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

chrome/browser/background/background_contents.cc

Index: chrome/browser/background/background_contents.cc
diff --git a/chrome/browser/background/background_contents.cc b/chrome/browser/background/background_contents.cc
index 7a1150b347a983fc2a213b3d228a83dba6625537..6b56660137f61a9e20116b5c68a4004cc531103b 100644
--- a/chrome/browser/background/background_contents.cc
+++ b/chrome/browser/background/background_contents.cc
@@ -4,6 +4,7 @@
 
 #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"
@@ -16,12 +17,25 @@
 #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,
@@ -82,12 +96,25 @@ BackgroundContents::~BackgroundContents() {
       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,