patch from issue 2577273002 at patchset 20001 (http://crrev.com/2577273002#ps20001)

chrome/browser/icon_manager.cc

Index: chrome/browser/icon_manager.cc
diff --git a/chrome/browser/icon_manager.cc b/chrome/browser/icon_manager.cc
index 1796f417fadcd22cc2d0d79625b8daa2ceb88b63..75cfc0c6684909a164db2ba2e28c501942c56d7d 100644
--- a/chrome/browser/icon_manager.cc
+++ b/chrome/browser/icon_manager.cc
@@ -8,6 +8,7 @@
 #include <tuple>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/task_runner.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
@@ -16,16 +17,17 @@ namespace {
 
 void RunCallbackIfNotCanceled(
     const base::CancelableTaskTracker::IsCanceledCallback& is_canceled,
-    const IconManager::IconRequestCallback& callback,
+    IconManager::IconRequestCallback callback,
     gfx::Image* image) {
   if (is_canceled.Run())
     return;
-  callback.Run(image);
+  std::move(callback).Run(image);
 }
 
 }  // namespace
 
 struct IconManager::ClientRequest {
+  std::unique_ptr<IconLoader> loader;
   IconRequestCallback callback;
   base::FilePath file_path;
   IconLoader::IconSize size;
@@ -54,50 +56,50 @@ gfx::Image* IconManager::LookupIconFromFilepath(const base::FilePath& file_path,
 base::CancelableTaskTracker::TaskId IconManager::LoadIcon(
     const base::FilePath& file_path,
     IconLoader::IconSize size,
-    const IconRequestCallback& callback,
+    IconRequestCallback callback,
     base::CancelableTaskTracker* tracker) {
-  IconLoader* loader = new IconLoader(file_path, size, this);
-  loader->AddRef();
+  auto loader = base::MakeUnique<IconLoader>(
+      file_path, size,
+      base::Bind(&IconManager::OnIconLoaded, base::Unretained(this)));
   loader->Start();
 
   base::CancelableTaskTracker::IsCanceledCallback is_canceled;
   base::CancelableTaskTracker::TaskId id =
       tracker->NewTrackedTaskId(&is_canceled);
   IconRequestCallback callback_runner = base::Bind(
-      &RunCallbackIfNotCanceled, is_canceled, callback);
+      &RunCallbackIfNotCanceled, is_canceled, base::Passed(&callback));
 
-  requests_[loader] = {callback_runner, file_path, size};
+  IconLoader* loader_ptr = loader.get();
+  requests_[loader_ptr] = {std::move(loader), std::move(callback_runner),
+                           file_path, size};
   return id;
 }
 
-// IconLoader::Delegate implementation -----------------------------------------
-
-void IconManager::OnImageLoaded(IconLoader* loader,
-                                std::unique_ptr<gfx::Image> result,
-                                const IconLoader::IconGroup& group) {
+void IconManager::OnIconLoaded(IconLoader* loader,
+                               std::unique_ptr<gfx::Image> result,
+                               const IconLoader::IconGroup& group) {
   auto request_it = requests_.find(loader);
   DCHECK(request_it != requests_.end());
 
-  // Balances the AddRef() in LoadIcon().
-  loader->Release();
-
-  const ClientRequest& client_request = request_it->second;
+  // TODO(jbroman): Or you could take a ClientRequest& here and keep the erase
+  // where it was, for marginally more efficiency, but it's less obvious whether
+  // the move is safe.
+  ClientRequest client_request = std::move(request_it->second);
+  requests_.erase(request_it);
 
   // Cache the bitmap. Watch out: |result| may be null, which indicates a
   // failure. We assume that if we have an entry in |icon_cache_| it must not be
   // null.
   CacheKey key(group, client_request.size);
   if (result) {
-    client_request.callback.Run(result.get());
+    std::move(client_request.callback).Run(result.get());
     icon_cache_[key] = std::move(result);
   } else {
-    client_request.callback.Run(nullptr);
+    std::move(client_request.callback).Run(nullptr);
     icon_cache_.erase(key);
   }
 
   group_cache_[client_request.file_path] = group;
-
-  requests_.erase(request_it);
 }
 
 IconManager::CacheKey::CacheKey(const IconLoader::IconGroup& group,