Refactor extension app icon.

chrome/browser/ui/app_list/extension_app_item.cc

 // Copyright (c) 2012 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/ui/app_list/extension_app_item.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/metrics/user_metrics.h"
 #include "build/build_config.h"
+#include "chrome/browser/extensions/chrome_app_icon.h"
+#include "chrome/browser/extensions/chrome_app_icon_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_controller_delegate.h"
 #include "chrome/browser/ui/app_list/extension_app_context_menu.h"
 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_metrics.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/prefs/pref_service.h"
 #include "components/sync/model/string_ordinal.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "extensions/common/manifest_url_handlers.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/skia_util.h"
-#include "chrome/browser/chromeos/extensions/gfx_utils.h"
 
 using extensions::Extension;
 
-namespace {
-
-// Overlays a shortcut icon over the bottom left corner of a given image.
-class ShortcutOverlayImageSource : public gfx::CanvasImageSource {
- public:
-  explicit ShortcutOverlayImageSource(const gfx::ImageSkia& icon)
-      : gfx::CanvasImageSource(icon.size(), false),
-        icon_(icon) {
-  }
-  ~ShortcutOverlayImageSource() override {}
-
- private:
-  // gfx::CanvasImageSource overrides:
-  void Draw(gfx::Canvas* canvas) override {
-    canvas->DrawImageInt(icon_, 0, 0);
-
-    // Draw the overlay in the bottom left corner of the icon.
-    const gfx::ImageSkia& overlay = *ui::ResourceBundle::GetSharedInstance().
-        GetImageSkiaNamed(IDR_APP_LIST_TAB_OVERLAY);
-    canvas->DrawImageInt(overlay, 0, icon_.height() - overlay.height());
-  }
-
-  gfx::ImageSkia icon_;
-
-  DISALLOW_COPY_AND_ASSIGN(ShortcutOverlayImageSource);
-};
-
-// 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.
-    const size_t kRoundingRadius = 2;
-
-    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()),
-                          kRoundingRadius, mask_flags);
-
-    canvas->Restore();
-  }
-
-  gfx::ImageSkia icon_;
-
-  DISALLOW_COPY_AND_ASSIGN(RoundedCornersImageSource);
-};
-
-}  // namespace
-
 ExtensionAppItem::ExtensionAppItem(
     Profile* profile,
     const app_list::AppListSyncableService::SyncItem* sync_item,
     const std::string& extension_id,
     const std::string& extension_name,
     const gfx::ImageSkia& installing_icon,
     bool is_platform_app)
     : ChromeAppListItem(profile, extension_id),
       extension_enable_flow_controller_(NULL),
       extension_name_(extension_name),
       installing_icon_(CreateDisabledIcon(installing_icon)),
       is_platform_app_(is_platform_app) {
   Reload();
   if (sync_item && sync_item->item_ordinal.IsValid())
     UpdateFromSync(sync_item);
   else
     SetDefaultPositionIfApplicable();
 }
 
 ExtensionAppItem::~ExtensionAppItem() {
 }
 
 void ExtensionAppItem::Reload() {
   const Extension* extension = GetExtension();
   bool is_installing = !extension;
   SetIsInstalling(is_installing);
   if (is_installing) {
     SetName(extension_name_);
-    UpdateIcon();
+    SetIcon(installing_icon_);
     return;
   }
   SetNameAndShortName(extension->name(), extension->short_name());
-  LoadImage(extension);
+  if (!icon_) {
+    icon_ = extensions::ChromeAppIconService::Get(profile())->CreateIcon(
+        this, extension_id(), extension_misc::EXTENSION_ICON_MEDIUM);
+  } else {
+    icon_->Reload();
+  }
 }
 
-void ExtensionAppItem::UpdateIcon() {
-  gfx::ImageSkia icon = installing_icon_;
-
-  // Use the app icon if the app exists. Turn the image greyscale if the app is
-  // not launchable.
-  if (GetExtension() && icon_) {
-    icon = icon_->image_skia();
-    const bool enabled = extensions::util::IsAppLaunchable(extension_id(),
-                                                           profile());
-    extensions::util::MaybeApplyChromeBadge(profile(), id(), &icon);
-
-    if (!enabled)
-      icon = CreateDisabledIcon(icon);
-
-    if (GetExtension()->from_bookmark())
-      icon = gfx::ImageSkia(new RoundedCornersImageSource(icon), icon.size());
-  }
-  SetIcon(icon);
+void ExtensionAppItem::OnIconUpdated(extensions::ChromeAppIcon* icon) {
+  SetIcon(icon->IsValid() ? icon->image_skia() : installing_icon_);
 }
 
 const Extension* ExtensionAppItem::GetExtension() const {
   const extensions::ExtensionRegistry* registry =
       extensions::ExtensionRegistry::Get(profile());
   const Extension* extension = registry->GetInstalledExtension(
       extension_id());
   return extension;
 }
 
-void ExtensionAppItem::LoadImage(const Extension* extension) {
-  icon_.reset(new extensions::IconImage(
-      profile(),
-      extension,
-      extensions::IconsInfo::GetIcons(extension),
-      extension_misc::EXTENSION_ICON_MEDIUM,
-      extensions::util::GetDefaultAppIcon(),
-      this));
-  UpdateIcon();
-}
-
 bool ExtensionAppItem::RunExtensionEnableFlow() {
   if (extensions::util::IsAppLaunchableWithoutEnabling(extension_id(),
                                                        profile()))
     return false;
 
   if (!extension_enable_flow_) {
     extension_enable_flow_controller_ = GetController();
     extension_enable_flow_controller_->OnShowChildDialog();
 
     extension_enable_flow_.reset(new ExtensionEnableFlow(
@@ skipping 16 matching lines @@
 
   if (RunExtensionEnableFlow())
     return;
 
   GetController()->LaunchApp(profile(),
                              extension,
                              AppListControllerDelegate::LAUNCH_FROM_APP_LIST,
                              event_flags);
 }
 
-void ExtensionAppItem::OnExtensionIconImageChanged(
-    extensions::IconImage* image) {
-  DCHECK(icon_.get() == image);
-  UpdateIcon();
-}
-
-void ExtensionAppItem::OnExtensionIconImageDestroyed(
-    extensions::IconImage* image) {
-  SetIcon(gfx::ImageSkia());
-}
-
 void ExtensionAppItem::ExtensionEnableFlowFinished() {
   extension_enable_flow_.reset();
   extension_enable_flow_controller_->OnCloseChildDialog();
   extension_enable_flow_controller_ = NULL;
 
   // Automatically launch app after enabling.
   Launch(ui::EF_NONE);
 }
 
 void ExtensionAppItem::ExtensionEnableFlowAborted(bool user_initiated) {
@@ skipping 35 matching lines @@
 // static
 const char ExtensionAppItem::kItemType[] = "ExtensionAppItem";
 
 const char* ExtensionAppItem::GetItemType() const {
   return ExtensionAppItem::kItemType;
 }
 
 void ExtensionAppItem::ExecuteLaunchCommand(int event_flags) {
   Launch(event_flags);
 }