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;
 
+gfx::Size GetIconSizeForActionType(ExtensionAction::Type type) {
+  switch (type) {
+    case ExtensionAction::TYPE_BROWSER:
+    case ExtensionAction::TYPE_PAGE:
+      return gfx::Size(extension_misc::EXTENSION_ICON_ACTION,
+                       extension_misc::EXTENSION_ICON_ACTION);
+    case ExtensionAction::TYPE_SCRIPT_BADGE:
+      return gfx::Size(extension_misc::EXTENSION_ICON_BITTY,
+                       extension_misc::EXTENSION_ICON_BITTY);
+    default:
+      NOTREACHED();
+      return gfx::Size();
+  }
+}
+
 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 {
+gfx::Image ExtensionAction::GetIcon(
+    int tab_id,
+    ExtensionIconFactoryDelegate* icon_factory) const {
   // Check if a specific icon is set for this tab.
   gfx::ImageSkia icon = GetExplicitlySetIcon(tab_id);
+
+  if (icon.isNull() && default_icon_.get() && icon_factory) {
+    icon = icon_factory->GetIcon(default_icon_.get(),
+                                 GetIconSizeForActionType(action_type()));
+  }
+
+  // Extension favicon is our last resort.
   if (icon.isNull()) {
-    if (cached_icon_.get()) {
-      icon = *cached_icon_;
-    } else {
-      icon = *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-          IDR_EXTENSIONS_FAVICON);
-    }
+    icon = *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+        IDR_EXTENSIONS_FAVICON);
   }
 
   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 29 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 GetIconSizeForActionType(action_type()).width();
+
+  // 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));
 }