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

chrome/browser/icon_manager.cc

 // Copyright (c) 2011 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.
 
 #include "chrome/browser/icon_manager.h"
 
 #include <memory>
 #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"
 
 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;
 };
 
 IconManager::IconManager() {
 }
 
 IconManager::~IconManager() {
 }
 
 gfx::Image* IconManager::LookupIconFromFilepath(const base::FilePath& file_path,
                                                 IconLoader::IconSize size) {
   auto group_it = group_cache_.find(file_path);
   if (group_it == group_cache_.end())
     return nullptr;
 
   CacheKey key(group_it->second, size);
   auto icon_it = icon_cache_.find(key);
   if (icon_it == icon_cache_.end())
     return nullptr;
 
   return icon_it->second.get();
 }
 
 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,
                                 IconLoader::IconSize size)
     : group(group), size(size) {}
 
 bool IconManager::CacheKey::operator<(const CacheKey &other) const {
   return std::tie(group, size) < std::tie(other.group, other.size);
 }