Enable spare RenderProcessHost to be preinitialized.

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 447 matching lines @@
 
  private:
   std::unique_ptr<std::map<int, SessionStorageNamespaceMap>>
       session_storage_namespaces_awaiting_close_;
   DISALLOW_COPY_AND_ASSIGN(SessionStorageHolder);
 };
 
 const void* const kDefaultSubframeProcessHostHolderKey =
     &kDefaultSubframeProcessHostHolderKey;
 
+// This class manages spare renderers.
+class SpareRenderProcessHostManager {
+ public:
+  SpareRenderProcessHostManager() {}
+
+  void WarmupSpareRenderProcessHost(BrowserContext* browser_context) {
+    StoragePartitionImpl* current_partition =
+        static_cast<StoragePartitionImpl*>(
+            BrowserContext::GetStoragePartition(browser_context, nullptr));
+
+    if (spare_render_process_host_ &&
+        matching_browser_context_ == browser_context &&
+        matching_storage_partition_ == current_partition) {
+      return;  // Nothing to warm up.
+    }
+
+    CleanupSpareRenderProcessHost();
+
+    matching_browser_context_ = browser_context;
+    matching_storage_partition_ = current_partition;
+    spare_render_process_host_ = RenderProcessHostImpl::CreateRenderProcessHost(
+        browser_context, current_partition, false /* is_for_guests_only */);
+
+    spare_render_process_host_->Init();
+  }
+
+  RenderProcessHost* MaybeTakeSpareRenderProcessHost(
+      const BrowserContext* browser_context,
+      const StoragePartition* partition,
+      bool is_for_guests_only) {
+    if (!spare_render_process_host_ ||
+        browser_context != matching_browser_context_ ||
+        partition != matching_storage_partition_ || is_for_guests_only) {
+      // As a new RenderProcessHost will almost certainly be created, we cleanup
+      // the non-matching one so as not to waste resources.
+      CleanupSpareRenderProcessHost();
+      return nullptr;
+    }
+
+    if (!spare_render_process_host_->HasConnection()) {

[falken, 2017/06/15 06:46:49]

I'm curious why this is needed. (I'm not really a render process host expert.)
Does this signify the RPH crashed?

Could the RPH just not be ready yet? Do we also want to check something like
FastShutdownStarted()?

[mattcary, 2017/06/15 08:30:39]

I'm not sure it is needed.

The case I'm worried about is if the spare renderer process is killed the warmup
and this function. Any advice on the best way to handle that would be great, as
I'm not personally familiar with the best way to hook into the RPH lifecycle (in
particular, it seems that the RPHObserver isn't sufficient, although it may be
necessary).

 I'll look into FastShutdownStarted.

+      CleanupSpareRenderProcessHost();
+      return nullptr;
+    }
+
+    RenderProcessHost* rph = spare_render_process_host_;
+    spare_render_process_host_ = nullptr;
+    return rph;
+  }
+
+  void OnStorageParitionShutdown(StoragePartition* partition) {

[falken, 2017/06/15 06:46:49]

typo: Partition

[mattcary, 2017/06/15 08:30:39]

Done.

+    if (partition == matching_storage_partition_) {
+      CleanupSpareRenderProcessHost();
+    }
+  }
+
+ private:
+  void CleanupSpareRenderProcessHost() {
+    if (spare_render_process_host_) {
+      spare_render_process_host_->Cleanup();
+      spare_render_process_host_ = nullptr;
+    }
+  }
+
+  // This is a bare pointer, because RenderProcessHost manages the lifetime of
+  // all its instances; see g_all_hosts, above.
+  RenderProcessHost* spare_render_process_host_;
+
+  // Used only to check if a creation request matches the
+  // spare, and not accessed.
+  const BrowserContext* matching_browser_context_ = nullptr;
+  const StoragePartition* matching_storage_partition_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(SpareRenderProcessHostManager);
+};
+
+base::LazyInstance<SpareRenderProcessHostManager>::Leaky
+    g_spare_render_process_host_manager = LAZY_INSTANCE_INITIALIZER;
+
 class DefaultSubframeProcessHostHolder : public base::SupportsUserData::Data,
                                          public RenderProcessHostObserver {
  public:
   explicit DefaultSubframeProcessHostHolder(BrowserContext* browser_context)
       : browser_context_(browser_context) {}
   ~DefaultSubframeProcessHostHolder() override {}
 
   // Gets the correct render process to use for this SiteInstance.
   RenderProcessHost* GetProcessHost(SiteInstance* site_instance,
                                     bool is_for_guests_only) {
     StoragePartition* default_partition =
         BrowserContext::GetDefaultStoragePartition(browser_context_);
     StoragePartition* partition =
         BrowserContext::GetStoragePartition(browser_context_, site_instance);
 
     // Is this the default storage partition? If it isn't, then just give it its
     // own non-shared process.
     if (partition != default_partition || is_for_guests_only) {
-      RenderProcessHostImpl* host = new RenderProcessHostImpl(
+      RenderProcessHost* host = RenderProcessHostImpl::CreateRenderProcessHost(
           browser_context_, static_cast<StoragePartitionImpl*>(partition),
           is_for_guests_only);
       host->SetIsNeverSuitableForReuse();
       return host;
     }
 
     // If we already have a shared host for the default storage partition, use
     // it.
     if (host_)
       return host_;
 
-    host_ = new RenderProcessHostImpl(
+    host_ =
+        g_spare_render_process_host_manager.Get()
+            .MaybeTakeSpareRenderProcessHost(browser_context_, partition,
+                                             false /* is for guests only */);
+
+    host_ = RenderProcessHostImpl::CreateRenderProcessHost(
         browser_context_, static_cast<StoragePartitionImpl*>(partition),
         false /* for guests only */);
     host_->SetIsNeverSuitableForReuse();
     host_->AddObserver(this);
 
     return host_;
   }
 
   // Implementation of RenderProcessHostObserver.
   void RenderProcessHostDestroyed(RenderProcessHost* host) override {
     DCHECK_EQ(host_, host);
     host_->RemoveObserver(this);
     host_ = nullptr;
   }
 
  private:
   BrowserContext* browser_context_;
 
   // The default subframe render process used for the default storage partition
   // of this BrowserContext.
-  RenderProcessHostImpl* host_ = nullptr;
+  RenderProcessHost* host_ = nullptr;
 };
 
 void CreateMemoryCoordinatorHandle(
     int render_process_id,
     const service_manager::BindSourceInfo& source_info,
     mojom::MemoryCoordinatorHandleRequest request) {
   MemoryCoordinatorImpl::GetInstance()->CreateHandle(render_process_id,
                                                      std::move(request));
 }
 
@@ skipping 370 matching lines @@
     max_count = std::min(max_count, kMaxRendererProcessCount);
   }
   return max_count;
 }
 
 // static
 void RenderProcessHost::SetMaxRendererProcessCount(size_t count) {
   g_max_renderer_count_override = count;
 }
 
+// static
+RenderProcessHost* RenderProcessHostImpl::CreateRenderProcessHost(
+    BrowserContext* browser_context,
+    StoragePartitionImpl* storage_partition_impl,
+    bool is_for_guests_only) {
+  if (g_render_process_host_factory_) {
+    return g_render_process_host_factory_->CreateRenderProcessHost(
+        browser_context);
+  }
+
+  return new RenderProcessHostImpl(browser_context, storage_partition_impl,
+                                   is_for_guests_only);
+}
+
 RenderProcessHostImpl::RenderProcessHostImpl(
     BrowserContext* browser_context,
     StoragePartitionImpl* storage_partition_impl,
     bool is_for_guests_only)
     : fast_shutdown_started_(false),
       deleting_soon_(false),
 #ifndef NDEBUG
       is_self_deleted_(false),
 #endif
       pending_views_(0),
@@ skipping 1051 matching lines @@
   SiteProcessCountTracker* tracker = static_cast<SiteProcessCountTracker*>(
       browser_context->GetUserData(kPendingSiteProcessCountTrackerKey));
   if (!tracker) {
     tracker = new SiteProcessCountTracker();
     browser_context->SetUserData(kPendingSiteProcessCountTrackerKey,
                                  base::WrapUnique(tracker));
   }
   tracker->DecrementSiteProcessCount(site_url, render_process_host->GetID());
 }
 
+// static
+void RenderProcessHostImpl::OnStorageParitionShutdown(

[falken, 2017/06/15 06:46:49]

typo: Partition

[mattcary, 2017/06/15 08:30:39]

Done (and in all the other instances too).

+    StoragePartition* partition) {
+  g_spare_render_process_host_manager.Get().OnStorageParitionShutdown(
+      partition);
+}
+
 bool RenderProcessHostImpl::IsForGuestsOnly() const {
   return is_for_guests_only_;
 }
 
 StoragePartition* RenderProcessHostImpl::GetStoragePartition() const {
   return storage_partition_impl_;
 }
 
 static void AppendCompositorCommandLineFlags(base::CommandLine* command_line) {
   command_line->AppendSwitchASCII(
@@ skipping 920 matching lines @@
           host->GetID()) !=
       WebUIControllerFactoryRegistry::GetInstance()->UseWebUIBindingsForURL(
           browser_context, site_url)) {
     return false;
   }
 
   return GetContentClient()->browser()->IsSuitableHost(host, site_url);
 }
 
 // static
+void RenderProcessHost::WarmupSpareRenderProcessHost(
+    content::BrowserContext* browser_context) {
+  g_spare_render_process_host_manager.Get().WarmupSpareRenderProcessHost(
+      browser_context);
+}
+
+// static
 bool RenderProcessHost::run_renderer_in_process() {
   return g_run_renderer_in_process_;
 }
 
 // static
 void RenderProcessHost::SetRunRendererInProcess(bool value) {
   g_run_renderer_in_process_ = value;
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (value) {
@@ skipping 175 matching lines @@
     default:
       break;
   }
 
   // If not (or if none found), see if we should reuse an existing process.
   if (!render_process_host &&
       ShouldTryToUseExistingProcessHost(browser_context, site_url)) {
     render_process_host = GetExistingProcessHost(browser_context, site_url);
   }
 
+  // Try to use a spare process if one is found.
+  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
+      BrowserContext::GetStoragePartition(browser_context, site_instance));

[falken, 2017/06/15 06:46:49]

really naive question: I wonder if we have to somehow stop the render process
from being discovered and used by some other thing (so it would no longer be a
spare, unused render process). E,g, anyone could probably discover it via
AllHostsIterator()?

I guess everything that "claims" a render process comes through
GetProcessHostForSiteInstance().

[mattcary, 2017/06/15 08:30:39]

That's a good point. I just searched through the code, all uses of
AllHostsIterator appear to be for updating hosts when events come though. So
that seems to be okay (although I guess this might expose some bugs where the
renderer is expected to be fully initialized with a web contents and such).
Yes, that was what we understood.

+  if (!render_process_host) {
+    render_process_host =
+        g_spare_render_process_host_manager.Get()
+            .MaybeTakeSpareRenderProcessHost(browser_context, partition,
+                                             is_for_guests_only);
+  }
+
   // Otherwise (or if that fails), create a new one.
   if (!render_process_host) {
-    if (g_render_process_host_factory_) {
-      render_process_host =
-          g_render_process_host_factory_->CreateRenderProcessHost(
-              browser_context);
-    } else {
-      StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
-          BrowserContext::GetStoragePartition(browser_context, site_instance));
-      render_process_host = new RenderProcessHostImpl(
-          browser_context, partition, is_for_guests_only);
-    }
+    render_process_host =
+        CreateRenderProcessHost(browser_context, partition, is_for_guests_only);
   }
   return render_process_host;
 }
 
 void RenderProcessHostImpl::CreateSharedRendererHistogramAllocator() {
   // Create a persistent memory segment for renderer histograms only if
   // they're active in the browser.
   if (!base::GlobalHistogramAllocator::Get())
     return;
 
@@ skipping 487 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing.
   // Capture the error message in a crash key value.
   base::debug::ScopedCrashKey error_key_value("mojo-message-error", error);
   bad_message::ReceivedBadMessage(render_process_id,
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content