Removing base::ThreadRestrictions::ScopedAllowIO from icon_manager_linux.cc

chrome/browser/icon_manager.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Class for finding and caching Windows explorer icons. The IconManager
 // lives on the UI thread but performs icon extraction work on the file thread
 // to avoid blocking the UI thread with potentially expensive COM and disk
 // operations.
 //
 // Terminology
@@ skipping 29 matching lines @@
 // fast.
 //
 // Icon bitmaps returned should be treated as const since they may be referenced
 // by other clients. Make a copy of the icon if you need to modify it.
 
 #ifndef CHROME_BROWSER_ICON_MANAGER_H_
 #define CHROME_BROWSER_ICON_MANAGER_H_
 
 #include <map>
 
+#include "base/file_path.h"
 #include "chrome/browser/icon_loader.h"
 #include "chrome/common/cancelable_task_tracker.h"
 #include "ui/gfx/image/image.h"
 
-namespace base {
-class FilePath;
-}
-
 class IconManager : public IconLoader::Delegate {
  public:
   IconManager();
   virtual ~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* LookupIcon(const base::FilePath& file_name, IconLoader::IconSize size);
+  gfx::Image* LookupIconFromFilepath(const base::FilePath& file_name,
+                                     IconLoader::IconSize size);
+  gfx::Image* LookupIconFromGroup(const IconGroupID& group,

[Robert Sesek, 2013/02/12 16:49:25]

Does this need to be public?

[shatch, 2013/02/13 16:14:52]

Doesn't need to be, but I made it public in case anybody in the future wants
access to it. I can make it private if it's an issue.

[Robert Sesek, 2013/02/13 17:33:05]

I prefer a minimally exposed interface. But your call.

[shatch, 2013/02/21 20:02:06]

Done.

+                                  IconLoader::IconSize size);
 
   typedef base::Callback<void(gfx::Image*)> IconRequestCallback;
 
   // 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
   // this function is called.
   //
   // Note:
   // 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
   //    failed.
   CancelableTaskTracker::TaskId LoadIcon(const base::FilePath& file_name,
                                          IconLoader::IconSize size,
                                          const IconRequestCallback& callback,
                                          CancelableTaskTracker* tracker);
 
   // IconLoader::Delegate interface.
-  virtual bool OnImageLoaded(IconLoader* loader, gfx::Image* result) OVERRIDE;
+  virtual bool OnImageLoaded(IconLoader* loader,
+                             gfx::Image* result,
+                             const IconGroupID& group) OVERRIDE;
+

[Robert Sesek, 2013/02/12 16:49:25]

nit: no blank line needed

[shatch, 2013/02/13 16:14:52]

Done.

+  virtual bool OnGroupLoaded(IconLoader* loader,
+                             const IconGroupID& group) OVERRIDE;
 
   // Get the identifying string for the given file. The implementation
   // is in icon_manager_[platform].cc.
-  static IconGroupID GetGroupIDFromFilepath(const base::FilePath& path);
+  static IconGroupID ReadGroupIDFromFilepath(const base::FilePath& path);
 
  private:
   struct CacheKey {
     CacheKey(const IconGroupID& group, IconLoader::IconSize size);
 
     // Used as a key in the map below, so we need this comparator.
     bool operator<(const CacheKey &other) const;
 
     IconGroupID group;
     IconLoader::IconSize size;
   };
 
   typedef std::map<CacheKey, gfx::Image*> IconMap;
   IconMap icon_cache_;
 
+  typedef std::map<FilePath, IconGroupID> GroupMap;

[Robert Sesek, 2013/02/12 16:49:25]

I'm not sure how much of a benefit this cache mapping will provide. My guess
would be not much, but that's just a guess.

[shatch, 2013/02/13 16:14:52]

From what I could see, it got used when you did things like drag. The same
filepath as the download would be used.

[Robert Sesek, 2013/02/13 17:33:05]

Ah, good point.

+  GroupMap group_cache_;
+
   // Asynchronous requests that have not yet been completed.
   struct ClientRequest;
   typedef std::map<IconLoader*, ClientRequest> ClientRequests;
   ClientRequests requests_;
 
   DISALLOW_COPY_AND_ASSIGN(IconManager);
 };
 
 #endif  // CHROME_BROWSER_ICON_MANAGER_H_