Convert extension action icons code to use ImageSkia instead of SkBitmap

chrome/browser/ui/views/browser_action_view.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/views/browser_action_view.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/commands/command_service.h"
 #include "chrome/browser/extensions/api/commands/command_service_factory.h"
 #include "chrome/browser/extensions/extension_context_menu_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/views/browser_actions_container.h"
 #include "chrome/browser/ui/views/toolbar_view.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/skbitmap_operations.h"
+#include "ui/gfx/image/canvas_image_source.h"
+#include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/image/image_skia_source.h"
 #include "ui/views/controls/menu/menu_model_adapter.h"
 #include "ui/views/controls/menu/menu_runner.h"
 
 using extensions::Extension;
 
 namespace {
 
+// CanvasImageSource for creating an browser action icon image with the provided
+// background.
+class IconWithBackgroundImageSource : public gfx::CanvasImageSource {
+ public:
+  IconWithBackgroundImageSource(const gfx::ImageSkia& icon,
+                                const gfx::ImageSkia& background)
+      : gfx::CanvasImageSource(background.size(), false),
+        icon_(icon),
+        background_(background) {
+  }
+
+ private:
+  virtual ~IconWithBackgroundImageSource() {}
+
+  virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
+    SkPaint paint;
+    paint.setXfermode(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
+
+    // We center the icon on the background.
+    canvas->DrawImageInt(icon_,
+                         (background_.width() - icon_.width()) / 2,
+                         (background_.height() - icon_.height()) / 2,
+                         paint);
+  }
+
+  virtual gfx::ImageSkiaRep GetImageForScale(
+      ui::ScaleFactor scale_factor) OVERRIDE {
+    gfx::Canvas canvas(background_.GetRepresentation(scale_factor), is_opaque_);
+    Draw(&canvas);
+    return canvas.ExtractImageRep();

[pkotwicz, 2012/08/07 22:31:22]

A couple comments.
It feels like we could introduce ImageSkiaOperations::CreateSuperimposedImage
and it would have the desired behavior for IconWithBackgroundImageSource.
(It's up to you though as to what you feel is clearer)

You don't need to specify SkXfermode::kSrcOver_Mode as that's the default.
Can you paint the two images in ::Draw() instead of overriding GetImageForScale
here?
The canvas constructor which takes in an ImageSkiaRep draws the ImageSkiaRep so
you are not losing any efficiency.

[tbarzic, 2012/08/08 02:09:29]

Done.

+  }
+
+  gfx::ImageSkia icon_;
+  gfx::ImageSkia background_;
+};
+
+// ImageSource for creating an image to be used as alpha in CreateMaskedImage
+// image skia operation while creating transparent image.
+class TransparentAlphaImageSource : public gfx::ImageSkiaSource {
+ public:
+  TransparentAlphaImageSource(size_t width, size_t height)
+      : width_(width),
+        height_(height) {
+  }
+

[pkotwicz, 2012/08/07 22:31:22]

Nit: destructor

[tbarzic, 2012/08/08 02:09:29]

Done.

+ private:
+  virtual ~TransparentAlphaImageSource() {}
+
+  virtual gfx::ImageSkiaRep GetImageForScale(
+      ui::ScaleFactor scale_factor) OVERRIDE {
+    SkBitmap alpha;
+    const float scale = ui::GetScaleFactorScale(scale_factor);
+    alpha.setConfig(SkBitmap::kARGB_8888_Config,
+                    static_cast<int>(width_ * scale),
+                    static_cast<int>(height_ * scale));
+    alpha.allocPixels();
+    alpha.eraseColor(SkColorSetARGB(64, 0, 0, 0));
+    return gfx::ImageSkiaRep(alpha, scale_factor);
+  }
+
+  // Icon width in DIP.
+  size_t width_;
+  // Icon height in DIP.
+  size_t height_;
+};
+
 // Return a more transparent |image|, with 25% of its original opacity.
-SkBitmap MakeTransparent(const SkBitmap& image) {
-  SkBitmap alpha;
-  alpha.setConfig(SkBitmap::kARGB_8888_Config, image.width(), image.height());
-  alpha.allocPixels();
-  alpha.eraseColor(SkColorSetARGB(64, 0, 0, 0));
+gfx::ImageSkia MakeTransparent(const gfx::ImageSkia& image) {
+  gfx::ImageSkia alpha(
+      new TransparentAlphaImageSource(image.width(), image.height()),
+      gfx::Size(image.width(), image.height()));
+  return gfx::ImageSkiaOperations::CreateMaskedImage(image, alpha);
+}
 
-  return SkBitmapOperations::CreateMaskedBitmap(image, alpha);
-}
+// CanvasImageSource for creating browser action icon with a badge.
+class ActionBadgeImageSource : public gfx::CanvasImageSource {

[pkotwicz, 2012/08/07 22:31:22]

Can you move this to new function ExtensionAction::GetBadgeImage() ?

[tbarzic, 2012/08/08 02:09:29]

Done.

+ public:
+  ActionBadgeImageSource(gfx::ImageSkia icon,
+                         bool button_enabled,
+                         const std::string& text,
+                         const SkColor& text_color,
+                         const SkColor& background_color)
+      : gfx::CanvasImageSource(icon.size(), false),
+        icon_(icon),
+        button_enabled_(button_enabled),
+        text_(text),
+        text_color_(text_color),
+        background_color_(background_color) {
+  }
+

[pkotwicz, 2012/08/07 22:31:22]

Nit: destructor

[tbarzic, 2012/08/08 02:09:29]

Done.

+ private:
+  virtual ~ActionBadgeImageSource() {}
+
+  virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
+    // Draw a badge on the provided browser action icon's canvas.
+    gfx::Rect bounds(size_.width(),
+                     size_.height() + ToolbarView::kVertSpacing);
+    ExtensionAction::DoPaintBadge(canvas, bounds, text_, text_color_,
+        background_color_, size_.width());
+  }
+
+  virtual gfx::ImageSkiaRep GetImageForScale(
+      ui::ScaleFactor scale_factor) OVERRIDE {
+    gfx::ImageSkia icon = icon_;
+    if (!button_enabled_)
+      icon = MakeTransparent(icon);
+
+    gfx::Canvas canvas(icon.GetRepresentation(scale_factor), is_opaque_);
+    Draw(&canvas);
+    return canvas.ExtractImageRep();
+  }
+
+  // Browser action icon image.
+  gfx::ImageSkia icon_;
+  // Whether the browser actions button is enabled.
+  bool button_enabled_;
+  // Text to be displayed on the badge.
+  std::string text_;
+  // Color of badge text.
+  SkColor text_color_;
+  // Color of the badge.
+  SkColor background_color_;
+};
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserActionButton
 
 BrowserActionButton::BrowserActionButton(const Extension* extension,
                                          BrowserActionsContainer* panel)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           MenuButton(this, string16(), NULL, false)),
@@ skipping 91 matching lines @@
       views::MenuRunner::MENU_DELETED)
     return;
 
   SetButtonNotPushed();
   context_menu_ = NULL;
 }
 
 void BrowserActionButton::OnImageLoaded(const gfx::Image& image,
                                         const std::string& extension_id,
                                         int index) {
-  browser_action_->CacheIcon(browser_action_->default_icon_path(), image);
+  browser_action_->CacheIcon(browser_action_->default_icon_path(),
+                             *image.ToImageSkia());
 
   // Call back to UpdateState() because a more specific icon might have been set
   // while the load was outstanding.
   UpdateState();
 }
 
 void BrowserActionButton::UpdateState() {
   int tab_id = panel_->GetCurrentTabId();
   if (tab_id < 0)
     return;
 
   if (!IsEnabled(tab_id)) {
     SetState(views::CustomButton::BS_DISABLED);
   } else {
     SetState(menu_visible_ ?
              views::CustomButton::BS_PUSHED :
              views::CustomButton::BS_NORMAL);
   }
 
-  SkBitmap icon(*browser_action()->GetIcon(tab_id).ToSkBitmap());
+  gfx::ImageSkia icon(browser_action()->GetIcon(tab_id));
+
   if (!icon.isNull()) {
     if (!browser_action()->GetIsVisible(tab_id))
       icon = MakeTransparent(icon);
-    SkPaint paint;
-    paint.setXfermode(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 
-    SkBitmap bg;
-    rb.GetBitmapNamed(IDR_BROWSER_ACTION)->copyTo(&bg,
-        SkBitmap::kARGB_8888_Config);
-    SkCanvas bg_canvas(bg);
-    bg_canvas.drawBitmap(icon, SkIntToScalar((bg.width() - icon.width()) / 2),
-        SkIntToScalar((bg.height() - icon.height()) / 2), &paint);
-    SetIcon(bg);
+    gfx::ImageSkia bg = *rb.GetImageSkiaNamed(IDR_BROWSER_ACTION);
+    SetIcon(gfx::ImageSkia(new IconWithBackgroundImageSource(icon, bg),
+            bg.size()));
 
-    SkBitmap bg_h;
-    rb.GetBitmapNamed(IDR_BROWSER_ACTION_H)->copyTo(&bg_h,
-        SkBitmap::kARGB_8888_Config);
-    SkCanvas bg_h_canvas(bg_h);
-    bg_h_canvas.drawBitmap(icon,
-        SkIntToScalar((bg_h.width() - icon.width()) / 2),
-        SkIntToScalar((bg_h.height() - icon.height()) / 2), &paint);
-    SetHoverIcon(bg_h);
+    gfx::ImageSkia bg_h = *rb.GetImageSkiaNamed(IDR_BROWSER_ACTION_H);
+    SetHoverIcon(gfx::ImageSkia(new IconWithBackgroundImageSource(icon, bg_h),
+                 bg_h.size()));
 
-    SkBitmap bg_p;
-    rb.GetBitmapNamed(IDR_BROWSER_ACTION_P)->copyTo(&bg_p,
-        SkBitmap::kARGB_8888_Config);
-    SkCanvas bg_p_canvas(bg_p);
-    bg_p_canvas.drawBitmap(icon,
-        SkIntToScalar((bg_p.width() - icon.width()) / 2),
-        SkIntToScalar((bg_p.height() - icon.height()) / 2), &paint);
-    SetPushedIcon(bg_p);
+    gfx::ImageSkia bg_p = *rb.GetImageSkiaNamed(IDR_BROWSER_ACTION_P);
+    SetPushedIcon(gfx::ImageSkia(new IconWithBackgroundImageSource(icon, bg_p),
+                  bg_p.size()));
   }
 
   // If the browser action name is empty, show the extension name instead.
   string16 name = UTF8ToUTF16(browser_action()->GetTitle(tab_id));
   if (name.empty())
     name = UTF8ToUTF16(extension()->name());
   SetTooltipText(name);
   SetAccessibleName(name);
 
   parent()->SchedulePaint();
@@ skipping 142 matching lines @@
   extensions::Command browser_action_command;
   if (!only_if_active || !command_service->GetBrowserActionCommand(
           extension_->id(),
           extensions::CommandService::ACTIVE_ONLY,
           &browser_action_command,
           NULL)) {
     panel_->GetFocusManager()->UnregisterAccelerator(*keybinding_.get(), this);
   }
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserActionView
 
 BrowserActionView::BrowserActionView(const Extension* extension,
                                      BrowserActionsContainer* panel)
     : panel_(panel) {
   button_ = new BrowserActionButton(extension, panel);
   button_->set_drag_controller(panel_);
   AddChildView(button_);
   button_->UpdateState();
 }
 
 BrowserActionView::~BrowserActionView() {
   RemoveChildView(button_);
   button_->Destroy();
 }
 
-gfx::Canvas* BrowserActionView::GetIconWithBadge() {
+gfx::ImageSkia BrowserActionView::GetIconWithBadge() {
   int tab_id = panel_->GetCurrentTabId();
 
-  SkBitmap icon = *button_->extension()->browser_action()->GetIcon(
-      tab_id).ToSkBitmap();
+  const ExtensionAction* action = button_->extension()->browser_action();
 
-  // Dim the icon if our button is disabled.
-  if (!button_->IsEnabled(tab_id))
-    icon = MakeTransparent(icon);
+  gfx::ImageSkia icon = action->GetIcon(tab_id);
 
-  gfx::Canvas* canvas =
-      new gfx::Canvas(gfx::ImageSkiaRep(icon, ui::SCALE_FACTOR_100P), false);
+  if (tab_id < 0)
+    return icon;
 
-  if (tab_id >= 0) {
-    gfx::Rect bounds(icon.width(), icon.height() + ToolbarView::kVertSpacing);
-    button_->extension()->browser_action()->PaintBadge(canvas, bounds, tab_id);
-  }
-
-  return canvas;
+  return gfx::ImageSkia(
+      new ActionBadgeImageSource(action->GetIcon(tab_id),
+                                 button_->IsEnabled(tab_id),
+                                 action->GetBadgeText(tab_id),
+                                 action->GetBadgeTextColor(tab_id),
+                                 action->GetBadgeBackgroundColor(tab_id)),
+      icon.size());
 }
 
 void BrowserActionView::Layout() {
   // We can't rely on button_->GetPreferredSize() here because that's not set
   // correctly until the first call to
   // BrowserActionsContainer::RefreshBrowserActionViews(), whereas this can be
   // called before that when the initial bounds are set (and then not after,
   // since the bounds don't change).  So instead of setting the height from the
   // button's preferred size, we use IconHeight(), since that's how big the
   // button should be regardless of what it's displaying.
   button_->SetBounds(0, ToolbarView::kVertSpacing, width(),
                      BrowserActionsContainer::IconHeight());
 }
 
 void BrowserActionView::GetAccessibleState(ui::AccessibleViewState* state) {
   state->name = l10n_util::GetStringUTF16(
       IDS_ACCNAME_EXTENSIONS_BROWSER_ACTION);
   state->role = ui::AccessibilityTypes::ROLE_GROUPING;
 }
 
 void BrowserActionView::PaintChildren(gfx::Canvas* canvas) {
   View::PaintChildren(canvas);
   ExtensionAction* action = button()->browser_action();
   int tab_id = panel_->GetCurrentTabId();
   if (tab_id >= 0)
     action->PaintBadge(canvas, gfx::Rect(width(), height()), tab_id);
 }