chrome/browser/icon_manager.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/icon_manager.h"
   6
   7 #include <memory>
   8 #include <tuple>
   9
  10 #include "base/bind.h"
  11 #include "base/task_runner.h"
  12 #include "third_party/skia/include/core/SkBitmap.h"
  13 #include "third_party/skia/include/core/SkCanvas.h"
  14
  15 namespace {
  16
  17 void RunCallbackIfNotCanceled(
  18     const base::CancelableTaskTracker::IsCanceledCallback& is_canceled,
  19     IconManager::IconRequestCallback callback,
  20     gfx::Image image) {
  21   if (is_canceled.Run())
  22     return;
  23   std::move(callback).Run(std::move(image));
  24 }
  25
  26 }  // namespace
  27
  28 IconManager::IconManager() {}
  29
  30 IconManager::~IconManager() {
  31 }
  32
  33 gfx::Image* IconManager::LookupIconFromFilepath(const base::FilePath& file_path,
  34                                                 IconLoader::IconSize size) {
  35   auto group_it = group_cache_.find(file_path);
  36   if (group_it == group_cache_.end())
  37     return nullptr;
  38
  39   CacheKey key(group_it->second, size);
  40   auto icon_it = icon_cache_.find(key);
  41   if (icon_it == icon_cache_.end())
  42     return nullptr;
  43
  44   return &icon_it->second;
  45 }
  46
  47 base::CancelableTaskTracker::TaskId IconManager::LoadIcon(
  48     const base::FilePath& file_path,
  49     IconLoader::IconSize size,
  50     IconRequestCallback callback,
  51     base::CancelableTaskTracker* tracker) {
  52   base::CancelableTaskTracker::IsCanceledCallback is_canceled;
  53   base::CancelableTaskTracker::TaskId id =
  54       tracker->NewTrackedTaskId(&is_canceled);
  55   IconRequestCallback callback_runner = base::BindOnce(
  56       &RunCallbackIfNotCanceled, is_canceled, std::move(callback));
  57
  58   IconLoader* loader = IconLoader::Create(
  59       file_path, size,
  60       base::BindOnce(&IconManager::OnIconLoaded, weak_factory_.GetWeakPtr(),
  61                      std::move(callback_runner), file_path, size));
  62   loader->Start();
  63
  64   return id;
  65 }
  66
  67 void IconManager::OnIconLoaded(IconRequestCallback callback,
  68                                base::FilePath file_path,
  69                                IconLoader::IconSize size,
  70                                gfx::Image result,
  71                                const IconLoader::IconGroup& group) {
  72   // Cache the bitmap. Watch out: |result| may be null, which indicates a
  73   // failure. We assume that if we have an entry in |icon_cache_| it must not be
  74   // null.
  75   CacheKey key(group, size);
  76   std::move(callback).Run(result);
  77   if (!result.IsEmpty())
  78     icon_cache_[key] = std::move(result);
  79   else
  80     icon_cache_.erase(key);
  81
  82   group_cache_[file_path] = group;
  83 }
  84
  85 IconManager::CacheKey::CacheKey(const IconLoader::IconGroup& group,
  86                                 IconLoader::IconSize size)
  87     : group(group), size(size) {}
  88
  89 bool IconManager::CacheKey::operator<(const CacheKey &other) const {
  90   return std::tie(group, size) < std::tie(other.group, other.size);
  91 }