Change browser/page action default icon defined in manifest to support hidpi.

chrome/browser/ui/views/location_bar/page_action_image_view.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/browser/ui/views/location_bar/page_action_image_view.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/commands/command_service.h"
 #include "chrome/browser/extensions/api/commands/command_service_factory.h"
+#include "chrome/browser/extensions/extension_action_icon_factory.h"
 #include "chrome/browser/extensions/extension_context_menu_model.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/location_bar_controller.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
@@ skipping 16 matching lines @@
 using content::WebContents;
 using extensions::LocationBarController;
 using extensions::Extension;
 
 PageActionImageView::PageActionImageView(LocationBarView* owner,
                                          ExtensionAction* page_action,
                                          Browser* browser)
     : owner_(owner),
       page_action_(page_action),
       browser_(browser),
-      ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(this)),
       current_tab_id_(-1),
       preview_enabled_(false),
       popup_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(scoped_icon_animation_observer_(
           page_action->GetIconAnimation(
               SessionID::IdForTab(owner->GetTabContents()->web_contents())),
           this)) {
   const Extension* extension = owner_->profile()->GetExtensionService()->
       GetExtensionById(page_action->extension_id(), false);
   DCHECK(extension);
 
-  // Load all the icons declared in the manifest. This is the contents of the
-  // icons array, plus the default_icon property, if any.
-  std::vector<std::string> icon_paths(*page_action->icon_paths());
-  if (!page_action_->default_icon_path().empty())
-    icon_paths.push_back(page_action_->default_icon_path());
-
-  for (std::vector<std::string>::iterator i(icon_paths.begin());
-       i != icon_paths.end(); ++i) {
-    tracker_.LoadImage(extension, extension->GetResource(*i),
-                       gfx::Size(Extension::kPageActionIconMaxSize,
-                                 Extension::kPageActionIconMaxSize),
-                       ImageLoadingTracker::DONT_CACHE);
-  }
+  icon_factory_.reset(new ExtensionActionIconFactory(extension, this));
 
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(
                      owner_->profile()->GetOriginalProfile()));
 
   set_accessibility_focusable(true);
   set_context_menu_controller(this);
 
   extensions::CommandService* command_service =
       extensions::CommandServiceFactory::GetForProfile(
@@ skipping 106 matching lines @@
 
 bool PageActionImageView::OnKeyPressed(const ui::KeyEvent& event) {
   if (event.key_code() == ui::VKEY_SPACE ||
       event.key_code() == ui::VKEY_RETURN) {
     ExecuteAction(ExtensionPopup::SHOW);
     return true;
   }
   return false;
 }
 
-void PageActionImageView::OnImageLoaded(const gfx::Image& image,
-                                        const std::string& extension_id,
-                                        int index) {
-  // We loaded icons()->size() icons, plus one extra if the page action had
-  // a default icon.
-  int total_icons = static_cast<int>(page_action_->icon_paths()->size());
-  if (!page_action_->default_icon_path().empty())
-    total_icons++;
-  DCHECK(index < total_icons);
-
-  // Map the index of the loaded image back to its name. If we ever get an
-  // index greater than the number of icons, it must be the default icon.
-  if (index < static_cast<int>(page_action_->icon_paths()->size()))
-    page_action_->CacheIcon(page_action_->icon_paths()->at(index), image);
-  else
-    page_action_->CacheIcon(page_action_->default_icon_path(), image);
-
-  // During object construction owner_ will be NULL.
-  TabContents* tab_contents = owner_ ? owner_->GetTabContents() : NULL;
-  if (tab_contents)
-    UpdateVisibility(tab_contents->web_contents(), current_url_);
-}
-
 void PageActionImageView::ShowContextMenuForView(View* source,
                                                  const gfx::Point& point) {
   const Extension* extension = owner_->profile()->GetExtensionService()->
       GetExtensionById(page_action()->extension_id(), false);
   if (!extension->ShowConfigureContextMenus())
     return;
 
   scoped_refptr<ExtensionContextMenuModel> context_menu_model(
       new ExtensionContextMenuModel(extension, browser_, this));
   views::MenuModelAdapter menu_model_adapter(context_menu_model.get());
@@ skipping 31 matching lines @@
       (!preview_enabled_ && !page_action_->GetIsVisible(current_tab_id_))) {
     SetVisible(false);
     return;
   }
 
   // Set the tooltip.
   tooltip_ = page_action_->GetTitle(current_tab_id_);
   SetTooltipText(UTF8ToUTF16(tooltip_));
 
   // Set the image.
-  gfx::Image icon = page_action_->GetIcon(current_tab_id_);
+  gfx::Image icon = page_action_->GetIcon(current_tab_id_, icon_factory_.get());
   if (!icon.IsEmpty())
     SetImage(*icon.ToImageSkia());
 
   SetVisible(true);
 }
 
 void PageActionImageView::InspectPopup(ExtensionAction* action) {
   ExecuteAction(ExtensionPopup::SHOW_AND_INSPECT);
 }
 
 void PageActionImageView::OnWidgetClosing(views::Widget* widget) {
   DCHECK_EQ(popup_->GetWidget(), widget);
   popup_->GetWidget()->RemoveObserver(this);
   popup_ = NULL;
 }
 
 void PageActionImageView::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_EXTENSION_UNLOADED, type);
   const Extension* unloaded_extension =
       content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
-  if (page_action_ == unloaded_extension ->page_action())
+  if (page_action_ == unloaded_extension->page_action())
     owner_->UpdatePageActions();
 }
 
-void PageActionImageView::OnIconChanged() {
+void PageActionImageView::OnIconUpdated() {
   TabContents* tab_contents = owner_->GetTabContents();
   if (tab_contents)
     UpdateVisibility(tab_contents->web_contents(), current_url_);
 }
 
+void PageActionImageView::OnIconChanged() {
+  OnIconUpdated();
+}
+
 void PageActionImageView::ShowPopupWithURL(
     const GURL& popup_url,
     ExtensionPopup::ShowAction show_action) {
   bool popup_showing = popup_ != NULL;
 
   // Always hide the current popup. Only one popup at a time.
   HidePopup();
 
   // If we were already showing, then treat this click as a dismiss.
   if (popup_showing)
     return;
 
   views::BubbleBorder::ArrowLocation arrow_location = base::i18n::IsRTL() ?
       views::BubbleBorder::TOP_LEFT : views::BubbleBorder::TOP_RIGHT;
 
   popup_ = ExtensionPopup::ShowPopup(popup_url, browser_, this, arrow_location,
                                      show_action);
   popup_->GetWidget()->AddObserver(this);
 }
 
 void PageActionImageView::HidePopup() {
   if (popup_)
     popup_->GetWidget()->Close();
 }