Eliminate all UI thread decoding of extension images....

chrome/browser/views/browser_actions_container.cc

 // Copyright (c) 2010 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/views/browser_actions_container.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
 #include "base/stl_util-inl.h"
@@ skipping 80 matching lines @@
 bool BrowserActionsContainer::disable_animations_during_testing_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserActionButton
 
 BrowserActionButton::BrowserActionButton(Extension* extension,
                                          BrowserActionsContainer* panel)
     : ALLOW_THIS_IN_INITIALIZER_LIST(MenuButton(this, L"", NULL, false)),
       browser_action_(extension->browser_action()),
       extension_(extension),
-      tracker_(NULL),
+      ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(this)),
       showing_context_menu_(false),
       panel_(panel) {
   set_alignment(TextButton::ALIGN_CENTER);
 
   // No UpdateState() here because View hierarchy not setup yet. Our parent
   // should call UpdateState() after creation.
 
   registrar_.Add(this, NotificationType::EXTENSION_BROWSER_ACTION_UPDATED,
                  Source<ExtensionAction>(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 relative_path = browser_action_->default_icon_path();
   if (relative_path.empty())
     return;
 
   // This is a bit sketchy because if ImageLoadingTracker calls
   // ::OnImageLoaded() before our creator appends up to the view hierarchy, we
   // will crash. But since we know that ImageLoadingTracker is asynchronous,
   // this should be OK. And doing this in the constructor means that we don't
   // have to protect against it getting done multiple times.
-  tracker_ = new ImageLoadingTracker(this, 1);
-  tracker_->PostLoadImageTask(
+  tracker_.PostLoadImageTask(
       extension->GetResource(relative_path),
       gfx::Size(Extension::kBrowserActionIconMaxSize,
-                Extension::kBrowserActionIconMaxSize));
+                Extension::kBrowserActionIconMaxSize),
+      0);  // |index| == 0, since we only ever load one image.
 }
 
 BrowserActionButton::~BrowserActionButton() {
-  if (tracker_)
-    tracker_->StopTrackingImageLoad();
 }
 
 gfx::Insets BrowserActionButton::GetInsets() const {
   static gfx::Insets zero_inset;
   return zero_inset;
 }
 
 void BrowserActionButton::ButtonPressed(views::Button* sender,
     const views::Event& event) {
   panel_->OnBrowserActionExecuted(this, false);  // inspect_with_devtools
 }
 
-void BrowserActionButton::OnImageLoaded(SkBitmap* image, size_t index) {
+void BrowserActionButton::OnImageLoaded(SkBitmap* image, int index) {
   if (image)
     default_icon_ = *image;
 
-  tracker_ = NULL;  // The tracker object will delete itself when we return.
-
   // Call back to UpdateState() because a more specific icon might have been set
   // while the load was outstanding.
   UpdateState();
 }
 
 void BrowserActionButton::UpdateState() {
   int tab_id = panel_->GetCurrentTabId();
   if (tab_id < 0)
     return;
 
@@ skipping 39 matching lines @@
   if (tab_id < 0) {
     NOTREACHED() << "Button is not on a specific tab.";
     GURL empty_url;
     return empty_url;
   }
   return browser_action_->GetPopupUrl(tab_id);
 }
 
 bool BrowserActionButton::Activate() {
   if (IsPopup()) {
-    panel_->OnBrowserActionExecuted(this, false); // inspect_with_devtools
+    panel_->OnBrowserActionExecuted(this, false);  // |inspect_with_devtools|.
 
     // TODO(erikkay): Run a nested modal loop while the mouse is down to
     // enable menu-like drag-select behavior.
 
     // The return value of this method is returned via OnMousePressed.
     // We need to return false here since we're handing off focus to another
     // widget/view, and true will grab it right back and try to send events
     // to us.
     return false;
   }
@@ skipping 283 matching lines @@
   owner_view_->SchedulePaint();
 }
 
 void BrowserActionsContainer::HidePopup() {
   if (popup_)
     popup_->Close();
 }
 
 void BrowserActionsContainer::TestExecuteBrowserAction(int index) {
   BrowserActionButton* button = browser_action_views_[index]->button();
-  OnBrowserActionExecuted(button, false); // inspect_with_devtools
+  OnBrowserActionExecuted(button, false);  // |inspect_with_devtools|.
 }
 
 void BrowserActionsContainer::TestSetIconVisibilityCount(size_t icons) {
   chevron_->SetVisible(icons < browser_action_views_.size());
   container_size_.set_width(IconCountToWidth(icons));
   Layout();
   SchedulePaint();
 }
 
 void BrowserActionsContainer::OnBrowserActionExecuted(
@@ skipping 582 matching lines @@
 
 void BrowserActionsContainer::NotifyMenuDeleted(
     BrowserActionOverflowMenuController* controller) {
   DCHECK(controller == overflow_menu_);
   overflow_menu_ = NULL;
 }
 
 void BrowserActionsContainer::InspectPopup(
     ExtensionAction* action) {
   OnBrowserActionExecuted(GetBrowserActionView(action)->button(),
-      true); // inspect_with_devtools
+      true);  // |inspect_with_devtools|.
 }
 
 void BrowserActionsContainer::ExtensionPopupClosed(ExtensionPopup* popup) {
   // ExtensionPopup is ref-counted, so we don't need to delete it.
   DCHECK_EQ(popup_, popup);
   popup_ = NULL;
   popup_button_->SetButtonNotPushed();
   popup_button_ = NULL;
 }
 
 bool BrowserActionsContainer::ShouldDisplayBrowserAction(Extension* extension) {
   // Only display incognito-enabled extensions while in incognito mode.
   return (!profile_->IsOffTheRecord() ||
           profile_->GetExtensionsService()->IsIncognitoEnabled(extension));
 }