Move icon fallbacks into ExtensionAction.

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 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 76 matching lines @@
 
   // What kind of action is this?
   Type action_type() const { return action_type_; }
 
   // action id -- only used with legacy page actions API
   std::string id() const { return id_; }
   void set_id(const std::string& id) { id_ = id; }
 
   // static icon paths from manifest -- only used with legacy page actions API.
   std::vector<std::string>* icon_paths() { return &icon_paths_; }
+  const std::vector<std::string>* icon_paths() const { return &icon_paths_; }
 
   // Set the url which the popup will load when the user clicks this action's
   // icon.  Setting an empty URL will disable the popup for a given tab.
   void SetPopupUrl(int tab_id, const GURL& url);
 
   // Use HasPopup() to see if a popup should be displayed.
   bool HasPopup(int tab_id) const;
 
   // Get the URL to display in a popup.
   GURL GetPopupUrl(int tab_id) const;
@@ skipping 10 matching lines @@
   // Icons are a bit different because the default value can be set to either a
   // 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.
   //
   // To get the default icon, first check for the bitmap. If it is null, check
   // for the path.
 
   // Set this action's icon bitmap on a specific tab.
   void SetIcon(int tab_id, const SkBitmap& bitmap);
 
-  // Get the icon for a tab, or the default if no icon was set.
-  SkBitmap GetIcon(int tab_id) const;
+  // Maps paths to icons since ExtensionAction, living in common/, can't
+  // interact with the browser to load them itself.  Pre-populate this cache
+  // with images from icon_paths() and default_icon_path().
+  typedef std::map<std::string, gfx::Image> PathToIconCache;
+
+  // 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 'cache'.  If the
+  // default icon isn't found in 'cache', returns the puzzle piece icon.
+  gfx::Image GetIcon(int tab_id, const PathToIconCache& cache) const;

[not at google - send to devlin, 2012/07/26 02:29:44]

A method like this makes me wonder if PathToIconCache should be a class like
ExtensionAction::IconCache, with an ExtensionAction curried in.

I also found it pretty confusing seeing PathToIconCache in other code when it's
just an alias for a map; I was expecting it to be a class.

---

Really I think all this icon loading logic should be pulled somewhere inside
chrome/extensions/browser and somehow combined with, or replacing,
ImageLoadingTracker. I say that because there's still a lot of shared
boilerplate for image loading in the UI code that could be cleaner.

However since I'm not prepared to do that, I don't expect anybody else to be.

[Jeffrey Yasskin, 2012/07/26 21:11:47]

Would you like me to duplicate the map<> arguments in each place I use the type?
I tend to think that kind of duplication makes code easier to read, but so many
people seem to like the typedefs that I got lazy and used one here.
I definitely agree that there should be some sort of structure for loading
images/resources from common code. I don't feel like I have enough context yet
to design it (presumably images aren't the only thing we want to load?), and I'd
rather not put a big refactoring before the grey'ed out request-to-act badges.
This was the simplest change that lets me do the icon-greying without changes to
platform-specific code.

 
   // 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);
   }
 
   // Non-tab-specific icon path. This is used to support the default_icon key of
   // page and browser actions.
   void set_default_icon_path(const std::string& path) {
     default_icon_path_ = path;
   }
-  std::string default_icon_path() const {
+  const std::string& default_icon_path() const {
     return default_icon_path_;
   }
 
   // Set this action's badge text on a specific tab.
   void SetBadgeText(int tab_id, const std::string& text) {
     SetValue(&badge_text_, tab_id, text);
   }
   // Get the badge text for a tab, or the default if no badge text was set.
   std::string GetBadgeText(int tab_id) const {
     return GetValue(&badge_text_, tab_id);
@@ skipping 36 matching lines @@
   void PaintBadge(gfx::Canvas* canvas, const gfx::Rect& bounds, int tab_id);
 
   // 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;
 
   // Runs an animation on a tab.
   void RunIconAnimation(int tab_id);
 
  private:
+  // 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;
+
   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) {
     (*map)[tab_id] = val;
@@ skipping 13 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, SkBitmap> icon_;
+  std::map<int, gfx::Image> 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, bool> visible_;
 
   class IconAnimationWrapper;
   std::map<int, linked_ptr<IconAnimationWrapper> > icon_animation_;
 
   std::string default_icon_path_;
@@ skipping 10 matching lines @@
 };
 
 template<>
 struct ExtensionAction::ValueTraits<int> {
   static int CreateEmpty() {
     return -1;
   }
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_ACTION_H_