Clean up IconLoader.

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/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,
     gfx::Image* image) {
   if (is_canceled.Run())
     return;
   callback.Run(image);
 }
 
 }  // namespace
 
 struct IconManager::ClientRequest {
+  IconLoader* loader;

[sky, 2016/12/16 23:27:27]

Do you need this anymore?

[Avi (use Gerrit), 2016/12/17 02:28:53]

I don't need any of this any more :)

   IconRequestCallback callback;
   base::FilePath file_path;
   IconLoader::IconSize size;
 };
 
-IconManager::IconManager() {
-}
+IconManager::IconManager() : weak_factory_(this) {}
 
 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,
     base::CancelableTaskTracker* tracker) {
-  IconLoader* loader = new IconLoader(file_path, size, this);
-  loader->AddRef();
+  IconLoader* loader = IconLoader::Create(
+      file_path, size,
+      base::Bind(&IconManager::OnIconLoaded, weak_factory_.GetWeakPtr()));
   loader->Start();
 
   base::CancelableTaskTracker::IsCanceledCallback is_canceled;
   base::CancelableTaskTracker::TaskId id =
       tracker->NewTrackedTaskId(&is_canceled);
   IconRequestCallback callback_runner = base::Bind(
       &RunCallbackIfNotCanceled, is_canceled, callback);
 
-  requests_[loader] = {callback_runner, file_path, size};
+  requests_[loader] = {loader, 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;
 
   // 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());
     icon_cache_[key] = std::move(result);
   } else {
     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);
 }