Lazy creating of background pages --enable-lazy-background-pages)

chrome/browser/ui/gtk/browser_actions_toolbar_gtk.cc

 // Copyright (c) 2011 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/gtk/browser_actions_toolbar_gtk.h"
 
 #include <algorithm>
 #include <vector>
 
+#include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_context_menu_model.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/image_loading_tracker.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/gtk/cairo_cached_surface.h"
 #include "chrome/browser/ui/gtk/extensions/extension_popup_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_chrome_button.h"
 #include "chrome/browser/ui/gtk/gtk_chrome_shrinkable_hbox.h"
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/hover_controller_gtk.h"
 #include "chrome/browser/ui/gtk/menu_gtk.h"
 #include "chrome/browser/ui/gtk/view_id_util.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "grit/ui_resources.h"
@@ skipping 47 matching lines @@
                             public MenuGtk::Delegate {
  public:
   BrowserActionButton(BrowserActionsToolbarGtk* toolbar,
                       const Extension* extension,
                       GtkThemeService* theme_provider)
       : toolbar_(toolbar),
         extension_(extension),
         image_(NULL),
         tracker_(this),
         tab_specific_icon_(NULL),
-        default_icon_(NULL) {
+        default_icon_(NULL),
+        waiting_for_background_page_(false) {
     button_.reset(new CustomDrawButton(
         theme_provider,
         IDR_BROWSER_ACTION,
         IDR_BROWSER_ACTION_P,
         IDR_BROWSER_ACTION_H,
         0,
         NULL));
     alignment_.Own(gtk_alignment_new(0, 0, 1, 1));
     gtk_container_add(GTK_CONTAINER(alignment_.get()), button());
     gtk_widget_show(button());
@@ skipping 38 matching lines @@
   GtkWidget* button() { return button_->widget(); }
 
   GtkWidget* widget() { return alignment_.get(); }
 
   const Extension* extension() { return extension_; }
 
   // NotificationObserver implementation.
   void Observe(int type,
                const NotificationSource& source,
                const NotificationDetails& details) {
-    if (type == chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED)
+    if (type == chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED) {
       UpdateState();
-    else
+    } else if (type == chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING) {
+      BrowserActionExecuted();
+      registrar_.Remove(this,
+                        chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
+                        Source<Profile>(toolbar_->browser()->profile()));
+      waiting_for_background_page_ = false;
+    } else {
       NOTREACHED();
+    }
   }
 
   // ImageLoadingTracker::Observer implementation.
   void OnImageLoaded(SkBitmap* image, const ExtensionResource& resource,
                      int index) {
     if (image) {
       default_skbitmap_ = *image;
       default_icon_ = gfx::GdkPixbufFromSkBitmap(image);
     }
     UpdateState();
   }
 
+  bool IsBackgroundPageMissing() {
+    if (extension_->background_url().is_valid()) {
+      ExtensionProcessManager* pm =
+          toolbar_->browser()->profile()->GetExtensionProcessManager();
+      return pm->GetBackgroundHostForExtension(extension_) == NULL;
+    }
+
+    return false;  // Extension doesn't have a background page.
+  }
+
+
+  void AddObserverForBackgroundPageLoaded() {
+    if (waiting_for_background_page_)
+      return;  // NotificationRegistrar doesn't like dups.
+    registrar_.Add(this,
+                   chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
+                   Source<Profile>(toolbar_->browser()->profile()));
+    waiting_for_background_page_ = true;
+  }
+
+  void BrowserActionExecuted() {
+    ExtensionService* service =
+        toolbar_->browser()->profile()->GetExtensionService();
+    service->browser_event_router()->BrowserActionExecuted(
+        toolbar_->browser()->profile(), extension_->id(),
+        toolbar_->browser());
+  }
+
   // Updates the button based on the latest state from the associated
   // browser action.
   void UpdateState() {
     int tab_id = toolbar_->GetCurrentTabId();
     if (tab_id < 0)
       return;
 
     std::string tooltip = extension_->browser_action()->GetTitle(tab_id);
     if (tooltip.empty())
       gtk_widget_set_has_tooltip(button(), FALSE);
@@ skipping 100 matching lines @@
     action->button_->SetPaintOverride(GTK_STATE_ACTIVE);
     menu->PopupForWidget(widget, event->button, event->time);
 
     return TRUE;
   }
 
   static void OnClicked(GtkWidget* widget, BrowserActionButton* action) {
     if (action->ShowPopup(false))
       return;
 
-    ExtensionService* service =
-        action->toolbar_->browser()->profile()->GetExtensionService();
-    service->browser_event_router()->BrowserActionExecuted(
-        action->toolbar_->browser()->profile(), action->extension_->id(),
-        action->toolbar_->browser());
+    // Time to create the background page!
+    if (CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableLazyBackgroundPages) &&
+        action->IsBackgroundPageMissing()) {
+      // Dispatch the OnClicked event when the background page is loaded.
+      action->AddObserverForBackgroundPageLoaded();
+
+      ExtensionProcessManager* pm =
+          action->toolbar_->browser()->profile()->GetExtensionProcessManager();
+      pm->CreateBackgroundHost(action->extension_,
+                               action->extension_->background_url());
+    } else {
+      action->BrowserActionExecuted();
+    }
   }
 
   static gboolean OnExposeEvent(GtkWidget* widget,
                                 GdkEventExpose* event,
                                 BrowserActionButton* button) {
     int tab_id = button->toolbar_->GetCurrentTabId();
     if (tab_id < 0)
       return FALSE;
 
     ExtensionAction* action = button->extension_->browser_action();
@@ skipping 45 matching lines @@
   // Same as |default_icon_|, but stored as SkBitmap.
   SkBitmap default_skbitmap_;
 
   ui::GtkSignalRegistrar signals_;
   NotificationRegistrar registrar_;
 
   // The context menu view and model for this extension action.
   scoped_ptr<MenuGtk> context_menu_;
   scoped_refptr<ExtensionContextMenuModel> context_menu_model_;
 
+  bool waiting_for_background_page_;
+
   friend class BrowserActionsToolbarGtk;
 };
 
 // BrowserActionsToolbarGtk ----------------------------------------------------
 
 BrowserActionsToolbarGtk::BrowserActionsToolbarGtk(Browser* browser)
     : browser_(browser),
       profile_(browser->profile()),
       theme_service_(GtkThemeService::GetFrom(browser->profile())),
       model_(NULL),
@@ skipping 579 matching lines @@
 
   menu->PopupAsContext(gfx::Point(event->x_root, event->y_root),
                        event->time);
   return TRUE;
 }
 
 void BrowserActionsToolbarGtk::OnButtonShowOrHide(GtkWidget* sender) {
   if (!resize_animation_.is_animating())
     UpdateChevronVisibility();
 }