Remove support for page_action.icons, and the legacy code surrounding it.

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/bind.h"
 #include "base/logging.h"
@@ skipping 230 matching lines @@
 
 ExtensionAction::~ExtensionAction() {
 }
 
 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->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
   // the API, we must remember that there is no popup for that specific tab.
   // If we removed the tab's URL, GetPopupURL would incorrectly return the
   // default URL.
   SetValue(&popup_url_, tab_id, url);
 }
 
 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::CacheIcon(const std::string& path,
-                                const gfx::Image& icon) {
+void ExtensionAction::CacheIcon(const gfx::Image& icon) {
   if (!icon.IsEmpty())
-    path_to_icon_cache_.insert(std::make_pair(path, *icon.ToImageSkia()));
+    cached_icon_.reset(new gfx::ImageSkia(*icon.ToImageSkia()));
 }
 
 void ExtensionAction::SetIcon(int tab_id, const gfx::Image& image) {
   SetValue(&icon_, tab_id, image.AsImageSkia());
 }
 
 gfx::Image ExtensionAction::GetIcon(int tab_id) const {
   // Check if a specific icon is set for this tab.
   gfx::ImageSkia icon = GetExplicitlySetIcon(tab_id);
   if (icon.isNull()) {
-    // 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::ImageSkia>::const_iterator cached_icon =
-        path_to_icon_cache_.find(*path);
-    if (cached_icon != path_to_icon_cache_.end()) {
-      icon = cached_icon->second;
+    if (cached_icon_.get()) {
+      icon = *cached_icon_;
     } else {
       icon = *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
           IDR_EXTENSIONS_FAVICON);
     }
   }
 
   if (GetValue(&appearance_, tab_id) == WANTS_ATTENTION)
     icon = gfx::ImageSkia(new GetAttentionImageSource(icon), icon.size());
 
   return gfx::Image(ApplyIconAnimation(tab_id, icon));
 }
 
 gfx::ImageSkia ExtensionAction::GetExplicitlySetIcon(int tab_id) const {
   return GetValue(&icon_, tab_id);
 }
 
-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);
   appearance_.erase(tab_id);
   icon_animation_.erase(tab_id);
 }
 
 void ExtensionAction::PaintBadge(gfx::Canvas* canvas,
                                  const gfx::Rect& bounds,
                                  int tab_id) {
@@ skipping 150 matching lines @@
   icon_animation->Start();
   // After the icon is finished fading in (plus some padding to handle random
   // timer delays), destroy it. We use a delayed task so that the Animation is
   // deleted even if it hasn't finished by the time the MessageLoop is
   // destroyed.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&DestroyIconAnimation, base::Passed(icon_animation.Pass())),
       base::TimeDelta::FromMilliseconds(kIconFadeInDurationMs * 2));
 }