chrome/browser/extensions/extension_action.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/extension_action.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/base64.h"
  10 #include "base/bind.h"
  11 #include "base/logging.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "chrome/common/badge_util.h"
  14 #include "chrome/common/icon_with_badge_image_source.h"
  15 #include "extensions/common/constants.h"
  16 #include "grit/theme_resources.h"
  17 #include "grit/ui_resources.h"
  18 #include "ipc/ipc_message.h"
  19 #include "ipc/ipc_message_utils.h"
  20 #include "third_party/skia/include/core/SkBitmap.h"
  21 #include "third_party/skia/include/core/SkCanvas.h"
  22 #include "third_party/skia/include/core/SkPaint.h"
  23 #include "third_party/skia/include/effects/SkGradientShader.h"
  24 #include "ui/base/resource/resource_bundle.h"
  25 #include "ui/gfx/animation/animation_delegate.h"
  26 #include "ui/gfx/canvas.h"
  27 #include "ui/gfx/color_utils.h"
  28 #include "ui/gfx/geometry/rect.h"
  29 #include "ui/gfx/geometry/size.h"
  30 #include "ui/gfx/image/image.h"
  31 #include "ui/gfx/image/image_skia.h"
  32 #include "ui/gfx/image/image_skia_source.h"
  33 #include "ui/gfx/ipc/gfx_param_traits.h"
  34 #include "ui/gfx/skbitmap_operations.h"
  35 #include "url/gurl.h"
  36
  37 namespace {
  38
  39 class GetAttentionImageSource : public gfx::ImageSkiaSource {
  40  public:
  41   explicit GetAttentionImageSource(const gfx::ImageSkia& icon)
  42       : icon_(icon) {}
  43
  44   // gfx::ImageSkiaSource overrides:
  45   gfx::ImageSkiaRep GetImageForScale(float scale) override {
  46     gfx::ImageSkiaRep icon_rep = icon_.GetRepresentation(scale);
  47     color_utils::HSL shift = {-1, 0, 0.5};
  48     return gfx::ImageSkiaRep(
  49         SkBitmapOperations::CreateHSLShiftedBitmap(icon_rep.sk_bitmap(), shift),
  50         icon_rep.scale());
  51   }
  52
  53  private:
  54   const gfx::ImageSkia icon_;
  55 };
  56
  57 struct IconRepresentationInfo {
  58   // Size as a string that will be used to retrieve a representation value from
  59   // SetIcon function arguments.
  60   const char* size_string;
  61   // Scale factor for which the represantion should be used.
  62   ui::ScaleFactor scale;
  63 };
  64
  65 const IconRepresentationInfo kIconSizes[] = {{"19", ui::SCALE_FACTOR_100P},
  66                                              {"38", ui::SCALE_FACTOR_200P}};
  67
  68 template <class T>
  69 bool HasValue(const std::map<int, T>& map, int tab_id) {
  70   return map.find(tab_id) != map.end();
  71 }
  72
  73 }  // namespace
  74
  75 const int ExtensionAction::kDefaultTabId = -1;
  76 const int ExtensionAction::kPageActionIconMaxSize =
  77     extension_misc::EXTENSION_ICON_ACTION;
  78
  79 ExtensionAction::ExtensionAction(const std::string& extension_id,
  80                                  extensions::ActionInfo::Type action_type,
  81                                  const extensions::ActionInfo& manifest_data)
  82     : extension_id_(extension_id), action_type_(action_type) {
  83   // Page/script actions are hidden/disabled by default, and browser actions are
  84   // visible/enabled by default.
  85   SetIsVisible(kDefaultTabId,
  86                action_type == extensions::ActionInfo::TYPE_BROWSER);
  87   SetTitle(kDefaultTabId, manifest_data.default_title);
  88   SetPopupUrl(kDefaultTabId, manifest_data.default_popup_url);
  89   if (!manifest_data.default_icon.empty()) {
  90     set_default_icon(make_scoped_ptr(new ExtensionIconSet(
  91         manifest_data.default_icon)));
  92   }
  93   set_id(manifest_data.id);
  94 }
  95
  96 ExtensionAction::~ExtensionAction() {
  97 }
  98
  99 scoped_ptr<ExtensionAction> ExtensionAction::CopyForTest() const {
 100   scoped_ptr<ExtensionAction> copy(
 101       new ExtensionAction(extension_id_, action_type_,
 102                           extensions::ActionInfo()));
 103   copy->popup_url_ = popup_url_;
 104   copy->title_ = title_;
 105   copy->icon_ = icon_;
 106   copy->badge_text_ = badge_text_;
 107   copy->badge_background_color_ = badge_background_color_;
 108   copy->badge_text_color_ = badge_text_color_;
 109   copy->is_visible_ = is_visible_;
 110   copy->id_ = id_;
 111
 112   if (default_icon_)
 113     copy->default_icon_.reset(new ExtensionIconSet(*default_icon_));
 114
 115   return copy.Pass();
 116 }
 117
 118 // static
 119 int ExtensionAction::GetIconSizeForType(
 120     extensions::ActionInfo::Type type) {
 121   switch (type) {
 122     case extensions::ActionInfo::TYPE_BROWSER:
 123     case extensions::ActionInfo::TYPE_PAGE:
 124     case extensions::ActionInfo::TYPE_SYSTEM_INDICATOR:
 125       // TODO(dewittj) Report the actual icon size of the system
 126       // indicator.
 127       return extension_misc::EXTENSION_ICON_ACTION;
 128     default:
 129       NOTREACHED();
 130       return 0;
 131   }
 132 }
 133
 134 void ExtensionAction::SetPopupUrl(int tab_id, const GURL& url) {
 135   // We store |url| even if it is empty, rather than removing a URL from the
 136   // map.  If an extension has a default popup, and removes it for a tab via
 137   // the API, we must remember that there is no popup for that specific tab.
 138   // If we removed the tab's URL, GetPopupURL would incorrectly return the
 139   // default URL.
 140   SetValue(&popup_url_, tab_id, url);
 141 }
 142
 143 bool ExtensionAction::HasPopup(int tab_id) const {
 144   return !GetPopupUrl(tab_id).is_empty();
 145 }
 146
 147 GURL ExtensionAction::GetPopupUrl(int tab_id) const {
 148   return GetValue(&popup_url_, tab_id);
 149 }
 150
 151 void ExtensionAction::SetIcon(int tab_id, const gfx::Image& image) {
 152   SetValue(&icon_, tab_id, image.AsImageSkia());
 153 }
 154
 155 bool ExtensionAction::ParseIconFromCanvasDictionary(
 156     const base::DictionaryValue& dict,
 157     gfx::ImageSkia* icon) {
 158   // Try to extract an icon for each known scale.
 159   for (size_t i = 0; i < arraysize(kIconSizes); i++) {
 160     const base::BinaryValue* image_data;
 161     std::string binary_string64;
 162     IPC::Message pickle;
 163     if (dict.GetBinary(kIconSizes[i].size_string, &image_data)) {
 164       pickle = IPC::Message(image_data->GetBuffer(), image_data->GetSize());
 165     } else if (dict.GetString(kIconSizes[i].size_string, &binary_string64)) {
 166       std::string binary_string;
 167       if (!base::Base64Decode(binary_string64, &binary_string))
 168         return false;
 169       pickle = IPC::Message(binary_string.c_str(), binary_string.length());
 170     } else {
 171       continue;
 172     }
 173     PickleIterator iter(pickle);
 174     SkBitmap bitmap;
 175     if (!IPC::ReadParam(&pickle, &iter, &bitmap))
 176       return false;
 177     CHECK(!bitmap.isNull());
 178     float scale = ui::GetScaleForScaleFactor(kIconSizes[i].scale);
 179     icon->AddRepresentation(gfx::ImageSkiaRep(bitmap, scale));
 180   }
 181   return true;
 182 }
 183
 184 gfx::ImageSkia ExtensionAction::GetExplicitlySetIcon(int tab_id) const {
 185   return GetValue(&icon_, tab_id);
 186 }
 187
 188 bool ExtensionAction::SetIsVisible(int tab_id, bool new_visibility) {
 189   const bool old_visibility = GetValue(&is_visible_, tab_id);
 190
 191   if (old_visibility == new_visibility)
 192     return false;
 193
 194   SetValue(&is_visible_, tab_id, new_visibility);
 195
 196   return true;
 197 }
 198
 199 void ExtensionAction::DeclarativeShow(int tab_id) {
 200   DCHECK_NE(tab_id, kDefaultTabId);
 201   ++declarative_show_count_[tab_id];  // Use default initialization to 0.
 202 }
 203
 204 void ExtensionAction::UndoDeclarativeShow(int tab_id) {
 205   int& show_count = declarative_show_count_[tab_id];
 206   DCHECK_GT(show_count, 0);
 207   if (--show_count == 0)
 208     declarative_show_count_.erase(tab_id);
 209 }
 210
 211 void ExtensionAction::DeclarativeSetIcon(int tab_id,
 212                                          int priority,
 213                                          const gfx::Image& icon) {
 214   DCHECK_NE(tab_id, kDefaultTabId);
 215   declarative_icon_[tab_id][priority].push_back(icon);
 216 }
 217
 218 void ExtensionAction::UndoDeclarativeSetIcon(int tab_id,
 219                                              int priority,
 220                                              const gfx::Image& icon) {
 221   std::vector<gfx::Image>& icons = declarative_icon_[tab_id][priority];
 222   for (std::vector<gfx::Image>::iterator it = icons.begin(); it != icons.end();
 223        ++it) {
 224     if (it->AsImageSkia().BackedBySameObjectAs(icon.AsImageSkia())) {
 225       icons.erase(it);
 226       return;
 227     }
 228   }
 229 }
 230
 231 const gfx::ImageSkia ExtensionAction::GetDeclarativeIcon(int tab_id) const {
 232   if (declarative_icon_.find(tab_id) != declarative_icon_.end() &&
 233       !declarative_icon_.find(tab_id)->second.rbegin()->second.empty()) {
 234     return declarative_icon_.find(tab_id)->second.rbegin()
 235         ->second.back().AsImageSkia();
 236   }
 237   return gfx::ImageSkia();
 238 }
 239
 240 void ExtensionAction::ClearAllValuesForTab(int tab_id) {
 241   popup_url_.erase(tab_id);
 242   title_.erase(tab_id);
 243   icon_.erase(tab_id);
 244   badge_text_.erase(tab_id);
 245   badge_text_color_.erase(tab_id);
 246   badge_background_color_.erase(tab_id);
 247   is_visible_.erase(tab_id);
 248   // TODO(jyasskin): Erase the element from declarative_show_count_
 249   // when the tab's closed.  There's a race between the
 250   // LocationBarController and the ContentRulesRegistry on navigation,
 251   // which prevents me from cleaning everything up now.
 252 }
 253
 254 void ExtensionAction::PaintBadge(gfx::Canvas* canvas,
 255                                  const gfx::Rect& bounds,
 256                                  int tab_id) {
 257   badge_util::PaintBadge(
 258       canvas,
 259       bounds,
 260       GetBadgeText(tab_id),
 261       GetBadgeTextColor(tab_id),
 262       GetBadgeBackgroundColor(tab_id),
 263       GetIconWidth(tab_id),
 264       action_type());
 265 }
 266
 267 gfx::ImageSkia ExtensionAction::GetIconWithBadge(
 268     const gfx::ImageSkia& icon,
 269     int tab_id,
 270     const gfx::Size& spacing) const {
 271   if (tab_id < 0)
 272     return icon;
 273
 274   return gfx::ImageSkia(
 275       new IconWithBadgeImageSource(icon,
 276                                    icon.size(),
 277                                    spacing,
 278                                    GetBadgeText(tab_id),
 279                                    GetBadgeTextColor(tab_id),
 280                                    GetBadgeBackgroundColor(tab_id),
 281                                    action_type()),
 282      icon.size());
 283 }
 284
 285 bool ExtensionAction::HasPopupUrl(int tab_id) const {
 286   return HasValue(popup_url_, tab_id);
 287 }
 288
 289 bool ExtensionAction::HasTitle(int tab_id) const {
 290   return HasValue(title_, tab_id);
 291 }
 292
 293 bool ExtensionAction::HasBadgeText(int tab_id) const {
 294   return HasValue(badge_text_, tab_id);
 295 }
 296
 297 bool ExtensionAction::HasBadgeBackgroundColor(int tab_id) const {
 298   return HasValue(badge_background_color_, tab_id);
 299 }
 300
 301 bool ExtensionAction::HasBadgeTextColor(int tab_id) const {
 302   return HasValue(badge_text_color_, tab_id);
 303 }
 304
 305 bool ExtensionAction::HasIsVisible(int tab_id) const {
 306   return HasValue(is_visible_, tab_id);
 307 }
 308
 309 bool ExtensionAction::HasIcon(int tab_id) const {
 310   return HasValue(icon_, tab_id);
 311 }
 312
 313 // Determines which icon would be returned by |GetIcon|, and returns its width.
 314 int ExtensionAction::GetIconWidth(int tab_id) const {
 315   // If icon has been set, return its width.
 316   gfx::ImageSkia icon = GetValue(&icon_, tab_id);
 317   if (!icon.isNull())
 318     return icon.width();
 319   // If there is a default icon, the icon width will be set depending on our
 320   // action type.
 321   if (default_icon_)
 322     return GetIconSizeForType(action_type());
 323
 324   // If no icon has been set and there is no default icon, we need favicon
 325   // width.
 326   return ui::ResourceBundle::GetSharedInstance().GetImageNamed(
 327           IDR_EXTENSIONS_FAVICON).ToImageSkia()->width();
 328 }