Make BackgroundContentsService start up BackgroundContents with a delay, as for ExtensionHosts.

chrome/browser/background/background_contents.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/background/background_contents.h"
 
+#include "base/lazy_instance.h"
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/chrome_extension_web_contents_observer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
+#include "extensions/browser/extension_host_queue.h"
+#include "extensions/browser/serial_extension_host_queue.h"
 #include "extensions/browser/view_type_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 using content::SiteInstance;
 using content::WebContents;
 
+namespace {
+
+// Singleton which wraps the chosen ExtensionHostQueue implementation.
+struct QueueWrapper {

[Devlin, 2015/02/18 23:22:12]

Should we have two separate queues for extension hosts and background contents? 
Possibly more importantly, should they be of (potentially) different
implementations?  Or should we put this somewhere more central where it can be
shared between extension hosts and background contents?

[Yoyo Zhou, 2015/02/19 02:55:37]

I don't have a strong preference either way. I think we could get a singleton
(lazy instance) SerialExtensionHostQueue, so we replace references to
g_queue_wrapper with SerialExtensionHostQueue::GetInstance. (An alternative
might be to make ExtensionHostQueue::GetInstance do the right thing, which puts
a dependency from the new extension_host_queue.cc to
serial_extension_host_queue.h.) What do you think?

[Devlin, 2015/02/19 16:41:43]

I think Ben's trying to make it easy to switch between different implementations
of the queue, so I don't think making a lazy instance of
SerialExtensionHostQueue is the right thing to do, as it binds all the code that
uses the queue to a particular implementation.  I think that, for now at least,
I'd prefer ExtensionHostQueue::GetInstance to just Do The Right Thing -
depending on how big all the implementations turn out, we could even put them
all into extension_host_queue.cc in an anonymous namespace.  Even if we don't,
the dependency on each implementation is unfortunate, but probably better than
each client having a dependency on each implementation. ;)

[not at google - send to devlin, 2015/02/19 18:07:41]

Note that I will probably need to modify the way the Singleton-isms work here
and instead delegate ExtensionHostQueue creation to chrome. I will want to
experiment with an ExtensionHostQueue implementation that delays until the first
tab has loaded, which means it needs to go in the //chrome layer.

As for the general question: ExtensionHostQueue::GetInstance() sounds
reasonable, if it's delegatable.

[Yoyo Zhou, 2015/02/19 23:57:58]

Turns out we have an ExtensionHostDelegate which works quite well for this
delegation. This makes it easy to share a queue for BackgroundContents and
ExtensionHosts, and if someone else wants their own queue, they can just make
one.

[not at google - send to devlin, 2015/02/20 00:28:33]

Sweet, that's where I put it as well (in my unfinished, probably never to be
finished by the sounds of it, patch).

+  QueueWrapper() : queue(new extensions::SerialExtensionHostQueue()) {}
+  scoped_ptr<extensions::ExtensionHostQueue> queue;
+};
+base::LazyInstance<QueueWrapper> g_queue_wrapper = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
 BackgroundContents::BackgroundContents(
     SiteInstance* site_instance,
     int routing_id,
     int main_frame_routing_id,
     Delegate* delegate,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace)
     : delegate_(delegate) {
   profile_ = Profile::FromBrowserContext(
       site_instance->GetBrowserContext());
@@ skipping 40 matching lines @@
 
   // Unregister for any notifications before notifying observers that we are
   // going away - this prevents any re-entrancy due to chained notifications
   // (http://crbug.com/237781).
   registrar_.RemoveAll();
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED,
       content::Source<Profile>(profile_),
       content::Details<BackgroundContents>(this));
+
+  g_queue_wrapper.Get().queue->Remove(this);
 }
 
 const GURL& BackgroundContents::GetURL() const {
   return web_contents_.get() ? web_contents_->GetURL() : GURL::EmptyGURL();
 }
 
+void BackgroundContents::CreateRenderViewSoon(const GURL& url) {
+  initial_url_ = url;
+  g_queue_wrapper.Get().queue->Add(this);
+}
+
+void BackgroundContents::CreateRenderViewNow() {
+  web_contents()->GetController().LoadURL(initial_url_, content::Referrer(),
+                                          ui::PAGE_TRANSITION_LINK,
+                                          std::string());
+}
+
 void BackgroundContents::CloseContents(WebContents* source) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BACKGROUND_CONTENTS_CLOSED,
       content::Source<Profile>(profile_),
       content::Details<BackgroundContents>(this));
   delete this;
 }
 
 bool BackgroundContents::ShouldSuppressDialogs(WebContents* source) {
   return true;
@@ skipping 52 matching lines @@
     case chrome::NOTIFICATION_PROFILE_DESTROYED:
     case chrome::NOTIFICATION_APP_TERMINATING: {
       delete this;
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification sent.";
       break;
   }
 }