Change browser/page action default icon defined in manifest to support hidpi.

chrome/common/extensions/extension_action.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/common/extensions/extension_action.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/common/badge_util.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "googleurl/src/gurl.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/animation/animation_delegate.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 31 matching lines @@
 const int kPadding = 2;
 // The padding between the top of the badge and the top of the text.
 const int kTopTextPadding = -1;
 #endif
 
 const int kBadgeHeight = 11;
 const int kMaxTextWidth = 23;
 // The minimum width for center-aligning the badge.
 const int kCenterAlignThreshold = 20;
 
+int GetIconWidthForActionType(ExtensionAction::Type type) {

[Jeffrey Yasskin, 2012/09/14 23:47:12]

You also have this function as GetIconSizeForType() in
chrome/browser/extensions/extension_action_icon_factory.cc. Please only add it
once. 

[tbarzic, 2012/09/15 00:29:10]

Done.

+  switch (type) {
+    case ExtensionAction::TYPE_BROWSER:
+    case ExtensionAction::TYPE_PAGE:
+      return extension_misc::EXTENSION_ICON_ACTION;
+    case ExtensionAction::TYPE_SCRIPT_BADGE:
+      return extension_misc::EXTENSION_ICON_BITTY;
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
 class GetAttentionImageSource : public gfx::ImageSkiaSource {
  public:
   explicit GetAttentionImageSource(const gfx::ImageSkia& icon)
       : icon_(icon) {}
 
   // gfx::ImageSkiaSource overrides:
   virtual gfx::ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor)
       OVERRIDE {
     gfx::ImageSkiaRep icon_rep = icon_.GetRepresentation(scale_factor);
     color_utils::HSL shift = {-1, 0, 0.5};
@@ skipping 172 matching lines @@
   scoped_ptr<ExtensionAction> copy(
       new ExtensionAction(extension_id_, action_type_));
   copy->popup_url_ = popup_url_;
   copy->title_ = title_;
   copy->icon_ = icon_;
   copy->badge_text_ = badge_text_;
   copy->badge_background_color_ = badge_background_color_;
   copy->badge_text_color_ = badge_text_color_;
   copy->appearance_ = appearance_;
   copy->icon_animation_ = icon_animation_;
-  copy->default_icon_path_ = default_icon_path_;
   copy->id_ = id_;
+
+  if (default_icon_.get()) {
+    scoped_ptr<ExtensionIconSet> default_icon_copy(new ExtensionIconSet());
+    default_icon_->CopyForTest(default_icon_copy.get());
+    copy->default_icon_ = default_icon_copy.Pass();
+  }
+
   return copy.Pass();
 }
 
 void ExtensionAction::SetPopupUrl(int tab_id, const GURL& url) {
   // We store |url| even if it is empty, rather than removing a URL from the
   // map.  If an extension has a default popup, and removes it for a tab via
   // the API, we must remember that there is no popup for that specific tab.
   // If we removed the tab's URL, GetPopupURL would incorrectly return the
   // default URL.
   SetValue(&popup_url_, tab_id, url);
 }
 
 bool ExtensionAction::HasPopup(int tab_id) const {
   return !GetPopupUrl(tab_id).is_empty();
 }
 
 GURL ExtensionAction::GetPopupUrl(int tab_id) const {
   return GetValue(&popup_url_, tab_id);
 }
 
-void ExtensionAction::CacheIcon(const gfx::Image& icon) {
-  if (!icon.IsEmpty())
-    cached_icon_.reset(new gfx::ImageSkia(*icon.ToImageSkia()));
-}
-
 void ExtensionAction::SetIcon(int tab_id, const gfx::Image& image) {
   SetValue(&icon_, tab_id, image.AsImageSkia());
 }
 
-gfx::Image ExtensionAction::GetIcon(int tab_id) const {
-  // Check if a specific icon is set for this tab.
-  gfx::ImageSkia icon = GetExplicitlySetIcon(tab_id);
-  if (icon.isNull()) {
-    if (cached_icon_.get()) {
-      icon = *cached_icon_;
-    } else {
-      icon = *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-          IDR_EXTENSIONS_FAVICON);
-    }
-  }
-
+gfx::Image ExtensionAction::ApplyAttentionAndAnimation(

[Jeffrey Yasskin, 2012/09/14 23:47:12]

Somewhere in this sequence of refactorings, the point of returning
gfx::Image—that it can cache the conversions to GdkPixbuf and NSImage—was lost.
No need to do it in this CL, but if it ever gets more convenient, feel free to
switch all of these to returning ImageSkia.

[tbarzic, 2012/09/15 00:29:10]

Initially I wanted to make all of this to return ImageSkia, but rsesek@ had
objections about that (gfx::Image should be used when the image could be used on
more different platforms, which is the case here)

+    const gfx::ImageSkia& original_icon,
+    int tab_id) const {
+  gfx::ImageSkia icon = original_icon;
   if (GetValue(&appearance_, tab_id) == WANTS_ATTENTION)
     icon = gfx::ImageSkia(new GetAttentionImageSource(icon), icon.size());
 
   return gfx::Image(ApplyIconAnimation(tab_id, icon));
 }
 
 gfx::ImageSkia ExtensionAction::GetExplicitlySetIcon(int tab_id) const {
   return GetValue(&icon_, tab_id);
 }
 
@@ skipping 27 matching lines @@
 
 void ExtensionAction::PaintBadge(gfx::Canvas* canvas,
                                  const gfx::Rect& bounds,
                                  int tab_id) {
   ExtensionAction::DoPaintBadge(
       canvas,
       bounds,
       GetBadgeText(tab_id),
       GetBadgeTextColor(tab_id),
       GetBadgeBackgroundColor(tab_id),
-      GetValue(&icon_, tab_id).size().width());
+      GetIconWidth(tab_id));
 }
 
 gfx::ImageSkia ExtensionAction::GetIconWithBadge(
     const gfx::ImageSkia& icon,
     int tab_id,
     const gfx::Size& spacing) const {
   if (tab_id < 0)
     return icon;
 
   return gfx::ImageSkia(
       new IconWithBadgeImageSource(icon,
                                    spacing,
                                    GetBadgeText(tab_id),
                                    GetBadgeTextColor(tab_id),
                                    GetBadgeBackgroundColor(tab_id)),
      icon.size());
 }
 
+// Determines which icon would be returned by |GetIcon|, and returns its width.
+int ExtensionAction::GetIconWidth(int tab_id) const {
+  // If icon has been set, return its width.
+  gfx::ImageSkia icon = GetValue(&icon_, tab_id);
+  if (!icon.isNull())
+    return icon.width();
+  // If there is a default icon, the icon width will be set depending on our
+  // action type.
+  if (default_icon_.get())
+    return GetIconWidthForActionType(action_type());
+
+  // If no icon has been set and there is no default icon, we need favicon
+  // width.
+  return ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+          IDR_EXTENSIONS_FAVICON).ToImageSkia()->width();
+}
+
 // static
 void ExtensionAction::DoPaintBadge(gfx::Canvas* canvas,
                                    const gfx::Rect& bounds,
                                    const std::string& text,
                                    const SkColor& text_color_in,
                                    const SkColor& background_color_in,
                                    int icon_width) {
   if (text.empty())
     return;
 
@@ skipping 115 matching lines @@
   icon_animation->Start();
   // After the icon is finished fading in (plus some padding to handle random
   // timer delays), destroy it. We use a delayed task so that the Animation is
   // deleted even if it hasn't finished by the time the MessageLoop is
   // destroyed.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&DestroyIconAnimation, base::Passed(icon_animation.Pass())),
       base::TimeDelta::FromMilliseconds(kIconFadeInDurationMs * 2));
 }