Refactor extension app icon.

chrome/browser/extensions/extension_app_icon.cc

+// Copyright 2017 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/extensions/extension_app_icon.h"
+
+#include <algorithm>
+
+#include "chrome/browser/extensions/extension_app_icon_delegate.h"
+#include "chrome/browser/extensions/extension_app_icon_service.h"

[xiyuan, 2017/04/20 17:52:46]

remove ?

[khmel, 2017/04/20 18:01:11]

Done.

+#include "chrome/browser/extensions/extension_util.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/common/manifest_handlers/icons_handler.h"
+#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/image/canvas_image_source.h"
+#include "ui/gfx/image/image_skia_operations.h"
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/extensions/gfx_utils.h"
+#endif
+
+namespace extensions {
+
+namespace {
+
+gfx::ImageSkia CreateDisabledIcon(const gfx::ImageSkia& icon) {
+  const color_utils::HSL shift = {-1, 0, 0.6};
+  return gfx::ImageSkiaOperations::CreateHSLShiftedImage(icon, shift);
+}
+
+// Rounds the corners of a given image.
+class RoundedCornersImageSource : public gfx::CanvasImageSource {
+ public:
+  explicit RoundedCornersImageSource(const gfx::ImageSkia& icon)
+      : gfx::CanvasImageSource(icon.size(), false), icon_(icon) {}
+  ~RoundedCornersImageSource() override {}
+
+ private:
+  // gfx::CanvasImageSource overrides:
+  void Draw(gfx::Canvas* canvas) override {
+    // The radius used to round the app icon, based on 2 pixel per 48 pixels
+    // icon size.
+    const int rounding_radius =
+        std::max((int)std::round(2.0 * icon_.width() / 48.0), 1);
+
+    canvas->DrawImageInt(icon_, 0, 0);
+
+    cc::PaintFlags masking_flags;
+    masking_flags.setBlendMode(SkBlendMode::kDstIn);
+    canvas->SaveLayerWithFlags(masking_flags);
+
+    cc::PaintFlags mask_flags;
+    mask_flags.setAntiAlias(true);
+    mask_flags.setColor(SK_ColorWHITE);
+    canvas->DrawRoundRect(gfx::Rect(icon_.width(), icon_.height()),
+                          rounding_radius, mask_flags);
+
+    canvas->Restore();
+  }
+
+  gfx::ImageSkia icon_;
+
+  DISALLOW_COPY_AND_ASSIGN(RoundedCornersImageSource);
+};
+
+}  // namespace
+
+ExtensionAppIcon::ExtensionAppIcon(ExtensionAppIconDelegate* delegate,
+                                   content::BrowserContext* context,
+                                   Closure close_callback,
+                                   const std::string& app_id,
+                                   int resource_size_in_dip)
+    : delegate_(delegate),
+      context_(context),
+      close_callback_(close_callback),
+      app_id_(app_id),
+      resource_size_in_dip_(resource_size_in_dip) {
+  DCHECK(delegate_);
+  DCHECK(context_);
+  DCHECK(!close_callback_.is_null());
+  DCHECK_GE(resource_size_in_dip, 0);
+  Reload();
+}
+
+ExtensionAppIcon::~ExtensionAppIcon() {
+  close_callback_.Run(this);
+}
+
+const extensions::Extension* ExtensionAppIcon::GetExtension() {
+  const extensions::Extension* extension =
+      extensions::ExtensionRegistry::Get(context_)->GetInstalledExtension(
+          app_id_);
+  return extension;
+}
+
+bool ExtensionAppIcon::IsValid() const {
+  return icon_ && icon_->is_valid();
+}
+
+void ExtensionAppIcon::Reload() {
+  const extensions::Extension* extension = GetExtension();
+  icon_ = base::MakeUnique<extensions::IconImage>(
+      context_, extension, extensions::IconsInfo::GetIcons(extension),
+      resource_size_in_dip_, extensions::util::GetDefaultAppIcon(), this);
+  UpdateIcon();
+}
+
+void ExtensionAppIcon::UpdateIcon() {
+  DCHECK(icon_);
+
+  image_skia_ = icon_->image_skia();
+#if defined(OS_CHROMEOS)
+  extensions::util::MaybeApplyChromeBadge(context_, app_id_, &image_skia_);
+#endif
+
+  const bool enabled = extensions::util::IsAppLaunchable(app_id_, context_);
+  if (!enabled)
+    image_skia_ = CreateDisabledIcon(image_skia_);
+
+  const extensions::Extension* extension = GetExtension();
+  if (extension && extension->from_bookmark())
+    image_skia_ = gfx::ImageSkia(new RoundedCornersImageSource(image_skia_),
+                                 image_skia_.size());
+
+  delegate_->OnIconUpdated(this);
+}
+
+void ExtensionAppIcon::EnsureRepsForSupportedScales() {
+  DCHECK(icon_);
+  icon_->image_skia().EnsureRepsForSupportedScales();
+}
+
+void ExtensionAppIcon::OnExtensionIconImageChanged(
+    extensions::IconImage* icon) {
+  DCHECK_EQ(icon_.get(), icon);
+  UpdateIcon();
+}
+
+}  // namespace extensions