Make the getAttention badge grey.

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/color_utils.h"
 #include "ui/gfx/rect.h"
+#include "ui/gfx/image/image_skia_source.h"
+#include "ui/gfx/skbitmap_operations.h"
 
 namespace {
 
 // Different platforms need slightly different constants to look good.
 #if defined(OS_LINUX) && !defined(TOOLKIT_VIEWS)
 const float kTextSize = 9.0;
 const int kBottomMargin = 0;
 const int kPadding = 2;
 const int kTopTextPadding = 0;
 #elif defined(OS_LINUX) && defined(TOOLKIT_VIEWS)
@@ skipping 19 matching lines @@
 // 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();
 }
 
+class GetAttentionImageSource : public gfx::ImageSkiaSource {
+ public:
+  explicit GetAttentionImageSource(const gfx::Image& icon)
+      : icon_(*icon.ToImageSkia()) {}
+
+  // 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};
+    return gfx::ImageSkiaRep(
+        SkBitmapOperations::CreateHSLShiftedBitmap(icon_rep.sk_bitmap(), shift),
+        icon_rep.scale_factor());
+  }
+
+ private:
+  const gfx::ImageSkia icon_;
+};
+
 }  // namespace
 
 // Wraps an IconAnimation and implements its ui::AnimationDelegate to delete
 // itself when the animation ends or is cancelled, causing its owned
 // IconAnimation to be destroyed.
 class ExtensionAction::IconAnimationWrapper
     : public ui::AnimationDelegate,
       public base::SupportsWeakPtr<IconAnimationWrapper> {
  public:
   IconAnimationWrapper()
@@ skipping 90 matching lines @@
 scoped_ptr<ExtensionAction> ExtensionAction::CopyForTest() const {
   scoped_ptr<ExtensionAction> copy(
       new ExtensionAction(extension_id_, action_type_));
   copy->popup_url_ = popup_url_;
   copy->title_ = title_;
   copy->icon_ = icon_;
   copy->icon_index_ = icon_index_;
   copy->badge_text_ = badge_text_;
   copy->badge_background_color_ = badge_background_color_;
   copy->badge_text_color_ = badge_text_color_;
-  copy->visible_ = visible_;
+  copy->appearance_ = appearance_;
   copy->icon_animation_ = icon_animation_;
   copy->default_icon_path_ = default_icon_path_;
   copy->id_ = id_;
   copy->icon_paths_ = icon_paths_;
   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
@@ skipping 39 matching lines @@
     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);
     }
   }
 
+  if (GetValue(&appearance_, tab_id) == WANTS_ATTENTION) {
+    icon = gfx::Image(gfx::ImageSkia(new GetAttentionImageSource(icon),
+                                     icon.ToImageSkia()->size()));
+  }
+
   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);
 }
 
+bool ExtensionAction::SetAppearance(int tab_id, Appearance new_appearance) {
+  const Appearance old_appearance = GetValue(&appearance_, tab_id);
+
+  if (old_appearance == new_appearance)
+    return false;
+
+  SetValue(&appearance_, tab_id, new_appearance);
+
+  // When showing a badge for the first time on a web page, fade it
+  // in.  Other transitions happen instantly.
+  if (old_appearance == INVISIBLE && tab_id != kDefaultTabId) {
+    RunIconAnimation(tab_id);
+  }
+
+  return true;
+}
+
 void ExtensionAction::ClearAllValuesForTab(int tab_id) {
   popup_url_.erase(tab_id);
   title_.erase(tab_id);
   icon_.erase(tab_id);
   icon_index_.erase(tab_id);
   badge_text_.erase(tab_id);
   badge_text_color_.erase(tab_id);
   badge_background_color_.erase(tab_id);
-  visible_.erase(tab_id);
+  appearance_.erase(tab_id);
   icon_animation_.erase(tab_id);
 }
 
 void ExtensionAction::PaintBadge(gfx::Canvas* canvas,
                                  const gfx::Rect& bounds,
                                  int tab_id) {
   std::string text = GetBadgeText(tab_id);
   if (text.empty())
     return;
 
@@ skipping 116 matching lines @@
     return orig;
   return gfx::Image(wrapper->animation()->Apply(*orig.ToSkBitmap()));
 }
 
 void ExtensionAction::RunIconAnimation(int tab_id) {
   IconAnimationWrapper* icon_animation =
       new IconAnimationWrapper();
   icon_animation_[tab_id] = icon_animation->AsWeakPtr();
   icon_animation->animation()->Start();
 }