// Copyright 2011 The Chromium Authors
// 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/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/task/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,
    IconManager::IconRequestCallback callback,
    gfx::Image image) {
  if (is_canceled.Run())
    return;
  std::move(callback).Run(std::move(image));
}

}  // namespace

IconManager::IconManager() = default;

IconManager::~IconManager() = default;

gfx::Image* IconManager::LookupIconFromFilepath(const base::FilePath& file_path,
                                                IconLoader::IconSize size,
                                                float scale) {
  // Since loading the icon is synchronous on Chrome OS (and doesn't require
  // disk access), if it hasn't already been loaded, load immediately.
#if BUILDFLAG(IS_CHROMEOS)
  gfx::Image* image = DoLookupIconFromFilepath(file_path, size, scale);
  if (image)
    return image;

  IconLoader::LoadIcon(
      file_path, size, scale,
      base::BindOnce(&IconManager::OnIconLoaded, weak_factory_.GetWeakPtr(),
                     base::DoNothing(), file_path, size, scale));
#endif
  return DoLookupIconFromFilepath(file_path, size, scale);
}

base::CancelableTaskTracker::TaskId IconManager::LoadIcon(
    const base::FilePath& file_path,
    IconLoader::IconSize size,
    float scale,
    IconRequestCallback callback,
    base::CancelableTaskTracker* tracker) {
  base::CancelableTaskTracker::IsCanceledCallback is_canceled;
  base::CancelableTaskTracker::TaskId id =
      tracker->NewTrackedTaskId(&is_canceled);
  IconRequestCallback callback_runner = base::BindOnce(
      &RunCallbackIfNotCanceled, is_canceled, std::move(callback));

  IconLoader::LoadIcon(
      file_path, size, scale,
      base::BindOnce(&IconManager::OnIconLoaded, weak_factory_.GetWeakPtr(),
                     std::move(callback_runner), file_path, size, scale));

  return id;
}

gfx::Image* IconManager::DoLookupIconFromFilepath(
    const base::FilePath& file_path,
    IconLoader::IconSize size,
    float scale) {
  auto group_it = group_cache_.find(file_path);
  if (group_it == group_cache_.end())
    return nullptr;

  CacheKey key(group_it->second, size, scale);
  auto icon_it = icon_cache_.find(key);
  if (icon_it == icon_cache_.end())
    return nullptr;

  return &icon_it->second;
}

void IconManager::OnIconLoaded(IconRequestCallback callback,
                               base::FilePath file_path,
                               IconLoader::IconSize size,
                               float scale,
                               gfx::Image result,
                               const IconLoader::IconGroup& group) {
  // 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, size, scale);
  std::move(callback).Run(result);
  if (!result.IsEmpty())
    icon_cache_[key] = std::move(result);
  else
    icon_cache_.erase(key);

  group_cache_[file_path] = group;
}

IconManager::CacheKey::CacheKey(const IconLoader::IconGroup& group,
                                IconLoader::IconSize size,
                                float scale)
    : group(group), size(size), scale(scale) {}

bool IconManager::CacheKey::operator<(const CacheKey& other) const {
  return std::tie(group, size, scale) <
         std::tie(other.group, other.size, other.scale);
}