Create renderers for ExtensionHosts one a time to avoid blocking the UI.

chrome/browser/extensions/extension_host.cc

 // Copyright (c) 2006-2009 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/extensions/extension_host.h"
 
+#include <list>
+
 #include "app/resource_bundle.h"
+#include "base/message_loop.h"
+#include "base/singleton.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
@@ skipping 14 matching lines @@
 #include "webkit/glue/context_menu.h"
 
 using WebKit::WebDragOperation;
 using WebKit::WebDragOperationsMask;
 
 // static
 bool ExtensionHost::enable_dom_automation_ = false;
 
 static const char* kToolstripTextColorSubstitution = "$TEXT_COLOR$";
 
+// Helper class that rate-limits the creation of renderer processes for
+// ExtensionHosts, to avoid blocking the UI.
+class ExtensionHost::ProcessCreationQueue {
+ public:
+  static ProcessCreationQueue* get() {
+    return Singleton<ProcessCreationQueue>::get();
+  }
+
+  // Add a host to the queue for RenderView creation.
+  void CreateSoon(ExtensionHost* host) {
+    queue_.push_back(host);
+    PostTask();
+  }
+
+  // Remove a host from the queue (in case it's being deleted).
+  void Remove(ExtensionHost* host) {
+    Queue::iterator it = std::find(queue_.begin(), queue_.end(), host);
+    if (it != queue_.end())
+      queue_.erase(it);
+  }
+
+ private:
+  friend class Singleton<ProcessCreationQueue>;
+  friend struct DefaultSingletonTraits<ProcessCreationQueue>;
+  ProcessCreationQueue()
+      : pending_create_(false),
+        ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) { }
+
+  // Queue up a delayed task to process the next ExtensionHost in the queue.
+  void PostTask() {
+    if (!pending_create_) {
+      MessageLoop::current()->PostTask(FROM_HERE,
+          method_factory_.NewRunnableMethod(
+             &ProcessCreationQueue::ProcessOneHost));
+      pending_create_ = true;
+    }
+  }
+
+  // Create the RenderView for the next host in the queue.
+  void ProcessOneHost() {
+    pending_create_ = false;
+    if (queue_.empty())
+      return;  // can happen on shutdown
+
+    queue_.front()->CreateRenderViewNow();
+    queue_.pop_front();
+
+    if (!queue_.empty())
+      PostTask();
+  }
+
+  typedef std::list<ExtensionHost*> Queue;
+  Queue queue_;
+  bool pending_create_;
+  ScopedRunnableMethodFactory<ProcessCreationQueue> method_factory_;
+};
+
+////////////////
+// ExtensionHost
+
 ExtensionHost::ExtensionHost(Extension* extension, SiteInstance* site_instance,
                              const GURL& url, ViewType::Type host_type)
     : extension_(extension),
       profile_(site_instance->browsing_instance()->profile()),
       did_stop_loading_(false),
       document_element_available_(false),
       url_(url),
       extension_host_type_(host_type) {
   render_view_host_ = new RenderViewHost(
       site_instance, this, MSG_ROUTING_NONE, NULL);
   render_view_host_->AllowBindings(BindingsPolicy::EXTENSION);
   if (enable_dom_automation_)
     render_view_host_->AllowBindings(BindingsPolicy::DOM_AUTOMATION);
 }
 
 ExtensionHost::~ExtensionHost() {
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_HOST_DESTROYED,
       Source<Profile>(profile_),
       Details<ExtensionHost>(this));
+  ProcessCreationQueue::get()->Remove(this);
   render_view_host_->Shutdown();  // deletes render_view_host
 }
 
 void ExtensionHost::CreateView(Browser* browser) {
 #if defined(TOOLKIT_VIEWS)
   view_.reset(new ExtensionView(this, browser));
   // We own |view_|, so don't auto delete when it's removed from the view
   // hierarchy.
   view_->SetParentOwned(false);
 #elif defined(OS_LINUX)
@@ skipping 13 matching lines @@
 }
 
 SiteInstance* ExtensionHost::site_instance() const {
   return render_view_host_->site_instance();
 }
 
 bool ExtensionHost::IsRenderViewLive() const {
   return render_view_host_->IsRenderViewLive();
 }
 
-void ExtensionHost::CreateRenderView(RenderWidgetHostView* host_view) {
+void ExtensionHost::CreateRenderViewSoon(RenderWidgetHostView* host_view) {
   render_view_host_->set_view(host_view);
+  ProcessCreationQueue::get()->CreateSoon(this);
+}
+
+void ExtensionHost::CreateRenderViewNow() {
   render_view_host_->CreateRenderView();
   NavigateToURL(url_);
   DCHECK(IsRenderViewLive());
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_PROCESS_CREATED,
       Source<Profile>(profile_),
       Details<ExtensionHost>(this));
 }
 
 void ExtensionHost::NavigateToURL(const GURL& url) {
@@ skipping 290 matching lines @@
     window_id = ExtensionTabUtil::GetWindowId(
         const_cast<ExtensionHost* >(this)->GetBrowser());
   } else if (extension_host_type_ == ViewType::EXTENSION_BACKGROUND_PAGE) {
     // Background page is not attached to any browser window, so pass -1.
     window_id = -1;
   } else {
     NOTREACHED();
   }
   return window_id;
 }