Remove logic for lazy initialization of WebKit.

See "Extensions impact on startup?" thread on (internal) chrome-fast mailing list from 8/14/2015 for background, which showed that effectively undoing this logic showed a 3% reduction on first_non_empty_paint_time. This lazy initialization used to be a performance win when it was added years ago, but has since become a performance drag. Since it's effectively not used now (since ChromeContentRendererClient::RenderThreadStarted always initializes WebKit through its call to RenderThread::RegisterExtension), just remove this unused logic.

Review URL: https://codereview.chromium.org/1821413003

Cr-Commit-Position: refs/heads/master@{#382795}

24 files changed, 156 insertions, 259 deletions

diff --git a/android_webview/renderer/aw_content_renderer_client.cc b/android_webview/renderer/aw_content_renderer_client.cc
index 7203f90..0ea5fac 100644
--- a/android_webview/renderer/aw_content_renderer_client.cc
+++ b/android_webview/renderer/aw_content_renderer_client.cc
@@ -68,9 +68,6 @@ void AwContentRendererClient::RenderThreadStarted() {
   visited_link_slave_.reset(new visitedlink::VisitedLinkSlave);
   thread->AddObserver(visited_link_slave_.get());
 
-  // Using WebString requires blink initialization.
-  thread->EnsureWebKitInitialized();
-
   blink::WebString content_scheme(base::ASCIIToUTF16(url::kContentScheme));
   blink::WebSecurityPolicy::registerURLSchemeAsLocal(content_scheme);
 
diff --git a/android_webview/renderer/aw_render_process_observer.cc b/android_webview/renderer/aw_render_process_observer.cc
index ab7d9d3..4719239 100644
--- a/android_webview/renderer/aw_render_process_observer.cc
+++ b/android_webview/renderer/aw_render_process_observer.cc
@@ -11,8 +11,7 @@
 
 namespace android_webview {
 
-AwRenderProcessObserver::AwRenderProcessObserver()
-  : webkit_initialized_(false) {
+AwRenderProcessObserver::AwRenderProcessObserver() {
 }
 
 AwRenderProcessObserver::~AwRenderProcessObserver() {
@@ -29,18 +28,12 @@ bool AwRenderProcessObserver::OnControlMessageReceived(
   return handled;
 }
 
-void AwRenderProcessObserver::WebKitInitialized() {
-  webkit_initialized_ = true;
-}
-
 void AwRenderProcessObserver::OnClearCache() {
-  if (webkit_initialized_)
-    blink::WebCache::clear();
+  blink::WebCache::clear();
 }
 
 void AwRenderProcessObserver::OnSetJsOnlineProperty(bool network_up) {
-  if (webkit_initialized_)
-    blink::WebNetworkStateNotifier::setOnLine(network_up);
+  blink::WebNetworkStateNotifier::setOnLine(network_up);
 }
 
 }  // nanemspace android_webview
diff --git a/android_webview/renderer/aw_render_process_observer.h b/android_webview/renderer/aw_render_process_observer.h
index b2df85d..96bda4b 100644
--- a/android_webview/renderer/aw_render_process_observer.h
+++ b/android_webview/renderer/aw_render_process_observer.h
@@ -20,13 +20,10 @@ class AwRenderProcessObserver : public content::RenderProcessObserver {
 
   // content::RenderProcessObserver implementation.
   bool OnControlMessageReceived(const IPC::Message& message) override;
-  void WebKitInitialized() override;
 
  private:
   void OnClearCache();
   void OnSetJsOnlineProperty(bool network_up);
-
-  bool webkit_initialized_;
 };
 
 }  // namespace android_webview
diff --git a/blimp/engine/app/blimp_content_renderer_client.cc b/blimp/engine/app/blimp_content_renderer_client.cc
index 43b388d..9b9b40a 100644
--- a/blimp/engine/app/blimp_content_renderer_client.cc
+++ b/blimp/engine/app/blimp_content_renderer_client.cc
@@ -6,7 +6,6 @@
 
 #include "blimp/common/compositor/blimp_image_serialization_processor.h"
 #include "components/web_cache/renderer/web_cache_render_process_observer.h"
-#include "content/public/renderer/render_thread.h"
 
 namespace blimp {
 namespace engine {
@@ -20,7 +19,6 @@ BlimpContentRendererClient::~BlimpContentRendererClient() {}
 
 void BlimpContentRendererClient::RenderThreadStarted() {
   web_cache_observer_.reset(new web_cache::WebCacheRenderProcessObserver());
-  content::RenderThread::Get()->AddObserver(web_cache_observer_.get());
 }
 
 cc::ImageSerializationProcessor*
diff --git a/chrome/renderer/chrome_content_renderer_client.cc b/chrome/renderer/chrome_content_renderer_client.cc
index a7d0931..8d2b344 100644
--- a/chrome/renderer/chrome_content_renderer_client.cc
+++ b/chrome/renderer/chrome_content_renderer_client.cc
@@ -355,7 +355,6 @@ void ChromeContentRendererClient::RenderThreadStarted() {
 #endif
 
   thread->AddObserver(chrome_observer_.get());
-  thread->AddObserver(web_cache_observer_.get());
 #if defined(FULL_SAFE_BROWSING)
   thread->AddObserver(phishing_classifier_.get());
 #endif
diff --git a/chrome/renderer/chrome_render_process_observer.cc b/chrome/renderer/chrome_render_process_observer.cc
index e8daff7..fab4631 100644
--- a/chrome/renderer/chrome_render_process_observer.cc
+++ b/chrome/renderer/chrome_render_process_observer.cc
@@ -183,7 +183,7 @@ class ResourceUsageReporterImpl : public ResourceUsageReporter {
     // Since it is not safe to call any Blink or V8 functions until Blink has
     // been initialized (which also initializes V8), early out and send 0 back
     // for all resources.
-    if (!observer_ || !observer_->webkit_initialized()) {
+    if (!observer_) {
       SendResults();
       return;
     }
@@ -238,7 +238,7 @@ void CreateResourceUsageReporter(
 bool ChromeRenderProcessObserver::is_incognito_process_ = false;
 
 ChromeRenderProcessObserver::ChromeRenderProcessObserver()
-    : webkit_initialized_(false), weak_factory_(this) {
+    : weak_factory_(this) {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
@@ -274,6 +274,19 @@ ChromeRenderProcessObserver::ChromeRenderProcessObserver()
       chrome_common_media::LocalizedStringProvider);
 
   InitFieldTrialObserving(command_line);
+
+  // chrome-native: is a scheme used for placeholder navigations that allow
+  // UIs to be drawn with platform native widgets instead of HTML.  These pages
+  // should not be accessible, and should also be treated as empty documents
+  // that can commit synchronously.  No code should be runnable in these pages,
+  // so it should not need to access anything nor should it allow javascript
+  // URLs since it should never be visible to the user.
+  WebString native_scheme(base::ASCIIToUTF16(chrome::kChromeNativeScheme));
+  WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(native_scheme);
+  WebSecurityPolicy::registerURLSchemeAsEmptyDocument(native_scheme);
+  WebSecurityPolicy::registerURLSchemeAsNoAccess(native_scheme);
+  WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs(
+      native_scheme);
 }
 
 ChromeRenderProcessObserver::~ChromeRenderProcessObserver() {}
@@ -320,26 +333,6 @@ bool ChromeRenderProcessObserver::OnControlMessageReceived(
   return handled;
 }
 
-void ChromeRenderProcessObserver::WebKitInitialized() {
-  webkit_initialized_ = true;
-  // chrome-native: is a scheme used for placeholder navigations that allow
-  // UIs to be drawn with platform native widgets instead of HTML.  These pages
-  // should not be accessible, and should also be treated as empty documents
-  // that can commit synchronously.  No code should be runnable in these pages,
-  // so it should not need to access anything nor should it allow javascript
-  // URLs since it should never be visible to the user.
-  WebString native_scheme(base::ASCIIToUTF16(chrome::kChromeNativeScheme));
-  WebSecurityPolicy::registerURLSchemeAsDisplayIsolated(native_scheme);
-  WebSecurityPolicy::registerURLSchemeAsEmptyDocument(native_scheme);
-  WebSecurityPolicy::registerURLSchemeAsNoAccess(native_scheme);
-  WebSecurityPolicy::registerURLSchemeAsNotAllowingJavascriptURLs(
-      native_scheme);
-}
-
-void ChromeRenderProcessObserver::OnRenderProcessShutdown() {
-  webkit_initialized_ = false;
-}
-
 void ChromeRenderProcessObserver::OnSetIsIncognitoProcess(
     bool is_incognito_process) {
   is_incognito_process_ = is_incognito_process;
diff --git a/chrome/renderer/chrome_render_process_observer.h b/chrome/renderer/chrome_render_process_observer.h
index b4d1b66..51b4daf 100644
--- a/chrome/renderer/chrome_render_process_observer.h
+++ b/chrome/renderer/chrome_render_process_observer.h
@@ -40,8 +40,6 @@ class ChromeRenderProcessObserver : public content::RenderProcessObserver,
 
   static bool is_incognito_process() { return is_incognito_process_; }
 
-  bool webkit_initialized() const { return webkit_initialized_; }
-
   // Returns a pointer to the content setting rules owned by
   // |ChromeRenderProcessObserver|.
   const RendererContentSettingRules* content_setting_rules() const;
@@ -53,8 +51,6 @@ class ChromeRenderProcessObserver : public content::RenderProcessObserver,
 
   // content::RenderProcessObserver:
   bool OnControlMessageReceived(const IPC::Message& message) override;
-  void WebKitInitialized() override;
-  void OnRenderProcessShutdown() override;
 
   // base::FieldTrialList::Observer:
   void OnFieldTrialGroupFinalized(const std::string& trial_name,
@@ -73,8 +69,6 @@ class ChromeRenderProcessObserver : public content::RenderProcessObserver,
   scoped_ptr<content::ResourceDispatcherDelegate> resource_delegate_;
   RendererContentSettingRules content_setting_rules_;
 
-  bool webkit_initialized_;
-
   base::WeakPtrFactory<ChromeRenderProcessObserver> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeRenderProcessObserver);
diff --git a/components/web_cache/renderer/web_cache_render_process_observer.cc b/components/web_cache/renderer/web_cache_render_process_observer.cc
index 4e7ee6a..acf11c1 100644
--- a/components/web_cache/renderer/web_cache_render_process_observer.cc
+++ b/components/web_cache/renderer/web_cache_render_process_observer.cc
@@ -14,16 +14,8 @@
 
 namespace web_cache {
 
-namespace {
-const size_t kUnitializedCacheCapacity = UINT_MAX;
-}
-
 WebCacheRenderProcessObserver::WebCacheRenderProcessObserver()
-  : clear_cache_pending_(false),
-    webkit_initialized_(false),
-    pending_cache_min_dead_capacity_(0),
-    pending_cache_max_dead_capacity_(0),
-    pending_cache_capacity_(kUnitializedCacheCapacity) {
+  : clear_cache_pending_(false) {
   content::ServiceRegistry* service_registry =
       content::RenderThread::Get()->GetServiceRegistry();
   service_registry->AddService(base::Bind(
@@ -39,25 +31,12 @@ void WebCacheRenderProcessObserver::BindRequest(
 }
 
 void WebCacheRenderProcessObserver::ExecutePendingClearCache() {
-  if (clear_cache_pending_ && webkit_initialized_) {
+  if (clear_cache_pending_) {
     clear_cache_pending_ = false;
     blink::WebCache::clear();
   }
 }
 
-void WebCacheRenderProcessObserver::WebKitInitialized() {
-  webkit_initialized_ = true;
-  if (pending_cache_capacity_ != kUnitializedCacheCapacity) {
-    blink::WebCache::setCapacities(pending_cache_min_dead_capacity_,
-                                   pending_cache_max_dead_capacity_,
-                                   pending_cache_capacity_);
-  }
-}
-
-void WebCacheRenderProcessObserver::OnRenderProcessShutdown() {
-  webkit_initialized_ = false;
-}
-
 void WebCacheRenderProcessObserver::SetCacheCapacities(
     uint64_t min_dead_capacity,
     uint64_t max_dead_capacity,
@@ -66,19 +45,12 @@ void WebCacheRenderProcessObserver::SetCacheCapacities(
   size_t max_dead_capacity2 = base::checked_cast<size_t>(max_dead_capacity);
   size_t capacity = base::checked_cast<size_t>(capacity64);
 
-  if (!webkit_initialized_) {
-    pending_cache_min_dead_capacity_ = min_dead_capacity2;
-    pending_cache_max_dead_capacity_ = max_dead_capacity2;
-    pending_cache_capacity_ = capacity;
-    return;
-  }
-
   blink::WebCache::setCapacities(min_dead_capacity2, max_dead_capacity2,
                                  capacity);
 }
 
 void WebCacheRenderProcessObserver::ClearCache(bool on_navigation) {
-  if (on_navigation || !webkit_initialized_)
+  if (on_navigation)
     clear_cache_pending_ = true;
   else
     blink::WebCache::clear();
diff --git a/components/web_cache/renderer/web_cache_render_process_observer.h b/components/web_cache/renderer/web_cache_render_process_observer.h
index d0b7d8c..aee3eac 100644
--- a/components/web_cache/renderer/web_cache_render_process_observer.h
+++ b/components/web_cache/renderer/web_cache_render_process_observer.h
@@ -11,14 +11,12 @@
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "components/web_cache/public/interfaces/web_cache.mojom.h"
-#include "content/public/renderer/render_process_observer.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 
 namespace web_cache {
 
 // This class implements the Mojo interface mojom::WebCache.
-class WebCacheRenderProcessObserver : public mojom::WebCache,
-                                      public content::RenderProcessObserver {
+class WebCacheRenderProcessObserver : public mojom::WebCache {
  public:
   WebCacheRenderProcessObserver();
   ~WebCacheRenderProcessObserver() override;
@@ -30,10 +28,6 @@ class WebCacheRenderProcessObserver : public mojom::WebCache,
   void ExecutePendingClearCache();
 
  private:
-  // RenderProcessObserver implementation.
-  void WebKitInitialized() override;
-  void OnRenderProcessShutdown() override;
-
   // mojom::WebCache methods:
   void SetCacheCapacities(uint64_t min_dead_capacity,
                           uint64_t max_dead_capacity,
@@ -44,10 +38,6 @@ class WebCacheRenderProcessObserver : public mojom::WebCache,
 
   // If true, the web cache shall be cleared before the next navigation event.
   bool clear_cache_pending_;
-  bool webkit_initialized_;
-  size_t pending_cache_min_dead_capacity_;
-  size_t pending_cache_max_dead_capacity_;
-  size_t pending_cache_capacity_;
 
   mojo::BindingSet<mojom::WebCache> bindings_;
 
diff --git a/content/public/renderer/render_process_observer.h b/content/public/renderer/render_process_observer.h
index f53ba65..30f855d 100644
--- a/content/public/renderer/render_process_observer.h
+++ b/content/public/renderer/render_process_observer.h
@@ -27,9 +27,6 @@ class CONTENT_EXPORT RenderProcessObserver {
   // Notification that the render process is shutting down.
   virtual void OnRenderProcessShutdown() {}
 
-  // Called right after the WebKit API is initialized.
-  virtual void WebKitInitialized() {}
-
   // Called when the renderer cache of the plugin list has changed.
   virtual void PluginListChanged() {}
 
diff --git a/content/public/renderer/render_thread.h b/content/public/renderer/render_thread.h
index db554c1..7f88da9 100644
--- a/content/public/renderer/render_thread.h
+++ b/content/public/renderer/render_thread.h
@@ -75,10 +75,6 @@ class CONTENT_EXPORT RenderThread : virtual public ChildThread {
   virtual void SetResourceDispatcherDelegate(
       ResourceDispatcherDelegate* delegate) = 0;
 
-  // We initialize WebKit as late as possible. Call this to force
-  // initialization.
-  virtual void EnsureWebKitInitialized() = 0;
-
   // Asks the host to create a block of shared memory for the renderer.
   // The shared memory allocated by the host is returned back.
   virtual scoped_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer(
diff --git a/content/public/test/mock_render_thread.cc b/content/public/test/mock_render_thread.cc
index 55b2269..0160c43 100644
--- a/content/public/test/mock_render_thread.cc
+++ b/content/public/test/mock_render_thread.cc
@@ -123,9 +123,6 @@ void MockRenderThread::SetResourceDispatcherDelegate(
     ResourceDispatcherDelegate* delegate) {
 }
 
-void MockRenderThread::EnsureWebKitInitialized() {
-}
-
 void MockRenderThread::RecordAction(const base::UserMetricsAction& action) {
 }
 
diff --git a/content/public/test/mock_render_thread.h b/content/public/test/mock_render_thread.h
index 7b6c7d3..5301acf 100644
--- a/content/public/test/mock_render_thread.h
+++ b/content/public/test/mock_render_thread.h
@@ -63,7 +63,6 @@ class MockRenderThread : public RenderThread {
   void RemoveObserver(RenderProcessObserver* observer) override;
   void SetResourceDispatcherDelegate(
       ResourceDispatcherDelegate* delegate) override;
-  void EnsureWebKitInitialized() override;
   void RecordAction(const base::UserMetricsAction& action) override;
   void RecordComputedAction(const std::string& action) override;
   scoped_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer(
diff --git a/content/renderer/dom_storage/dom_storage_dispatcher.cc b/content/renderer/dom_storage/dom_storage_dispatcher.cc
index c80df04..05ac68d 100644
--- a/content/renderer/dom_storage/dom_storage_dispatcher.cc
+++ b/content/renderer/dom_storage/dom_storage_dispatcher.cc
@@ -299,8 +299,6 @@ bool DomStorageDispatcher::OnMessageReceived(const IPC::Message& msg) {
 
 void DomStorageDispatcher::OnStorageEvent(
     const DOMStorageMsg_Event_Params& params) {
-  RenderThreadImpl::current()->EnsureWebKitInitialized();
-
   WebStorageAreaImpl* originating_area = NULL;
   if (params.connection_id) {
     originating_area = WebStorageAreaImpl::FromConnectionId(
diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index c8a00e6..aa8f002 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc
@@ -591,7 +591,9 @@ RenderThreadImpl* RenderThreadImpl::Create(
     const InProcessChildThreadParams& params) {
   scoped_ptr<scheduler::RendererScheduler> renderer_scheduler =
       scheduler::RendererScheduler::Create();
-  return new RenderThreadImpl(params, std::move(renderer_scheduler));
+  scoped_refptr<base::SingleThreadTaskRunner> test_task_counter;
+  return new RenderThreadImpl(
+      params, std::move(renderer_scheduler), test_task_counter);
 }
 
 // static
@@ -608,14 +610,15 @@ RenderThreadImpl* RenderThreadImpl::current() {
 
 RenderThreadImpl::RenderThreadImpl(
     const InProcessChildThreadParams& params,
-    scoped_ptr<scheduler::RendererScheduler> scheduler)
+    scoped_ptr<scheduler::RendererScheduler> scheduler,
+    scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue)
     : ChildThreadImpl(Options::Builder()
                           .InBrowserProcess(params)
                           .UseMojoChannel(ShouldUseMojoChannel())
                           .Build()),
       renderer_scheduler_(std::move(scheduler)),
       raster_worker_pool_(new RasterWorkerPool()) {
-  Init();
+  Init(resource_task_queue);
 }
 
 // When we run plugins in process, we actually run them on the render thread,
@@ -629,10 +632,12 @@ RenderThreadImpl::RenderThreadImpl(
       renderer_scheduler_(std::move(scheduler)),
       main_message_loop_(std::move(main_message_loop)),
       raster_worker_pool_(new RasterWorkerPool()) {
-  Init();
+  scoped_refptr<base::SingleThreadTaskRunner> test_task_counter;
+  Init(test_task_counter);
 }
 
-void RenderThreadImpl::Init() {
+void RenderThreadImpl::Init(
+    scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue) {
   TRACE_EVENT0("startup", "RenderThreadImpl::Init");
 
   base::trace_event::TraceLog::GetInstance()->SetThreadSortIndex(
@@ -649,6 +654,8 @@ void RenderThreadImpl::Init() {
   // Register this object as the main thread.
   ChildProcess::current()->set_main_thread(this);
 
+  InitializeWebKit(resource_task_queue);
+
   // In single process the single process is all there is.
   notify_webkit_of_modal_loop_ = true;
   webkit_shared_timer_suspended_ = false;
@@ -1155,21 +1162,6 @@ void RenderThreadImpl::SetResourceDispatcherDelegate(
   resource_dispatcher()->set_delegate(delegate);
 }
 
-void RenderThreadImpl::SetResourceDispatchTaskQueue(
-    const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue) {
-  // Add a filter that forces resource messages to be dispatched via a
-  // particular task runner.
-  scoped_refptr<ResourceSchedulingFilter> filter(
-      new ResourceSchedulingFilter(resource_task_queue, resource_dispatcher()));
-  channel()->AddFilter(filter.get());
-  resource_dispatcher()->SetResourceSchedulingFilter(filter);
-
-  // The ChildResourceMessageFilter and the ResourceDispatcher need to use the
-  // same queue to ensure tasks are executed in the expected order.
-  child_resource_message_filter()->SetMainThreadTaskRunner(resource_task_queue);
-  resource_dispatcher()->SetMainThreadTaskRunner(resource_task_queue);
-}
-
 void RenderThreadImpl::InitializeCompositorThread() {
 #if defined(OS_ANDROID)
   SynchronousCompositorFactory* sync_compositor_factory =
@@ -1233,9 +1225,9 @@ void RenderThreadImpl::InitializeCompositorThread() {
       synchronous_input_handler_proxy_client, renderer_scheduler_.get()));
 }
 
-void RenderThreadImpl::EnsureWebKitInitialized() {
-  if (blink_platform_impl_)
-    return;
+void RenderThreadImpl::InitializeWebKit(
+    scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue) {
+  DCHECK(!blink_platform_impl_);
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
@@ -1262,7 +1254,26 @@ void RenderThreadImpl::EnsureWebKitInitialized() {
       base::Bind(base::IgnoreResult(&RenderThreadImpl::OnMessageReceived),
                  base::Unretained(this)));
 
-  SetResourceDispatchTaskQueue(renderer_scheduler_->LoadingTaskRunner());
+  scoped_refptr<base::SingleThreadTaskRunner> resource_task_queue2;
+  if (resource_task_queue) {
+    resource_task_queue2 = resource_task_queue;
+  } else {
+    resource_task_queue2 = renderer_scheduler_->LoadingTaskRunner();
+  }
+  // Add a filter that forces resource messages to be dispatched via a
+  // particular task runner.
+  scoped_refptr<ResourceSchedulingFilter> filter(
+      new ResourceSchedulingFilter(
+          resource_task_queue2, resource_dispatcher()));
+  channel()->AddFilter(filter.get());
+  resource_dispatcher()->SetResourceSchedulingFilter(filter);
+
+  // The ChildResourceMessageFilter and the ResourceDispatcher need to use the
+  // same queue to ensure tasks are executed in the expected order.
+  child_resource_message_filter()->SetMainThreadTaskRunner(
+      resource_task_queue2);
+  resource_dispatcher()->SetMainThreadTaskRunner(resource_task_queue2);
+
   if (!command_line.HasSwitch(switches::kDisableThreadedCompositing) &&
       !command_line.HasSwitch(switches::kUseRemoteCompositing))
     InitializeCompositorThread();
@@ -1294,8 +1305,6 @@ void RenderThreadImpl::EnsureWebKitInitialized() {
 
   RenderMediaClient::Initialize();
 
-  FOR_EACH_OBSERVER(RenderProcessObserver, observers_, WebKitInitialized());
-
   devtools_agent_message_filter_ = new DevToolsAgentFilter();
   AddFilter(devtools_agent_message_filter_.get());
 
@@ -1378,7 +1387,6 @@ cc::SharedBitmapManager* RenderThreadImpl::GetSharedBitmapManager() {
 }
 
 void RenderThreadImpl::RegisterExtension(v8::Extension* extension) {
-  EnsureWebKitInitialized();
   WebScriptController::registerExtension(extension);
 }
 
@@ -1837,7 +1845,6 @@ void RenderThreadImpl::OnSetZoomLevelForCurrentURL(const std::string& scheme,
 }
 
 void RenderThreadImpl::OnCreateNewView(const ViewMsg_New_Params& params) {
-  EnsureWebKitInitialized();
   CompositorDependencies* compositor_deps = this;
   // When bringing in render_view, also bring in webkit's glue and jsbindings.
   RenderViewImpl::Create(compositor_deps, params, false);
@@ -1923,7 +1930,6 @@ GpuChannelHost* RenderThreadImpl::GetGpuChannel() {
 
 #if defined(ENABLE_PLUGINS)
 void RenderThreadImpl::OnPurgePluginListCache(bool reload_pages) {
-  EnsureWebKitInitialized();
   // The call below will cause a GetPlugins call with refresh=true, but at this
   // point we already know that the browser has refreshed its list, so disable
   // refresh temporarily to prevent each renderer process causing the list to be
@@ -1939,7 +1945,6 @@ void RenderThreadImpl::OnPurgePluginListCache(bool reload_pages) {
 void RenderThreadImpl::OnNetworkConnectionChanged(
     net::NetworkChangeNotifier::ConnectionType type,
     double max_bandwidth_mbps) {
-  EnsureWebKitInitialized();
   bool online = type != net::NetworkChangeNotifier::CONNECTION_NONE;
   WebNetworkStateNotifier::setOnLine(online);
   FOR_EACH_OBSERVER(
@@ -1962,7 +1967,6 @@ void RenderThreadImpl::OnUpdateTimezone(const std::string& zone_id) {
 
 #if defined(OS_ANDROID)
 void RenderThreadImpl::OnSetWebKitSharedTimersSuspended(bool suspend) {
-  EnsureWebKitInitialized();
   if (suspend) {
     renderer_scheduler_->SuspendTimerQueue();
   } else {
@@ -1975,7 +1979,6 @@ void RenderThreadImpl::OnSetWebKitSharedTimersSuspended(bool suspend) {
 #if defined(OS_MACOSX)
 void RenderThreadImpl::OnUpdateScrollbarTheme(
     const ViewMsg_UpdateScrollbarTheme_Params& params) {
-  EnsureWebKitInitialized();
   static_cast<WebScrollbarBehaviorImpl*>(
       blink_platform_impl_->scrollbarBehavior())
       ->set_jump_on_track_click(params.jump_on_track_click);
diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index cf98faf..f532662 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h
@@ -180,7 +180,6 @@ class CONTENT_EXPORT RenderThreadImpl
   void RemoveObserver(RenderProcessObserver* observer) override;
   void SetResourceDispatcherDelegate(
       ResourceDispatcherDelegate* delegate) override;
-  void EnsureWebKitInitialized() override;
   scoped_ptr<base::SharedMemory> HostAllocateSharedMemoryBuffer(
       size_t buffer_size) override;
   cc::SharedBitmapManager* GetSharedBitmapManager() override;
@@ -458,12 +457,12 @@ class CONTENT_EXPORT RenderThreadImpl
   StoragePartitionService* GetStoragePartitionService();
 
  protected:
-  RenderThreadImpl(const InProcessChildThreadParams& params,
-                   scoped_ptr<scheduler::RendererScheduler> scheduler);
+  RenderThreadImpl(
+      const InProcessChildThreadParams& params,
+      scoped_ptr<scheduler::RendererScheduler> scheduler,
+      scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue);
   RenderThreadImpl(scoped_ptr<base::MessageLoop> main_message_loop,
                    scoped_ptr<scheduler::RendererScheduler> scheduler);
-  virtual void SetResourceDispatchTaskQueue(
-    const scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue);
 
  private:
   // ChildThread
@@ -477,10 +476,13 @@ class CONTENT_EXPORT RenderThreadImpl
   scoped_refptr<base::SingleThreadTaskRunner> GetIOThreadTaskRunner() override;
   scoped_ptr<base::SharedMemory> AllocateSharedMemory(size_t size) override;
 
-  void Init();
+  void Init(scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue);
 
   void InitializeCompositorThread();
 
+  void InitializeWebKit(
+      scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue);
+
   void OnCreateNewFrame(FrameMsg_NewFrame_Params params);
   void OnCreateNewFrameProxy(int routing_id,
                              int render_view_routing_id,
diff --git a/content/renderer/render_thread_impl_browsertest.cc b/content/renderer/render_thread_impl_browsertest.cc
index 67bc93a..f1b21a4 100644
--- a/content/renderer/render_thread_impl_browsertest.cc
+++ b/content/renderer/render_thread_impl_browsertest.cc
@@ -101,24 +101,18 @@ class TestTaskCounter : public base::SingleThreadTaskRunner {
 
 class RenderThreadImplForTest : public RenderThreadImpl {
  public:
-  RenderThreadImplForTest(const InProcessChildThreadParams& params,
-                          scoped_ptr<scheduler::RendererScheduler> scheduler,
-                          scoped_refptr<TestTaskCounter> test_task_counter)
-      : RenderThreadImpl(params, std::move(scheduler)),
-        test_task_counter_(test_task_counter) {}
+  RenderThreadImplForTest(
+      const InProcessChildThreadParams& params,
+      scoped_ptr<scheduler::RendererScheduler> scheduler,
+      scoped_refptr<base::SingleThreadTaskRunner>& test_task_counter)
+      : RenderThreadImpl(params, std::move(scheduler), test_task_counter) {
+  }
 
   ~RenderThreadImplForTest() override {}
 
-  void SetResourceDispatchTaskQueue(
-      const scoped_refptr<base::SingleThreadTaskRunner>&) override {
-    // Use our TestTaskCounter instead.
-    RenderThreadImpl::SetResourceDispatchTaskQueue(test_task_counter_);
-  }
-
   using ChildThreadImpl::OnMessageReceived;
 
  private:
-  scoped_refptr<TestTaskCounter> test_task_counter_;
 };
 
 #if defined(COMPILER_MSVC)
@@ -185,15 +179,15 @@ class RenderThreadImplBrowserTest : public testing::Test {
     scoped_ptr<scheduler::RendererScheduler> renderer_scheduler =
         scheduler::RendererScheduler::Create();
     InitializeMojo();
+    scoped_refptr<base::SingleThreadTaskRunner> test_task_counter(
+        test_task_counter_.get());
     thread_ = new RenderThreadImplForTest(
         InProcessChildThreadParams(test_helper_->GetChannelId(),
                                    test_helper_->GetIOTaskRunner(),
                                    test_helper_->GetMessagePipeHandle()),
-        std::move(renderer_scheduler), test_task_counter_);
+        std::move(renderer_scheduler), test_task_counter);
     cmd->InitFromArgv(old_argv);
 
-    thread_->EnsureWebKitInitialized();
-
     test_msg_filter_ = make_scoped_refptr(
         new QuitOnTestMsgFilter(test_helper_->GetMessageLoop()));
     thread_->AddFilter(test_msg_filter_.get());
diff --git a/content/renderer/service_worker/embedded_worker_dispatcher.cc b/content/renderer/service_worker/embedded_worker_dispatcher.cc
index 7ed1a41..f4334ed 100644
--- a/content/renderer/service_worker/embedded_worker_dispatcher.cc
+++ b/content/renderer/service_worker/embedded_worker_dispatcher.cc
@@ -78,7 +78,6 @@ void EmbeddedWorkerDispatcher::OnStartWorker(
     const EmbeddedWorkerMsg_StartWorker_Params& params) {
   DCHECK(!workers_.Lookup(params.embedded_worker_id));
   TRACE_EVENT0("ServiceWorker", "EmbeddedWorkerDispatcher::OnStartWorker");
-  RenderThread::Get()->EnsureWebKitInitialized();
   scoped_ptr<WorkerWrapper> wrapper(
       new WorkerWrapper(blink::WebEmbeddedWorker::create(
                             new ServiceWorkerContextClient(
diff --git a/content/shell/renderer/layout_test/layout_test_render_process_observer.cc b/content/shell/renderer/layout_test/layout_test_render_process_observer.cc
index d62ae58..0ca0149 100644
--- a/content/shell/renderer/layout_test/layout_test_render_process_observer.cc
+++ b/content/shell/renderer/layout_test/layout_test_render_process_observer.cc
@@ -43,26 +43,7 @@ LayoutTestRenderProcessObserver::LayoutTestRenderProcessObserver()
   g_instance = this;
   RenderThread::Get()->AddObserver(this);
   EnableRendererLayoutTestMode();
-}
-
-LayoutTestRenderProcessObserver::~LayoutTestRenderProcessObserver() {
-  CHECK(g_instance == this);
-  g_instance = NULL;
-}
-
-void LayoutTestRenderProcessObserver::SetTestDelegate(
-    test_runner::WebTestDelegate* delegate) {
-  test_interfaces_->SetDelegate(delegate);
-  test_delegate_ = delegate;
-}
-
-void LayoutTestRenderProcessObserver::SetMainWindow(RenderView* view) {
-  BlinkTestRunner* test_runner = BlinkTestRunner::Get(view);
-  test_interfaces_->SetWebView(view->GetWebView(), test_runner->proxy());
-  main_test_runner_ = test_runner;
-}
 
-void LayoutTestRenderProcessObserver::WebKitInitialized() {
   // We always expose GC to layout tests.
   std::string flags("--expose-gc");
   v8::V8::SetFlagsFromString(flags.c_str(), static_cast<int>(flags.size()));
@@ -85,6 +66,23 @@ void LayoutTestRenderProcessObserver::WebKitInitialized() {
   }
 }
 
+LayoutTestRenderProcessObserver::~LayoutTestRenderProcessObserver() {
+  CHECK(g_instance == this);
+  g_instance = NULL;
+}
+
+void LayoutTestRenderProcessObserver::SetTestDelegate(
+    test_runner::WebTestDelegate* delegate) {
+  test_interfaces_->SetDelegate(delegate);
+  test_delegate_ = delegate;
+}
+
+void LayoutTestRenderProcessObserver::SetMainWindow(RenderView* view) {
+  BlinkTestRunner* test_runner = BlinkTestRunner::Get(view);
+  test_interfaces_->SetWebView(view->GetWebView(), test_runner->proxy());
+  main_test_runner_ = test_runner;
+}
+
 void LayoutTestRenderProcessObserver::OnRenderProcessShutdown() {
   test_interfaces_.reset();
 }
diff --git a/content/shell/renderer/layout_test/layout_test_render_process_observer.h b/content/shell/renderer/layout_test/layout_test_render_process_observer.h
index 062ea5e..2787409 100644
--- a/content/shell/renderer/layout_test/layout_test_render_process_observer.h
+++ b/content/shell/renderer/layout_test/layout_test_render_process_observer.h
@@ -37,7 +37,6 @@ class LayoutTestRenderProcessObserver : public RenderProcessObserver {
   void SetMainWindow(RenderView* view);
 
   // RenderProcessObserver implementation.
-  void WebKitInitialized() override;
   void OnRenderProcessShutdown() override;
   bool OnControlMessageReceived(const IPC::Message& message) override;
 
diff --git a/content/shell/renderer/shell_content_renderer_client.cc b/content/shell/renderer/shell_content_renderer_client.cc
index c799904..c1d501c 100644
--- a/content/shell/renderer/shell_content_renderer_client.cc
+++ b/content/shell/renderer/shell_content_renderer_client.cc
@@ -6,7 +6,6 @@
 
 #include "base/command_line.h"
 #include "components/web_cache/renderer/web_cache_render_process_observer.h"
-#include "content/public/renderer/render_thread.h"
 #include "content/shell/renderer/shell_render_view_observer.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "v8/include/v8.h"
@@ -23,9 +22,7 @@ ShellContentRendererClient::~ShellContentRendererClient() {
 }
 
 void ShellContentRendererClient::RenderThreadStarted() {
-  RenderThread* thread = RenderThread::Get();
   web_cache_observer_.reset(new web_cache::WebCacheRenderProcessObserver());
-  thread->AddObserver(web_cache_observer_.get());
 }
 
 void ShellContentRendererClient::RenderViewCreated(RenderView* render_view) {
diff --git a/content/test/layouttest_support.cc b/content/test/layouttest_support.cc
index 2843fb8..5ec52f6 100644
--- a/content/test/layouttest_support.cc
+++ b/content/test/layouttest_support.cc
@@ -98,7 +98,6 @@ RenderFrameImpl* CreateWebFrameTestProxy(
 // DirectWrite only has access to %WINDIR%\Fonts by default. For developer
 // side-loading, support kRegisterFontFiles to allow access to additional fonts.
 void RegisterSideloadedTypefaces(SkFontMgr* fontmgr) {
-  RenderThreadImpl::current()->EnsureWebKitInitialized();
   std::vector<std::string> files = switches::GetSideloadFontFiles();
   for (std::vector<std::string>::const_iterator i(files.begin());
        i != files.end();
diff --git a/extensions/renderer/dispatcher.cc b/extensions/renderer/dispatcher.cc
index 4bca09c..77a4e7b 100644
--- a/extensions/renderer/dispatcher.cc
+++ b/extensions/renderer/dispatcher.cc
@@ -211,7 +211,6 @@ Dispatcher::Dispatcher(DispatcherDelegate* delegate)
       content_watcher_(new ContentWatcher()),
       source_map_(&ResourceBundle::GetSharedInstance()),
       v8_schema_registry_(new V8SchemaRegistry),
-      is_webkit_initialized_(false),
       user_script_set_manager_observer_(this),
       webrequest_used_(false) {
   const base::CommandLine& command_line =
@@ -233,6 +232,62 @@ Dispatcher::Dispatcher(DispatcherDelegate* delegate)
   request_sender_.reset(new RequestSender(this));
   PopulateSourceMap();
   WakeEventPage::Get()->Init(RenderThread::Get());
+
+  RenderThread::Get()->RegisterExtension(SafeBuiltins::CreateV8Extension());
+
+  // WebSecurityPolicy whitelists. They should be registered for both
+  // chrome-extension: and chrome-extension-resource.
+  using RegisterFunction = void (*)(const WebString&);
+  RegisterFunction register_functions[] = {
+      // Treat as secure because communication with them is entirely in the
+      // browser, so there is no danger of manipulation or eavesdropping on
+      // communication with them by third parties.
+      WebSecurityPolicy::registerURLSchemeAsSecure,
+      // As far as Blink is concerned, they should be allowed to receive CORS
+      // requests. At the Extensions layer, requests will actually be blocked
+      // unless overridden by the web_accessible_resources manifest key.
+      // TODO(kalman): See what happens with a service worker.
+      WebSecurityPolicy::registerURLSchemeAsCORSEnabled,
+      // Resources should bypass Content Security Policy checks when included in
+      // protected resources. TODO(kalman): What are "protected resources"?
+      WebSecurityPolicy::registerURLSchemeAsBypassingContentSecurityPolicy,
+      // Extension resources are HTTP-like and safe to expose to the fetch API.
+      // The rules for the fetch API are consistent with XHR.
+      WebSecurityPolicy::registerURLSchemeAsSupportingFetchAPI,
+      // Extension resources, when loaded as the top-level document, should
+      // bypass Blink's strict first-party origin checks.
+      WebSecurityPolicy::registerURLSchemeAsFirstPartyWhenTopLevel,
+  };
+
+  WebString extension_scheme(base::ASCIIToUTF16(kExtensionScheme));
+  WebString extension_resource_scheme(base::ASCIIToUTF16(
+      kExtensionResourceScheme));
+  for (RegisterFunction func : register_functions) {
+    func(extension_scheme);
+    func(extension_resource_scheme);
+  }
+
+  // For extensions, we want to ensure we call the IdleHandler every so often,
+  // even if the extension keeps up activity.
+  if (set_idle_notifications_) {
+    forced_idle_timer_.reset(new base::RepeatingTimer);
+    forced_idle_timer_->Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs),
+        RenderThread::Get(),
+        &RenderThread::IdleHandler);
+  }
+
+  // Initialize host permissions for any extensions that were activated before
+  // WebKit was initialized.
+  for (const std::string& extension_id : active_extension_ids_) {
+    const Extension* extension =
+        RendererExtensionRegistry::Get()->GetByID(extension_id);
+    CHECK(extension);
+    InitOriginPermissions(extension);
+  }
+
+  EnableCustomElementWhiteList();
 }
 
 Dispatcher::~Dispatcher() {
@@ -889,67 +944,6 @@ bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) {
 
   return handled;
 }
-
-void Dispatcher::WebKitInitialized() {
-  RenderThread::Get()->RegisterExtension(SafeBuiltins::CreateV8Extension());
-
-  // WebSecurityPolicy whitelists. They should be registered for both
-  // chrome-extension: and chrome-extension-resource.
-  using RegisterFunction = void (*)(const WebString&);
-  RegisterFunction register_functions[] = {
-      // Treat as secure because communication with them is entirely in the
-      // browser, so there is no danger of manipulation or eavesdropping on
-      // communication with them by third parties.
-      WebSecurityPolicy::registerURLSchemeAsSecure,
-      // As far as Blink is concerned, they should be allowed to receive CORS
-      // requests. At the Extensions layer, requests will actually be blocked
-      // unless overridden by the web_accessible_resources manifest key.
-      // TODO(kalman): See what happens with a service worker.
-      WebSecurityPolicy::registerURLSchemeAsCORSEnabled,
-      // Resources should bypass Content Security Policy checks when included in
-      // protected resources. TODO(kalman): What are "protected resources"?
-      WebSecurityPolicy::registerURLSchemeAsBypassingContentSecurityPolicy,
-      // Extension resources are HTTP-like and safe to expose to the fetch API.
-      // The rules for the fetch API are consistent with XHR.
-      WebSecurityPolicy::registerURLSchemeAsSupportingFetchAPI,
-      // Extension resources, when loaded as the top-level document, should
-      // bypass Blink's strict first-party origin checks.
-      WebSecurityPolicy::registerURLSchemeAsFirstPartyWhenTopLevel,
-  };
-
-  WebString extension_scheme(base::ASCIIToUTF16(kExtensionScheme));
-  WebString extension_resource_scheme(base::ASCIIToUTF16(
-      kExtensionResourceScheme));
-  for (RegisterFunction func : register_functions) {
-    func(extension_scheme);
-    func(extension_resource_scheme);
-  }
-
-  // For extensions, we want to ensure we call the IdleHandler every so often,
-  // even if the extension keeps up activity.
-  if (set_idle_notifications_) {
-    forced_idle_timer_.reset(new base::RepeatingTimer);
-    forced_idle_timer_->Start(
-        FROM_HERE,
-        base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs),
-        RenderThread::Get(),
-        &RenderThread::IdleHandler);
-  }
-
-  // Initialize host permissions for any extensions that were activated before
-  // WebKit was initialized.
-  for (const std::string& extension_id : active_extension_ids_) {
-    const Extension* extension =
-        RendererExtensionRegistry::Get()->GetByID(extension_id);
-    CHECK(extension);
-    InitOriginPermissions(extension);
-  }
-
-  EnableCustomElementWhiteList();
-
-  is_webkit_initialized_ = true;
-}
-
 void Dispatcher::IdleNotification() {
   if (set_idle_notifications_ && forced_idle_timer_) {
     // Dampen the forced delay as well if the extension stays idle for long
@@ -1003,12 +997,10 @@ void Dispatcher::OnActivateExtension(const std::string& extension_id) {
   // handler ticking.
   RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs);
 
-  if (is_webkit_initialized_) {
-    DOMActivityLogger::AttachToWorld(
-        DOMActivityLogger::kMainWorldId, extension_id);
+  DOMActivityLogger::AttachToWorld(
+      DOMActivityLogger::kMainWorldId, extension_id);
 
-    InitOriginPermissions(extension);
-  }
+  InitOriginPermissions(extension);
 
   UpdateActiveExtensions();
 }
@@ -1189,12 +1181,10 @@ void Dispatcher::OnUpdatePermissions(
   scoped_ptr<const PermissionSet> withheld =
       params.withheld_permissions.ToPermissionSet();
 
-  if (is_webkit_initialized_) {
-    UpdateOriginPermissions(
-        extension->url(),
-        extension->permissions_data()->GetEffectiveHostPermissions(),
-        active->effective_hosts());
-  }
+  UpdateOriginPermissions(
+      extension->url(),
+      extension->permissions_data()->GetEffectiveHostPermissions(),
+      active->effective_hosts());
 
   extension->permissions_data()->SetPermissions(std::move(active),
                                                 std::move(withheld));
@@ -1219,7 +1209,7 @@ void Dispatcher::OnUpdateTabSpecificPermissions(const GURL& visible_url,
                                 extensions::ManifestPermissionSet(), new_hosts,
                                 extensions::URLPatternSet()));
 
-  if (is_webkit_initialized_ && update_origin_whitelist) {
+  if (update_origin_whitelist) {
     UpdateOriginPermissions(
         extension->url(),
         old_effective,
@@ -1237,7 +1227,7 @@ void Dispatcher::OnClearTabSpecificPermissions(
       URLPatternSet old_effective =
           extension->permissions_data()->GetEffectiveHostPermissions();
       extension->permissions_data()->ClearTabSpecificPermissions(tab_id);
-      if (is_webkit_initialized_ && update_origin_whitelist) {
+      if (update_origin_whitelist) {
         UpdateOriginPermissions(
             extension->url(),
             old_effective,
diff --git a/extensions/renderer/dispatcher.h b/extensions/renderer/dispatcher.h
index eb4372c..37ab0a3 100644
--- a/extensions/renderer/dispatcher.h
+++ b/extensions/renderer/dispatcher.h
@@ -155,7 +155,6 @@ class Dispatcher : public content::RenderProcessObserver,
 
   // RenderProcessObserver implementation:
   bool OnControlMessageReceived(const IPC::Message& message) override;
-  void WebKitInitialized() override;
   void IdleNotification() override;
   void OnRenderProcessShutdown() override;
 
@@ -298,9 +297,6 @@ class Dispatcher : public content::RenderProcessObserver,
   // Mapping of port IDs to tabs. If there is no tab, the value would be -1.
   std::map<int, int> port_to_tab_id_map_;
 
-  // True once WebKit has been initialized (and it is therefore safe to poke).
-  bool is_webkit_initialized_;
-
   // It is important for this to come after the ScriptInjectionManager, so that
   // the observer is destroyed before the UserScriptSet.
   ScopedObserver<UserScriptSetManager, UserScriptSetManager::Observer>