Convert extension action icons code to use ImageSkia instead of SkBitmap

chrome/common/extensions/extension_action.h

 // 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.
 
 #ifndef CHROME_COMMON_EXTENSIONS_EXTENSION_ACTION_H_
 #define CHROME_COMMON_EXTENSIONS_EXTENSION_ACTION_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/animation/linear_animation.h"
 
 class GURL;
 class SkBitmap;
 class SkDevice;
 
 namespace gfx {
 class Canvas;
-class Image;
+class ImageSkia;
 class Rect;
 }
 
 // ExtensionAction encapsulates the state of a browser action, page action, or
 // script badge.
 // Instances can have both global and per-tab state. If a property does not have
 // a per-tab value, the global value is used instead.
 class ExtensionAction {
  public:
   // Use this ID to indicate the default state for properties that take a tab_id
@@ skipping 118 matching lines @@
   // bitmap or a path. However, conceptually, there is only one default icon.
   // Setting the default icon using a path clears the bitmap and vice-versa.
 
   // Since ExtensionAction, living in common/, can't interact with the browser
   // to load images, the UI code needs to load the images for each path.  For
   // each path in default_icon_path() and icon_paths(), load the image there
   // using an ImageLoadingTracker and call CacheIcon(path, image) with the
   // result.
   //
   // If an image is cached redundantly, the first load will be used.
-  void CacheIcon(const std::string& path, const gfx::Image& icon);
+  void CacheIcon(const std::string& path, const gfx::ImageSkia& icon);
 
   // Set this action's icon bitmap on a specific tab.
-  void SetIcon(int tab_id, const SkBitmap& bitmap);
+  void SetIcon(int tab_id, const gfx::ImageSkia& bitmap);
 
   // Get the icon for a tab, or the default if no icon was set for this tab,
   // retrieving icons that have been specified by path from the previous
   // arguments to CacheIcon().  If the default icon isn't found in the cache,
   // returns the puzzle piece icon.
-  gfx::Image GetIcon(int tab_id) const;
+  gfx::ImageSkia GetIcon(int tab_id) const;
 
   // Set this action's icon index for a specific tab.  For use with
   // icon_paths(), only used in page actions.
   void SetIconIndex(int tab_id, int index);
 
   // Get this action's icon index for a tab, or the default if no icon index
   // was set.
   int GetIconIndex(int tab_id) const {
     return GetValue(&icon_index_, tab_id);
   }
@@ skipping 45 matching lines @@
   bool GetIsVisible(int tab_id) const {
     return GetValue(&appearance_, tab_id) != INVISIBLE;
   }
 
   // Remove all tab-specific state.
   void ClearAllValuesForTab(int tab_id);
 
   // If the specified tab has a badge, paint it into the provided bounds.
   void PaintBadge(gfx::Canvas* canvas, const gfx::Rect& bounds, int tab_id);
 
+  // Paints badge with specified parameters to |canvas|.
+  static void 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);
+
   // Gets a weak reference to the icon animation for a tab, if any. The
   // reference will only have a value while the animation is running.
   base::WeakPtr<IconAnimation> GetIconAnimation(int tab_id) const;
 
  private:
   // Runs an animation on a tab.
   void RunIconAnimation(int tab_id);
 
+ private:
   class IconAnimationWrapper;
+  class AnimatedIconImageSource;
 
   // Finds the icon animation wrapper for a tab, if any.  If the animation for
   // this tab has recently completed, also removes up any other dead wrappers
   // from the map.
   IconAnimationWrapper* GetIconAnimationWrapper(int tab_id) const;
 
   // If the icon animation is running on tab |tab_id|, applies it to
   // |orig| and returns the result. Otherwise, just returns |orig|.
-  gfx::Image ApplyIconAnimation(int tab_id, const gfx::Image& orig) const;
+  gfx::ImageSkia ApplyIconAnimation(int tab_id,
+                                    const gfx::ImageSkia& orig) const;
 
   template <class T>
   struct ValueTraits {
     static T CreateEmpty() {
       return T();
     }
   };
 
   template<class T>
   void SetValue(std::map<int, T>* map, int tab_id, const T& val) {
@@ skipping 14 matching lines @@
   // The id for the extension this action belongs to (as defined in the
   // extension manifest).
   const std::string extension_id_;
 
   const Type action_type_;
 
   // Each of these data items can have both a global state (stored with the key
   // kDefaultTabId), or tab-specific state (stored with the tab_id as the key).
   std::map<int, GURL> popup_url_;
   std::map<int, std::string> title_;
-  std::map<int, gfx::Image> icon_;
+  std::map<int, gfx::ImageSkia> icon_;
   std::map<int, int> icon_index_;  // index into icon_paths_
   std::map<int, std::string> badge_text_;
   std::map<int, SkColor> badge_background_color_;
   std::map<int, SkColor> badge_text_color_;
   std::map<int, Appearance> appearance_;
 
   // IconAnimationWrappers own themselves so that even if the Extension and
   // ExtensionAction are destroyed on a non-UI thread, the animation will still
   // only be touched from the UI thread.  When an animation finishes, it deletes
   // itself, which causes the WeakPtr in this map to become NULL.
   // GetIconAnimationWrapper() removes NULLs to prevent the map from growing
   // without bound.
   mutable std::map<int, base::WeakPtr<IconAnimationWrapper> > icon_animation_;
 
   std::string default_icon_path_;
 
   // The id for the ExtensionAction, for example: "RssPageAction". This is
   // needed for compat with an older version of the page actions API.
   std::string id_;
 
   // A list of paths to icons this action might show. This is needed to support
   // the legacy setIcon({iconIndex:...} method of the page actions API.
   std::vector<std::string> icon_paths_;
 
   // Saves the arguments from CacheIcon() calls.
-  std::map<std::string, gfx::Image> path_to_icon_cache_;
+  std::map<std::string, gfx::ImageSkia> path_to_icon_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionAction);
 };
 
 template<>
 struct ExtensionAction::ValueTraits<int> {
   static int CreateEmpty() {
     return -1;
   }
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_ACTION_H_