mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Update icon loading API implementation

Browse source
This commit is contained in:
Yury Solovyov 2017-02-16 22:19:19 +03:00
parent 19b686c90b
commit 977abc6458
9 changed files with 176 additions and 243 deletions
Download patch file Download diff file Expand all files Collapse all files

70
chromium_src/chrome/browser/icon_manager.h
View file

@ -34,7 +34,7 @@
// 2. An asynchronous icon load from a file on the file thread:
// IconManager::LoadIcon()
//
// When using the second (asychronous) method, callers must supply a callback
// When using the second (asynchronous) method, callers must supply a callback
// which will be run once the icon has been extracted. The icon manager will
// cache the results of the icon extraction so that subsequent lookups will be
// fast.
@ -46,25 +46,29 @@
#define CHROME_BROWSER_ICON_MANAGER_H_
#include <map>
#include <memory>
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/memory/singleton.h"
#include "base/memory/weak_ptr.h"
#include "base/task/cancelable_task_tracker.h"
#include "chrome/browser/icon_loader.h"
#include "ui/gfx/image/image.h"
class IconManager : public IconLoader::Delegate {
class IconManager {
public:
static IconManager* GetInstance();
IconManager();
~IconManager();
// Synchronous call to examine the internal caches for the icon. Returns the
// icon if we have already loaded it, NULL if we don't have it and must load
// it via 'LoadIcon'. The returned bitmap is owned by the IconManager and must
// not be free'd by the caller. If the caller needs to modify the icon, it
// must make a copy and modify the copy.
gfx::Image* LookupIconFromFilepath(const base::FilePath& file_name,
// icon if we have already loaded it, or null if we don't have it and must
// load it via LoadIcon(). The returned bitmap is owned by the IconManager and
// must not be free'd by the caller. If the caller needs to modify the icon,
// it must make a copy and modify the copy.
gfx::Image* LookupIconFromFilepath(const base::FilePath& file_path,
IconLoader::IconSize size);
typedef base::Callback<void(gfx::Image*)> IconRequestCallback;
using IconRequestCallback = base::Callback<void(gfx::Image*)>;
// Asynchronous call to lookup and return the icon associated with file. The
// work is done on the file thread, with the callbacks running on the thread
@ -74,47 +78,35 @@ class IconManager : public IconLoader::Delegate {
// 1. This does *not* check the cache.
// 2. The returned bitmap pointer is *not* owned by callback. So callback
// should never keep it or delete it.
// 3. The gfx::Image pointer passed to the callback may be NULL if decoding
// 3. The gfx::Image pointer passed to the callback will be null if decoding
// failed.
void LoadIcon(const base::FilePath& file_name,
IconLoader::IconSize size,
const IconRequestCallback& callback);
// IconLoader::Delegate interface.
bool OnGroupLoaded(IconLoader* loader, const IconGroupID& group) override;
bool OnImageLoaded(IconLoader* loader,
gfx::Image* result,
const IconGroupID& group) override;
base::CancelableTaskTracker::TaskId LoadIcon(
const base::FilePath& file_name,
IconLoader::IconSize size,
const IconRequestCallback& callback,
base::CancelableTaskTracker* tracker);
private:
friend struct base::DefaultSingletonTraits<IconManager>;
IconManager();
~IconManager() override;
void OnIconLoaded(IconRequestCallback callback,
base::FilePath file_path,
IconLoader::IconSize size,
std::unique_ptr<gfx::Image> result,
const IconLoader::IconGroup& group);
struct CacheKey {
CacheKey(const IconGroupID& group, IconLoader::IconSize size);
CacheKey(const IconLoader::IconGroup& group, IconLoader::IconSize size);
// Used as a key in the map below, so we need this comparator.
bool operator<(const CacheKey& other) const;
bool operator<(const CacheKey &other) const;
IconGroupID group;
IconLoader::IconGroup group;
IconLoader::IconSize size;
};
gfx::Image* LookupIconFromGroup(const IconGroupID& group,
IconLoader::IconSize size);
std::map<base::FilePath, IconLoader::IconGroup> group_cache_;
std::map<CacheKey, std::unique_ptr<gfx::Image>> icon_cache_;
typedef std::map<CacheKey, gfx::Image*> IconMap;
IconMap icon_cache_;
typedef std::map<base::FilePath, IconGroupID> GroupMap;
GroupMap group_cache_;
// Asynchronous requests that have not yet been completed.
struct ClientRequest;
typedef std::map<IconLoader*, ClientRequest> ClientRequests;
ClientRequests requests_;
base::WeakPtrFactory<IconManager> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(IconManager);
};