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

chrome/browser/ui/cocoa/extensions/browser_action_button.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/extensions/browser_action_button.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/sys_string_conversions.h"
-#include "chrome/browser/extensions/image_loading_tracker.h"
+#include "chrome/browser/extensions/extension_action_icon_factory.h"
 #include "chrome/browser/ui/cocoa/extensions/extension_action_context_menu.h"
 #import "chrome/browser/ui/cocoa/image_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/theme_resources.h"
@@ skipping 14 matching lines @@
     @"BrowserActionButtonDragEndNotification";
 
 static const CGFloat kBrowserActionBadgeOriginYOffset = 5;
 
 namespace {
 const CGFloat kAnimationDuration = 0.2;
 }  // anonymous namespace
 
 // A helper class to bridge the asynchronous Skia bitmap loading mechanism to
 // the extension's button.
-class ExtensionImageTrackerBridge : public content::NotificationObserver,
-                                    public ImageLoadingTracker::Observer {
+class ExtensionActionIconFactoryBridge
+    : public content::NotificationObserver,
+      public ExtensionActionIconFactory::Observer {
  public:
-  ExtensionImageTrackerBridge(BrowserActionButton* owner,
-                              const Extension* extension)
+  ExtensionActionIconFactoryBridge(BrowserActionButton* owner,
+                                   const Extension* extension)
       : owner_(owner),
-        tracker_(this),
+        icon_factory_(extension, this),
         browser_action_(extension->browser_action()) {
-    // The Browser Action API does not allow the default icon path to be
-    // changed at runtime, so we can load this now and cache it.
-    std::string path = extension->browser_action()->default_icon_path();
-    if (!path.empty()) {
-      tracker_.LoadImage(extension, extension->GetResource(path),
-                         gfx::Size(Extension::kBrowserActionIconMaxSize,
-                                   Extension::kBrowserActionIconMaxSize),
-                         ImageLoadingTracker::DONT_CACHE);
-    }
     registrar_.Add(
         this, chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
         content::Source<ExtensionAction>(browser_action_));
   }
 
-  ~ExtensionImageTrackerBridge() {}
+  virtual ~ExtensionActionIconFactoryBridge() {}
 
   // ImageLoadingTracker::Observer implementation.
-  void OnImageLoaded(const gfx::Image& image,
-                     const std::string& extension_id,
-                     int index) OVERRIDE {
-    browser_action_->CacheIcon(browser_action_->default_icon_path(), image);
+  void OnIconUpdated() OVERRIDE {
     [owner_ updateState];
   }
 
   // Overridden from content::NotificationObserver.
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) {
     if (type == chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED)
       [owner_ updateState];
     else
       NOTREACHED();
   }
 
+  gfx::Image GetIcon(int tabId) {
+    // Note that |icon_factory_| is not const in |GetIcon|.
+    return browser_action_->GetIcon(tabId, &icon_factory_);
+  }
+
  private:
   // Weak. Owns us.
   BrowserActionButton* owner_;
 
-  // Loads the button's icons for us on the file thread.
-  ImageLoadingTracker tracker_;
+  // The object that browser action will use to create icon for us.
+  // It may load icon asynchronously (in which case initial icon returned by
+  // the action will be blank), so we have to observe it for icon's updates.
+  ExtensionActionIconFactory icon_factory_;
 
   // The browser action whose images we're loading.
   ExtensionAction* const browser_action_;
 
   // Used for registering to receive notifications and automatic clean up.
   content::NotificationRegistrar registrar_;
 
-  DISALLOW_COPY_AND_ASSIGN(ExtensionImageTrackerBridge);
+  DISALLOW_COPY_AND_ASSIGN(ExtensionActionIconFactoryBridge);
 };
 
 @interface BrowserActionCell (Internals)
 - (void)drawBadgeWithinFrame:(NSRect)frame;
 @end
 
 @interface BrowserActionButton (Private)
 - (void)endDrag;
 @end
 
@@ skipping 29 matching lines @@
     [self setButtonType:NSMomentaryChangeButton];
     [self setShowsBorderOnlyWhileMouseInside:YES];
 
     [self setMenu:[[[ExtensionActionContextMenu alloc]
         initWithExtension:extension
                   browser:browser
           extensionAction:extension->browser_action()] autorelease]];
 
     tabId_ = tabId;
     extension_ = extension;
-    imageLoadingBridge_.reset(new ExtensionImageTrackerBridge(self, extension));
+    iconFactoryBridge_.reset(
+        new ExtensionActionIconFactoryBridge(self, extension));
 
     moveAnimation_.reset([[NSViewAnimation alloc] init]);
     [moveAnimation_ gtm_setDuration:kAnimationDuration
                           eventMask:NSLeftMouseUpMask];
     [moveAnimation_ setAnimationBlockingMode:NSAnimationNonblocking];
 
     [self updateState];
   }
 
   return self;
@@ skipping 79 matching lines @@
   if (tabId_ < 0)
     return;
 
   std::string tooltip = extension_->browser_action()->GetTitle(tabId_);
   if (tooltip.empty()) {
     [self setToolTip:nil];
   } else {
     [self setToolTip:base::SysUTF8ToNSString(tooltip)];
   }
 
-  gfx::Image image = extension_->browser_action()->GetIcon(tabId_);
+  gfx::Image image = iconFactoryBridge_->GetIcon(tabId_);
+
   if (!image.IsEmpty())
     [self setImage:image.ToNSImage()];
 
   [[self cell] setTabId:tabId_];
 
   bool enabled = extension_->browser_action()->GetIsVisible(tabId_);
   [self setEnabled:enabled ? YES : NO];
 
   [self setNeedsDisplay:YES];
 }
@@ skipping 44 matching lines @@
 }
 
 - (void)drawInteriorWithFrame:(NSRect)cellFrame inView:(NSView*)controlView {
   gfx::ScopedNSGraphicsContextSaveGState scopedGState;
   [super drawInteriorWithFrame:cellFrame inView:controlView];
   cellFrame.origin.y += kBrowserActionBadgeOriginYOffset;
   [self drawBadgeWithinFrame:cellFrame];
 }
 
 @end