// Copyright 2015 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/ash/app_list/arc/arc_app_icon.h"

#include <algorithm>
#include <map>
#include <memory>
#include <utility>
#include <vector>

#include "base/containers/contains.h"
#include "base/containers/span.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/lazy_instance.h"
#include "base/memory/raw_ref.h"
#include "base/no_destructor.h"
#include "base/task/thread_pool.h"
#include "chrome/browser/ash/app_list/arc/arc_app_icon_descriptor.h"
#include "chrome/browser/ash/app_list/arc/arc_app_list_prefs.h"
#include "chrome/browser/ash/app_list/arc/arc_app_utils.h"
#include "chrome/browser/image_decoder/image_decoder.h"
#include "chrome/browser/ui/ash/shelf/arc_app_shelf_id.h"
#include "chrome/grit/component_extension_resources.h"
#include "content/public/browser/browser_thread.h"
#include "extensions/grit/extensions_browser_resources.h"
#include "services/data_decoder/public/cpp/data_decoder.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/base/resource/resource_scale_factor.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/image/image_skia_operations.h"
#include "ui/gfx/image/image_skia_rep.h"
#include "ui/gfx/image/image_skia_source.h"

namespace {

bool disable_safe_decoding_for_testing = false;

data_decoder::DataDecoder& GetDataDecoder() {
  static base::NoDestructor<data_decoder::DataDecoder> data_decoder;
  return *data_decoder;
}

}  // namespace

////////////////////////////////////////////////////////////////////////////////
// ArcAppIcon::ReadResult

ArcAppIcon::ReadResult::ReadResult(bool error,
                                   bool request_to_install,
                                   ui::ResourceScaleFactor scale_factor,
                                   bool resize_allowed,
                                   std::vector<std::string> unsafe_icon_data)
    : error(error),
      request_to_install(request_to_install),
      scale_factor(scale_factor),
      resize_allowed(resize_allowed),
      unsafe_icon_data(std::move(unsafe_icon_data)) {}
ArcAppIcon::ReadResult::~ReadResult() = default;

////////////////////////////////////////////////////////////////////////////////
// ArcAppIcon::Source

// Initializes the ImageSkia with placeholder bitmaps, decoded from
// compiled-into-the-binary resources such as IDR_APP_DEFAULT_ICON, and
// schedules the asynchronous loading of the app's actual bitmaps.
class ArcAppIcon::Source : public gfx::ImageSkiaSource {
 public:
  Source(const base::WeakPtr<ArcAppIcon>& host, int resource_size_in_dip);

  Source(const Source&) = delete;
  Source& operator=(const Source&) = delete;

  ~Source() override;

 private:
  // gfx::ImageSkiaSource overrides:
  gfx::ImageSkiaRep GetImageForScale(float scale) override;

  // Used to load images asynchronously. NULLed out when the ArcAppIcon is
  // destroyed.
  base::WeakPtr<ArcAppIcon> host_;

  const int resource_size_in_dip_;

  // A map from a pair of a resource ID and size in DIP to an image. This
  // is a cache to avoid resizing IDR icons in GetImageForScale every time.
  static base::LazyInstance<std::map<std::pair<int, int>, gfx::ImageSkia>>::
      DestructorAtExit default_icons_cache_;
};

base::LazyInstance<std::map<std::pair<int, int>, gfx::ImageSkia>>::
    DestructorAtExit ArcAppIcon::Source::default_icons_cache_ =
        LAZY_INSTANCE_INITIALIZER;

ArcAppIcon::Source::Source(const base::WeakPtr<ArcAppIcon>& host,
                           int resource_size_in_dip)
    : host_(host),
      resource_size_in_dip_(resource_size_in_dip) {
}

ArcAppIcon::Source::~Source() = default;

gfx::ImageSkiaRep ArcAppIcon::Source::GetImageForScale(float scale) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  // Host loads icon asynchronously, so use default icon so far.
  int resource_id;
  if (host_ && host_->app_id() == arc::kPlayStoreAppId) {
    // Don't request icon from Android side. Use overloaded Chrome icon for Play
    // Store that is adapted according Chrome style.
    const int resource_size_in_px =
        static_cast<int>(resource_size_in_dip_ * scale + 0.5);
    resource_id = resource_size_in_px <= 32 ? IDR_ARC_SUPPORT_ICON_32_PNG
                                            : IDR_ARC_SUPPORT_ICON_192_PNG;
  } else {
    if (host_)
      host_->LoadForScaleFactor(ui::GetSupportedResourceScaleFactor(scale));
    resource_id = IDR_APP_DEFAULT_ICON;
  }

  // Check |default_icons_cache_| and returns the existing one if possible.
  const auto key = std::make_pair(resource_id, resource_size_in_dip_);
  const auto it = default_icons_cache_.Get().find(key);
  if (it != default_icons_cache_.Get().end())
    return it->second.GetRepresentation(scale);

  const gfx::ImageSkia* default_image =
      ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
  CHECK(default_image);
  gfx::ImageSkia resized_image = gfx::ImageSkiaOperations::CreateResizedImage(
      *default_image, skia::ImageOperations::RESIZE_BEST,
      gfx::Size(resource_size_in_dip_, resource_size_in_dip_));

  // Add the resized image to the cache to avoid executing the expensive resize
  // operation many times. Caching the result is safe because unlike ARC icons
  // that can be updated dynamically, IDR icons are static.
  default_icons_cache_.Get().insert(std::make_pair(key, resized_image));
  return resized_image.GetRepresentation(scale);
}

class ArcAppIcon::DecodeRequest : public ImageDecoder::ImageRequest {
 public:
  DecodeRequest(
      ArcAppIcon& host,
      const ArcAppIconDescriptor& descriptor,
      bool resize_allowed,
      bool retain_padding,
      gfx::ImageSkia& image_skia,
      std::map<ui::ResourceScaleFactor, base::Time>& incomplete_scale_factors);

  DecodeRequest(const DecodeRequest&) = delete;
  DecodeRequest& operator=(const DecodeRequest&) = delete;

  ~DecodeRequest() override;

  // ImageDecoder::ImageRequest
  void OnImageDecoded(const SkBitmap& bitmap) override;
  void OnDecodeImageFailed() override;

 private:
  const raw_ref<ArcAppIcon> host_;
  const ArcAppIconDescriptor descriptor_;
  const bool resize_allowed_;
  const bool retain_padding_;
  const raw_ref<gfx::ImageSkia> image_skia_;
  const raw_ref<std::map<ui::ResourceScaleFactor, base::Time>>
      incomplete_scale_factors_;
};

////////////////////////////////////////////////////////////////////////////////
// ArcAppIcon::DecodeRequest

ArcAppIcon::DecodeRequest::DecodeRequest(
    ArcAppIcon& host,
    const ArcAppIconDescriptor& descriptor,
    bool resize_allowed,
    bool retain_padding,
    gfx::ImageSkia& image_skia,
    std::map<ui::ResourceScaleFactor, base::Time>& incomplete_scale_factors)
    : ImageRequest(&GetDataDecoder()),
      host_(host),
      descriptor_(descriptor),
      resize_allowed_(resize_allowed),
      retain_padding_(retain_padding),
      image_skia_(image_skia),
      incomplete_scale_factors_(incomplete_scale_factors) {}

ArcAppIcon::DecodeRequest::~DecodeRequest() {
  ImageDecoder::Cancel(this);
}

void ArcAppIcon::DecodeRequest::OnImageDecoded(const SkBitmap& bitmap) {
  DCHECK(!bitmap.isNull() && !bitmap.empty());

  const int expected_dim = descriptor_.GetSizeInPixels();

  // If retain_padding is true, that means the foreground or the
  // background image has paddings which should be chopped by AppService, so the
  // raw image is forwarded without resize.
  if (!retain_padding_ &&
      (bitmap.width() != expected_dim || bitmap.height() != expected_dim)) {
    if (!resize_allowed_) {
      VLOG(2) << "Decoded ARC icon has unexpected dimension " << bitmap.width()
              << "x" << bitmap.height() << ". Expected " << expected_dim << ".";
      host_->MaybeRequestIcon(descriptor_.scale_factor);
    } else {
      host_->UpdateImageSkia(descriptor_.scale_factor,
                             skia::ImageOperations::Resize(
                                 bitmap, skia::ImageOperations::RESIZE_BEST,
                                 expected_dim, expected_dim),
                             *image_skia_, *incomplete_scale_factors_);
    }
  } else {
    host_->UpdateImageSkia(descriptor_.scale_factor, bitmap, *image_skia_,
                           *incomplete_scale_factors_);
  }

  host_->DiscardDecodeRequest(this, true /* bool is_decode_success */);
}

void ArcAppIcon::DecodeRequest::OnDecodeImageFailed() {
  VLOG(2) << "Failed to decode ARC icon.";
  host_->MaybeRequestIcon(descriptor_.scale_factor);
  host_->DiscardDecodeRequest(this, false /* bool is_decode_success*/);
}

////////////////////////////////////////////////////////////////////////////////
// ArcAppIcon

// static
void ArcAppIcon::DisableSafeDecodingForTesting() {
  disable_safe_decoding_for_testing = true;
}

// static
bool ArcAppIcon::IsSafeDecodingDisabledForTesting() {
  return disable_safe_decoding_for_testing;
}

ArcAppIcon::ArcAppIcon(content::BrowserContext* context,
                       const std::string& app_id,
                       int resource_size_in_dip,
                       Observer* observer,
                       IconType icon_type)
    : context_(context),
      app_id_(app_id),
      mapped_app_id_(arc::GetAppFromAppOrGroupId(context, app_id)),
      resource_size_in_dip_(resource_size_in_dip),
      observer_(observer),
      icon_type_(icon_type) {
  CHECK(observer_);

  gfx::Size resource_size(resource_size_in_dip, resource_size_in_dip);
  const std::vector<ui::ResourceScaleFactor>& scale_factors =
      ui::GetSupportedResourceScaleFactors();
  switch (icon_type) {
    case IconType::kAdaptive:
      foreground_image_skia_ = gfx::ImageSkia(
          std::make_unique<Source>(weak_ptr_factory_.GetWeakPtr(),
                                   resource_size_in_dip),
          resource_size);

      // ArcAppIcon::Source::GetImageForScale calls host_->LoadForScaleFactor to
      // read both the foreground and background files, so the
      // |background_image_skia_| doesn't need to set the host to call
      // LoadForScaleFactor again. Otherwise, it might duplicate the opened
      // files number, and cause the system crash,
      background_image_skia_ = gfx::ImageSkia(
          std::make_unique<Source>(nullptr, resource_size_in_dip),
          resource_size);
      for (const auto scale_factor : scale_factors) {
        foreground_incomplete_scale_factors_.insert(
            {scale_factor, base::Time::Now()});
        background_incomplete_scale_factors_.insert(
            {scale_factor, base::Time::Now()});
        is_adaptive_icons_.insert({scale_factor, true});
      }
      // Deliberately fall through to IconType::kUncompressed to update
      // |image_skia_| and |incomplete_scale_factors_|.
      [[fallthrough]];
    case IconType::kUncompressed:
      image_skia_ = gfx::ImageSkia(
          std::make_unique<Source>(weak_ptr_factory_.GetWeakPtr(),
                                   resource_size_in_dip),
          resource_size);
      // Deliberately fall through to IconType::kCompressed to update
      // |incomplete_scale_factors_|.
      [[fallthrough]];
    case IconType::kCompressed:
      for (const auto scale_factor : scale_factors) {
        incomplete_scale_factors_.insert({scale_factor, base::Time::Now()});
        if (icon_type != IconType::kAdaptive)
          is_adaptive_icons_.insert({scale_factor, false});
      }
      break;
  }
}

ArcAppIcon::~ArcAppIcon() = default;

void ArcAppIcon::LoadSupportedScaleFactors() {
  switch (icon_type_) {
    case IconType::kCompressed:
      for (auto scale_factor : incomplete_scale_factors_)
        LoadForScaleFactor(scale_factor.first);
      break;
    case IconType::kAdaptive:
      for (auto scale_factor : foreground_incomplete_scale_factors_) {
        foreground_image_skia_.GetRepresentation(
            ui::GetScaleForResourceScaleFactor(scale_factor.first));
      }
      for (auto scale_factor : background_incomplete_scale_factors_) {
        background_image_skia_.GetRepresentation(
            ui::GetScaleForResourceScaleFactor(scale_factor.first));
      }
      // Deliberately fall through to IconType::kCompressed to update
      // |image_skia_|.
      [[fallthrough]];
    case IconType::kUncompressed:
      // Calling GetRepresentation indirectly calls LoadForScaleFactor but also
      // first initializes image_skia_ with the placeholder icons (e.g.
      // IDR_APP_DEFAULT_ICON), via ArcAppIcon::Source::GetImageForScale.
      for (auto scale_factor : incomplete_scale_factors_) {
        image_skia_.GetRepresentation(
            ui::GetScaleForResourceScaleFactor(scale_factor.first));
      }
      break;
  }
}

bool ArcAppIcon::EverySupportedScaleFactorIsLoaded() {
  switch (icon_type_) {
    case IconType::kUncompressed:
      // Deliberately fall through to IconType::kCompressed to check
      // |incomplete_scale_factors_|.
      [[fallthrough]];
    case IconType::kCompressed:
      return incomplete_scale_factors_.empty();
    case IconType::kAdaptive: {
      // Check whether there is non-adaptive icon for any scale.
      bool is_adaptive_icon = true;
      for (const auto& it : is_adaptive_icons_) {
        if (!it.second) {
          is_adaptive_icon = false;
          break;
        }
      }

      // All scales have adaptive icon.
      if (is_adaptive_icon) {
        return foreground_incomplete_scale_factors_.empty() &&
               background_incomplete_scale_factors_.empty();
      }

      // Some scales have non-adaptive icons. Copy the decode image
      // representation from |foreground_image_skia_| to |image_skia_|.
      for (auto it = is_adaptive_icons_.begin(); it != is_adaptive_icons_.end();
           it++) {
        if (it->second &&
            !base::Contains(foreground_incomplete_scale_factors_, it->first)) {
          it->second = false;
          float scale = ui::GetScaleForResourceScaleFactor(it->first);
          image_skia_.RemoveRepresentation(scale);
          image_skia_.AddRepresentation(
              foreground_image_skia_.GetRepresentation(scale));
          image_skia_.RemoveUnsupportedRepresentationsForScale(scale);
          incomplete_scale_factors_.erase(it->first);
        }
      }

      return incomplete_scale_factors_.empty();
    }
  }
}

void ArcAppIcon::LoadForScaleFactor(ui::ResourceScaleFactor scale_factor) {
  // We provide Play Store icon from Chrome resources and it is not expected
  // that we have external load request.
  DCHECK_NE(app_id(), arc::kPlayStoreAppId);

  ArcAppListPrefs* const prefs = ArcAppListPrefs::Get(context_);
  DCHECK(prefs);

  const ArcAppIconDescriptor descriptor(resource_size_in_dip_, scale_factor);
  std::vector<base::FilePath> paths;
  std::vector<base::FilePath> default_app_paths;
  switch (icon_type_) {
    case IconType::kAdaptive: {
      base::FilePath foreground_path =
          prefs->GetForegroundIconPath(mapped_app_id_, descriptor);
      base::FilePath background_path =
          prefs->GetBackgroundIconPath(mapped_app_id_, descriptor);
      if (foreground_path.empty() || background_path.empty())
        return;
      paths.emplace_back(foreground_path);
      paths.emplace_back(background_path);

      default_app_paths.emplace_back(
          prefs->MaybeGetForegroundIconPathForDefaultApp(mapped_app_id_,
                                                         descriptor));
      default_app_paths.emplace_back(
          prefs->MaybeGetBackgroundIconPathForDefaultApp(mapped_app_id_,
                                                         descriptor));
      // Deliberately fall through to IconType::kCompressed to add |path| to
      // |paths|. For the migration scenario, when the foreground icon file
      // doesn't exist, load the original icon file to resolve the icon lag
      // issue.
      [[fallthrough]];
    }
    case IconType::kUncompressed: {
      // Deliberately fall through to IconType::kCompressed to add |path| to
      // |paths|.
      [[fallthrough]];
    }
    case IconType::kCompressed: {
      base::FilePath path = prefs->GetIconPath(mapped_app_id_, descriptor);
      if (path.empty())
        return;
      paths.emplace_back(path);
      default_app_paths.emplace_back(
          prefs->MaybeGetIconPathForDefaultApp(mapped_app_id_, descriptor));
      break;
    }
  }

  base::ThreadPool::PostTaskAndReplyWithResult(
      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
      base::BindOnce(&ArcAppIcon::ReadOnBackgroundThread, icon_type_,
                     scale_factor, paths, default_app_paths),
      base::BindOnce(&ArcAppIcon::OnIconRead, weak_ptr_factory_.GetWeakPtr()));
}

void ArcAppIcon::MaybeRequestIcon(ui::ResourceScaleFactor scale_factor) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  ArcAppListPrefs* prefs = ArcAppListPrefs::Get(context_);
  DCHECK(prefs);

  // ArcAppListPrefs notifies the ArcAppIconLoader (which is an
  // ArcAppListPrefs::Observer) when the icon is updated, and
  // ArcAppIconLoader::OnAppIconUpdated calls ArcAppIcon::LoadForScaleFactor on
  // the corresponding ArcAppIcon.
  prefs->MaybeRequestIcon(
      mapped_app_id_,
      ArcAppIconDescriptor(resource_size_in_dip_, scale_factor));
}

// static
std::unique_ptr<ArcAppIcon::ReadResult> ArcAppIcon::ReadOnBackgroundThread(
    ArcAppIcon::IconType icon_type,
    ui::ResourceScaleFactor scale_factor,
    const std::vector<base::FilePath>& paths,
    const std::vector<base::FilePath>& default_app_paths) {
  DCHECK(!paths.empty());

  switch (icon_type) {
    case IconType::kUncompressed:
      // Deliberately fall through to IconType::kCompressed.
      [[fallthrough]];
    case IconType::kCompressed:
      DCHECK_EQ(1u, paths.size());
      return ArcAppIcon::ReadSingleIconFile(scale_factor, paths[0],
                                            default_app_paths[0]);
    case IconType::kAdaptive:
      return ArcAppIcon::ReadAdaptiveIconFiles(scale_factor, paths,
                                               default_app_paths);
  }
}

// static
std::unique_ptr<ArcAppIcon::ReadResult> ArcAppIcon::ReadSingleIconFile(
    ui::ResourceScaleFactor scale_factor,
    const base::FilePath& path,
    const base::FilePath& default_app_path) {
  DCHECK(!path.empty());

  base::FilePath path_to_read;
  // Allow resizing only for default app icons.
  bool resize_allowed;
  if (base::PathExists(path)) {
    path_to_read = path;
    resize_allowed = false;
  } else {
    if (default_app_path.empty() || !base::PathExists(default_app_path)) {
      return std::make_unique<ArcAppIcon::ReadResult>(
          false /* error */, true /* request_to_install */, scale_factor,
          false /* resize_allowed */,
          std::vector<std::string>() /* unsafe_icon_data */);
    }
    path_to_read = default_app_path;
    resize_allowed = true;
  }

  bool request_to_install = path_to_read != path;
  return ArcAppIcon::ReadFile(request_to_install, scale_factor, resize_allowed,
                              path_to_read);
}

// static
std::unique_ptr<ArcAppIcon::ReadResult> ArcAppIcon::ReadAdaptiveIconFiles(
    ui::ResourceScaleFactor scale_factor,
    const std::vector<base::FilePath>& paths,
    const std::vector<base::FilePath>& default_app_paths) {
  DCHECK_EQ(3u, paths.size());

  const base::FilePath& foreground_path = paths[0];
  const base::FilePath& background_path = paths[1];
  if (!base::PathExists(foreground_path)) {
    // For the migration scenario, when the foreground icon file doesn't
    // exist, load the original icon file to resolve the icon lag issue.
    if (!paths[2].empty() && base::PathExists(paths[2])) {
      return ArcAppIcon::ReadFile(true /* request_to_install */, scale_factor,
                                  false /* resize_allowed */, paths[2]);
    }

    // Check and read the default app icon path for the default app if the files
    // exist.
    return ReadDefaultAppAdaptiveIconFiles(scale_factor, default_app_paths);
  }

  if (!base::PathExists(background_path)) {
    // For non-adaptive icon, there could be a |foreground_icon_path| file
    // only without a |background_icon_path| file.
    return ArcAppIcon::ReadFile(false /* request_to_install */, scale_factor,
                                false /* resize_allowed */, foreground_path);
  }

  return ArcAppIcon::ReadFiles(false /* request_to_install */, scale_factor,
                               false /* resize_allowed */, foreground_path,
                               background_path);
}

// static
std::unique_ptr<ArcAppIcon::ReadResult>
ArcAppIcon::ReadDefaultAppAdaptiveIconFiles(
    ui::ResourceScaleFactor scale_factor,
    const std::vector<base::FilePath>& default_app_paths) {
  // Check the default app icon path, and read the icon files for the default
  // app if the files exist.
  DCHECK_EQ(3u, default_app_paths.size());
  const base::FilePath& default_app_foreground_path = default_app_paths[0];
  const base::FilePath& default_app_background_path = default_app_paths[1];
  if (default_app_foreground_path.empty() ||
      !base::PathExists(default_app_foreground_path)) {
    // For the migration scenario, when the foreground icon file doesn't
    // exist, load the original icon file to resolve the icon lag issue for
    // the default app.
    if (default_app_paths.size() == 3u && !default_app_paths[2].empty() &&
        base::PathExists(default_app_paths[2])) {
      return ArcAppIcon::ReadFile(true /* request_to_install */, scale_factor,
                                  true /* resize_allowed */,
                                  default_app_paths[2]);
    }

    return std::make_unique<ArcAppIcon::ReadResult>(
        false /* error */, true /* request_to_install */, scale_factor,
        false /* resize_allowed */,
        std::vector<std::string>() /* unsafe_icon_data */);
  }

  if (default_app_background_path.empty() ||
      !base::PathExists(default_app_background_path)) {
    // For non-adaptive icon, there could be a |default_app_foreground_path|
    // file only without a |default_app_background_path| file.
    return ArcAppIcon::ReadFile(true /* request_to_install */, scale_factor,
                                true /* resize_allowed */,
                                default_app_foreground_path);
  }

  return ArcAppIcon::ReadFiles(
      true /* request_to_install */, scale_factor, true /* resize_allowed */,
      default_app_foreground_path, default_app_background_path);
}

// static
std::unique_ptr<ArcAppIcon::ReadResult> ArcAppIcon::ReadFile(
    bool request_to_install,
    ui::ResourceScaleFactor scale_factor,
    bool resize_allowed,
    const base::FilePath& path) {
  // Read the file from disk. Sometimes, the file could be deleted, e.g. when
  // running unit tests, so check whether the file exists again.
  std::string unsafe_icon_data;
  if (path.empty() || !base::PathExists(path) ||
      !base::ReadFileToString(path, &unsafe_icon_data) ||
      unsafe_icon_data.empty()) {
    VLOG(2) << "Failed to read an ARC icon from file " << path.MaybeAsASCII();

    // If |unsafe_icon_data| is empty typically means we have a file corruption
    // on cached icon file. Send request to re install the icon.
    request_to_install |= unsafe_icon_data.empty();
    return std::make_unique<ArcAppIcon::ReadResult>(
        true /* error */, request_to_install, scale_factor,
        false /* resize_allowed */,
        std::vector<std::string>() /* unsafe_icon_data */);
  }

  return std::make_unique<ArcAppIcon::ReadResult>(
      false /* error */, request_to_install, scale_factor, resize_allowed,
      std::vector<std::string>{std::move(unsafe_icon_data)});
}

// static
std::unique_ptr<ArcAppIcon::ReadResult> ArcAppIcon::ReadFiles(
    bool request_to_install,
    ui::ResourceScaleFactor scale_factor,
    bool resize_allowed,
    const base::FilePath& foreground_path,
    const base::FilePath& background_path) {
  // Read the file from disk. Sometimes, the file could be deleted, e.g. when
  // running unit tests, so check whether the file exists again.
  std::string unsafe_foreground_icon_data;
  std::string unsafe_background_icon_data;
  if (foreground_path.empty() || !base::PathExists(foreground_path) ||
      !base::ReadFileToString(foreground_path, &unsafe_foreground_icon_data) ||
      unsafe_foreground_icon_data.empty()) {
    VLOG(2) << "Failed to read an ARC icon from file "
            << foreground_path.MaybeAsASCII();

    // If |unsafe_icon_data| is empty typically means we have a file corruption
    // on cached icon file. Send request to re install the icon.
    request_to_install |= unsafe_foreground_icon_data.empty();
    return std::make_unique<ArcAppIcon::ReadResult>(
        true /* error */, true /* request_to_install */, scale_factor,
        false /* resize_allowed */,
        std::vector<std::string>() /* unsafe_icon_data */);
  }

  if (background_path.empty() || !base::PathExists(background_path) ||
      !base::ReadFileToString(background_path, &unsafe_background_icon_data) ||
      unsafe_background_icon_data.empty()) {
    VLOG(2) << "Failed to read an ARC icon from file "
            << background_path.MaybeAsASCII();

    // If |unsafe_icon_data| is empty typically means we have a file corruption
    // on cached icon file. Send request to re install the icon.
    request_to_install |= unsafe_background_icon_data.empty();
    return std::make_unique<ArcAppIcon::ReadResult>(
        true /* error */, true /* request_to_install */, scale_factor,
        false /* resize_allowed */,
        std::vector<std::string>() /* unsafe_icon_data */);
  }

  return std::make_unique<ArcAppIcon::ReadResult>(
      false /* error */, request_to_install, scale_factor, resize_allowed,
      std::vector<std::string>{std::move(unsafe_foreground_icon_data),
                               std::move(unsafe_background_icon_data)});
}

void ArcAppIcon::OnIconRead(
    std::unique_ptr<ArcAppIcon::ReadResult> read_result) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  if (read_result->request_to_install)
    MaybeRequestIcon(read_result->scale_factor);

  if (read_result->unsafe_icon_data.empty()) {
    observer_->OnIconFailed(this);
    return;
  }

  switch (icon_type_) {
    case IconType::kUncompressed: {
      DCHECK_EQ(1u, read_result->unsafe_icon_data.size());
      DecodeImage(std::move(read_result->unsafe_icon_data[0]),
                  ArcAppIconDescriptor(resource_size_in_dip_,
                                       read_result->scale_factor),
                  read_result->resize_allowed, false /* retain_padding */,
                  image_skia_, incomplete_scale_factors_);
      return;
    }
    case IconType::kCompressed: {
      DCHECK_EQ(1u, read_result->unsafe_icon_data.size());
      UpdateCompressed(read_result->scale_factor,
                       std::move(read_result->unsafe_icon_data[0]));
      return;
    }
    case IconType::kAdaptive: {
      // For non-adaptive icons, |foreground_icon_path| is used to save the icon
      // without |background_icon_path|, so |unsafe_icon_data| could have one
      // element for |foreground_icon_path| only.
      if (read_result->unsafe_icon_data.size() == 1) {
        is_adaptive_icons_[read_result->scale_factor] = false;
        DecodeImage(std::move(read_result->unsafe_icon_data[0]),
                    ArcAppIconDescriptor(resource_size_in_dip_,
                                         read_result->scale_factor),
                    read_result->resize_allowed, false /* retain_padding */,
                    image_skia_, incomplete_scale_factors_);
        return;
      }

      DCHECK_EQ(2u, read_result->unsafe_icon_data.size());
      DecodeImage(std::move(read_result->unsafe_icon_data[0]),
                  ArcAppIconDescriptor(resource_size_in_dip_,
                                       read_result->scale_factor),
                  read_result->resize_allowed, true /* retain_padding */,
                  foreground_image_skia_, foreground_incomplete_scale_factors_);
      DecodeImage(std::move(read_result->unsafe_icon_data[1]),
                  ArcAppIconDescriptor(resource_size_in_dip_,
                                       read_result->scale_factor),
                  read_result->resize_allowed, true /* retain_padding */,
                  background_image_skia_, background_incomplete_scale_factors_);
      return;
    }
  }
}

void ArcAppIcon::DecodeImage(
    std::string unsafe_icon_data,
    const ArcAppIconDescriptor& descriptor,
    bool resize_allowed,
    bool retain_padding,
    gfx::ImageSkia& image_skia,
    std::map<ui::ResourceScaleFactor, base::Time>& incomplete_scale_factors) {
  decode_requests_.emplace_back(std::make_unique<DecodeRequest>(
      *this, descriptor, resize_allowed, retain_padding, image_skia,
      incomplete_scale_factors));
  if (disable_safe_decoding_for_testing) {
    if (unsafe_icon_data.empty()) {
      decode_requests_.back()->OnDecodeImageFailed();
    } else {
      SkBitmap bitmap =
          gfx::PNGCodec::Decode(base::as_byte_span(unsafe_icon_data));
      if (bitmap.isNull()) {
        decode_requests_.back()->OnDecodeImageFailed();
      } else {
        decode_requests_.back()->OnImageDecoded(bitmap);
      }
    }
  } else {
    ImageDecoder::Start(decode_requests_.back().get(),
                        std::move(unsafe_icon_data));
  }
}

void ArcAppIcon::UpdateImageSkia(
    ui::ResourceScaleFactor scale_factor,
    const SkBitmap& bitmap,
    gfx::ImageSkia& image_skia,
    std::map<ui::ResourceScaleFactor, base::Time>& incomplete_scale_factors) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  CHECK(ui::IsScaleFactorSupported(scale_factor));

  gfx::ImageSkiaRep image_rep(bitmap,
                              ui::GetScaleForResourceScaleFactor(scale_factor));
  image_skia.RemoveRepresentation(image_rep.scale());
  image_skia.AddRepresentation(image_rep);
  image_skia.RemoveUnsupportedRepresentationsForScale(image_rep.scale());

  incomplete_scale_factors.erase(scale_factor);
  observer_->OnIconUpdated(this);
}

void ArcAppIcon::UpdateCompressed(ui::ResourceScaleFactor scale_factor,
                                  std::string data) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  compressed_images_[scale_factor] = std::move(data);

  incomplete_scale_factors_.erase(scale_factor);
  observer_->OnIconUpdated(this);
}

void ArcAppIcon::DiscardDecodeRequest(DecodeRequest* request,
                                      bool is_decode_success) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  auto it = std::ranges::find(decode_requests_, request,
                              &std::unique_ptr<DecodeRequest>::get);
  DCHECK(it != decode_requests_.end());
  decode_requests_.erase(it);

  if (!is_decode_success)
    observer_->OnIconFailed(this);
}