Enable spare RenderProcessHost to be preinitialized.

content/public/browser/render_process_host.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_RENDER_PROCESS_HOST_H_
 #define CONTENT_PUBLIC_BROWSER_RENDER_PROCESS_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 360 matching lines @@
   //     assigned.
   // Note that a process hosting ServiceWorkers will be implicitly handled by
   // (2) during ServiceWorker initialization, and SharedWorkers will be handled
   // by (1) since a page needs to commit before it can create a SharedWorker.
   //
   // While a process is unused, it is still suitable to host a URL that
   // requires a dedicated process.
   virtual bool IsUnused() = 0;
   virtual void SetIsUsed() = 0;
 
+  // Return true if the host has not been used. This is stronger than IsUnused()
+  // in that it checks if this RPH has ever been used to render at all, rather
+  // than just no being suitable to host a URL that requires a dedicated
+  // process.
+  // TODO(alexmos): can this be unified with IsUnused()? See also
+  // crbug.com/738634.
+  virtual bool HostHasNotBeenUsed() = 0;
+
   // Returns the current number of active views in this process.  Excludes
   // any RenderViewHosts that are swapped out.
   size_t GetActiveViewCount();
 
   // Posts |task|, if this RenderProcessHost is ready or when it becomes ready
   // (see RenderProcessHost::IsReady method).  The |task| might not run at all
   // (e.g. if |render_process_host| is destroyed before becoming ready).  This
   // function can only be called on the browser's UI thread (and the |task| will
   // be posted back on the UI thread).
   void PostTaskWhenProcessIsReady(base::OnceClosure task);
 
   // Static management functions -----------------------------------------------
 
+  // Possibly start an unbound, spare RenderProcessHost. A subsequent creation
+  // of a RenderProcessHost with a matching browser_context may use this
+  // preinitialized RenderProcessHost, improving performance.
+  //
+  // It is safe to call this multiple times or when it is not certain that the
+  // spare renderer will be used, although calling this too eagerly may reduce
+  // performance as unnecessary RenderProcessHosts are created. The spare
+  // renderer will only be used if it using the default StoragePartition of a
+  // matching BrowserContext.
+  //
+  // The spare RenderProcessHost is meant to be created in a situation where a
+  // navigation is imminent and it is unlikely an existing RenderProcessHost
+  // will be used, for example in a cross-site navigation when a Service Worker
+  // will need to be started.
+  static void WarmupSpareRenderProcessHost(
+      content::BrowserContext* browser_context);
+
   // Flag to run the renderer in process.  This is primarily
   // for debugging purposes.  When running "in process", the
   // browser maintains a single RenderProcessHost which communicates
   // to a RenderProcess which is instantiated in the same process
   // with the Browser.  All IPC between the Browser and the
   // Renderer is the same, it's just not crossing a process boundary.
 
   static bool run_renderer_in_process();
 
   // This also calls out to ContentBrowserClient::GetApplicationLocale and
@@ skipping 36 matching lines @@
   static void SetMaxRendererProcessCount(size_t count);
 
   // Returns the current maximum number of renderer process hosts kept by the
   // content module.
   static size_t GetMaxRendererProcessCount();
 };
 
 }  // namespace content.
 
 #endif  // CONTENT_PUBLIC_BROWSER_RENDER_PROCESS_HOST_H_