Move icon fallbacks into ExtensionAction.

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/logging.h"
 #include "chrome/common/badge_util.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"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/rect.h"
@@ skipping 23 matching lines @@
 // 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 Width(const gfx::Image& image) {
+  if (image.IsEmpty())
+    return 0;
+  return image.ToSkBitmap()->width();
+}
+
 }  // namespace
 
 // Wraps an IconAnimation and implements its ui::AnimationDelegate to erase the
 // animation from a map when the animation ends or is cancelled, causing itself
 // and its owned IconAnimation to be deleted.
 class ExtensionAction::IconAnimationWrapper : public ui::AnimationDelegate {
  public:
   IconAnimationWrapper(ExtensionAction* owner, int tab_id)
       : owner_(owner),
         tab_id_(tab_id),
@@ skipping 118 matching lines @@
 }
 
 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::SetIcon(int tab_id, const SkBitmap& bitmap) {
-  SetValue(&icon_, tab_id, bitmap);
+void ExtensionAction::CacheIcon(const std::string& path,
+                                const gfx::Image& icon) {
+  if (!icon.IsEmpty())
+    path_to_icon_cache_.insert(std::make_pair(path, icon));
 }
 
-SkBitmap ExtensionAction::GetIcon(int tab_id) const {
-  return GetValue(&icon_, tab_id);
+void ExtensionAction::SetIcon(int tab_id, const SkBitmap& bitmap) {
+  SetValue(&icon_, tab_id, gfx::Image(bitmap));
+}
+
+gfx::Image ExtensionAction::GetIcon(int tab_id) const {
+  // Check if a specific icon is set for this tab.
+  gfx::Image icon = GetValue(&icon_, tab_id);
+  if (icon.IsEmpty()) {
+    // Need to find an icon from a path.
+    const std::string* path = NULL;
+    // Check if one of the elements of icon_path() was selected.
+    int icon_index = GetIconIndex(tab_id);
+    if (icon_index >= 0) {
+      path = &icon_paths()->at(icon_index);
+    } else {
+      // Otherwise, use the default icon.
+      path = &default_icon_path();
+    }
+
+    std::map<std::string, gfx::Image>::const_iterator cached_icon =
+        path_to_icon_cache_.find(*path);
+    if (cached_icon != path_to_icon_cache_.end()) {
+      icon = cached_icon->second;
+    } else {
+      icon = ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+          IDR_EXTENSIONS_FAVICON);
+    }
+  }
+
+  return ApplyIconAnimation(tab_id, icon);
 }
 
 void ExtensionAction::SetIconIndex(int tab_id, int index) {
   if (static_cast<size_t>(index) >= icon_paths_.size()) {
     NOTREACHED();
     return;
   }
   SetValue(&icon_index_, tab_id, index);
 }
 
@@ skipping 32 matching lines @@
   text_paint->setColor(text_color);
 
   // Calculate text width. We clamp it to a max size.
   SkScalar text_width = text_paint->measureText(text.c_str(), text.size());
   text_width = SkIntToScalar(
       std::min(kMaxTextWidth, SkScalarFloor(text_width)));
 
   // Calculate badge size. It is clamped to a min width just because it looks
   // silly if it is too skinny.
   int badge_width = SkScalarFloor(text_width) + kPadding * 2;
-  int icon_width = GetIcon(tab_id).width();
+  int icon_width = Width(GetValue(&icon_, tab_id));
   // Force the pixel width of badge to be either odd (if the icon width is odd)
   // or even otherwise. If there is a mismatch you get http://crbug.com/26400.
-  if (icon_width != 0 && (badge_width % 2 != GetIcon(tab_id).width() % 2))
+  if (icon_width != 0 && (badge_width % 2 != icon_width % 2))
     badge_width += 1;
   badge_width = std::max(kBadgeHeight, badge_width);
 
   // Paint the badge background color in the right location. It is usually
   // right-aligned, but it can also be center-aligned if it is large.
   SkRect rect;
   rect.fBottom = SkIntToScalar(bounds.bottom() - kBottomMargin);
   rect.fTop = rect.fBottom - SkIntToScalar(kBadgeHeight);
   if (badge_width >= kCenterAlignThreshold) {
     rect.fLeft = SkIntToScalar(
@@ skipping 43 matching lines @@
 }
 
 base::WeakPtr<ExtensionAction::IconAnimation> ExtensionAction::GetIconAnimation(
     int tab_id) const {
   std::map<int, linked_ptr<IconAnimationWrapper> >::const_iterator it =
       icon_animation_.find(tab_id);
   return (it != icon_animation_.end()) ? it->second->animation()->AsWeakPtr()
                                        : base::WeakPtr<IconAnimation>();
 }
 
+gfx::Image ExtensionAction::ApplyIconAnimation(int tab_id,
+                                               const gfx::Image& orig) const {
+  std::map<int, linked_ptr<IconAnimationWrapper> >::const_iterator it =
+      icon_animation_.find(tab_id);
+  if (it == icon_animation_.end())
+    return orig;
+  return gfx::Image(it->second->animation()->Apply(*orig.ToSkBitmap()));
+}
+
 void ExtensionAction::RunIconAnimation(int tab_id) {
   IconAnimationWrapper* icon_animation =
       new IconAnimationWrapper(this, tab_id);
   icon_animation_[tab_id] = make_linked_ptr(icon_animation);
   icon_animation->animation()->Start();
 }