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

extensions/browser/extension_host.cc

 // Copyright 2014 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 "extensions/browser/extension_host.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 32 matching lines @@
 
 using content::BrowserContext;
 using content::OpenURLParams;
 using content::RenderProcessHost;
 using content::RenderViewHost;
 using content::SiteInstance;
 using content::WebContents;
 
 namespace extensions {
 
-namespace {
-
-// Singleton which wraps our current ExtensionHostQueue implementation.
-struct QueueWrapper {
-  QueueWrapper() : queue(new SerialExtensionHostQueue()) {}
-  scoped_ptr<ExtensionHostQueue> queue;
-};
-base::LazyInstance<QueueWrapper> g_queue_wrapper = LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
 ExtensionHost::ExtensionHost(const Extension* extension,
                              SiteInstance* site_instance,
                              const GURL& url,
                              ViewType host_type)
     : delegate_(ExtensionsBrowserClient::Get()->CreateExtensionHostDelegate()),
       extension_(extension),
       extension_id_(extension->id()),
       browser_context_(site_instance->GetBrowserContext()),
       render_view_host_(nullptr),
       did_stop_loading_(false),
@@ skipping 29 matching lines @@
       load_start_.get()) {
     UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageActiveTime2",
                              load_start_->Elapsed());
   }
   content::NotificationService::current()->Notify(
       extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
       content::Source<BrowserContext>(browser_context_),
       content::Details<ExtensionHost>(this));
   FOR_EACH_OBSERVER(ExtensionHostObserver, observer_list_,
                     OnExtensionHostDestroyed(this));
-  g_queue_wrapper.Get().queue->Remove(this);
+  delegate_->GetExtensionHostQueue()->Remove(this);
   // Immediately stop observing |host_contents_| because its destruction events
   // (like DidStopLoading, it turns out) can call back into ExtensionHost
   // re-entrantly, when anything declared after |host_contents_| has already
   // been destroyed.
   content::WebContentsObserver::Observe(nullptr);
 }
 
 content::RenderProcessHost* ExtensionHost::render_process_host() const {
   return render_view_host()->GetProcess();
 }
 
 RenderViewHost* ExtensionHost::render_view_host() const {
   // TODO(mpcomplete): This can be null. How do we handle that?
   return render_view_host_;
 }
 
 bool ExtensionHost::IsRenderViewLive() const {
   return render_view_host()->IsRenderViewLive();
 }
 
 void ExtensionHost::CreateRenderViewSoon() {
   if (render_process_host() && render_process_host()->HasConnection()) {
     // If the process is already started, go ahead and initialize the RenderView
     // synchronously. The process creation is the real meaty part that we want
     // to defer.
     CreateRenderViewNow();
   } else {
-    g_queue_wrapper.Get().queue->Add(this);
+    delegate_->GetExtensionHostQueue()->Add(this);
   }
 }
 
 void ExtensionHost::CreateRenderViewNow() {
   LoadInitialURL();
   if (IsBackgroundPage()) {
     DCHECK(IsRenderViewLive());
     if (extension_) {
       std::string group_name = base::FieldTrialList::FindFullName(
           "ThrottleExtensionBackgroundPages");
@@ skipping 280 matching lines @@
   return delegate_->CheckMediaAccessPermission(
       web_contents, security_origin, type, extension());
 }
 
 bool ExtensionHost::IsNeverVisible(content::WebContents* web_contents) {
   ViewType view_type = extensions::GetViewType(web_contents);
   return view_type == extensions::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE;
 }
 
 }  // namespace extensions