Enable spare RenderProcessHost to be preinitialized.

content/browser/renderer_host/render_process_host_browsertest.cc

 // Copyright 2013 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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/common/child_process_messages.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_service.mojom.h"
 #include "content/shell/browser/shell.h"
+#include "content/shell/browser/shell_browser_context.h"
+#include "content/shell/browser/shell_content_browser_client.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_data_util.h"
 #include "media/mojo/features.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 namespace content {
 namespace {
 
 int RenderProcessHostCount() {
   content::RenderProcessHost::iterator hosts =
       content::RenderProcessHost::AllHostsIterator();
   int count = 0;
   while (!hosts.IsAtEnd()) {
     if (hosts.GetCurrentValue()->HasConnection())
       count++;
     hosts.Advance();
   }
   return count;
 }
 
+RenderProcessHost* FirstRenderProcessHost() {
+  content::RenderProcessHost::iterator hosts =
+      content::RenderProcessHost::AllHostsIterator();
+  if (!hosts.IsAtEnd()) {
+    return hosts.GetCurrentValue();
+  }
+  return nullptr;
+}
+
 class RenderProcessHostTest : public ContentBrowserTest,
                               public RenderProcessHostObserver {
  public:
   RenderProcessHostTest() : process_exits_(0), host_destructions_(0) {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kIgnoreAutoplayRestrictionsForTests);
   }
 
  protected:
@@ skipping 64 matching lines @@
       set_is_for_guests_only_for_testing(true);
   EXPECT_EQ(1, RenderProcessHostCount());
 
   // Navigate to a different page.
   GURL::Replacements replace_host;
   replace_host.SetHostStr("localhost");
   GURL another_url = embedded_test_server()->GetURL("/simple_page.html");
   another_url = another_url.ReplaceComponents(replace_host);
   NavigateToURL(CreateBrowser(), another_url);
 
-  // Expect that we got another process (the guest renderer was not reused).
+  // Expect that we got another process (the guest RenderProcessHost was not
+  // reused).
   EXPECT_EQ(2, RenderProcessHostCount());
 }
 
+IN_PROC_BROWSER_TEST_F(RenderProcessHostTest, SpareRenderProcessHostTaken) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  RenderProcessHost::WarmupSpareRenderProcessHost(
+      ShellContentBrowserClient::Get()->browser_context());
+  RenderProcessHost* spare_renderer = FirstRenderProcessHost();
+  EXPECT_NE(nullptr, spare_renderer);
+  EXPECT_EQ(RenderProcessHostImpl::GetSpareRenderProcessHostForTesting(),
+            spare_renderer);

[Charlie Reis, 2017/06/26 21:22:50]

We might not need this line, if we can just use
GetSpareRenderProcessHostForTesting() to initialize spare_renderer.

[mattcary, 2017/06/28 13:14:38]

Done.

+
+  GURL test_url = embedded_test_server()->GetURL("/simple_page.html");
+  NavigateToURL(CreateBrowser(), test_url);
+
+  EXPECT_EQ(spare_renderer, FirstRenderProcessHost());

[Charlie Reis, 2017/06/26 21:22:50]

I would suggest checking shell()->web_contents()->GetMainFrame()->GetProcess()
if you're hoping to verify that the navigation consumed the spare process.

[mattcary, 2017/06/28 13:14:38]

Done, that's a good idea, thanks. This is what I was trying to get at with
FirstRenderProcessHost() but seems to be strictly better.

+
+  // The spare render process host should no longer be available.
+  EXPECT_EQ(nullptr,
+            RenderProcessHostImpl::GetSpareRenderProcessHostForTesting());
+}
+
+IN_PROC_BROWSER_TEST_F(RenderProcessHostTest, SpareRenderProcessHostNotTaken) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  RenderProcessHost::WarmupSpareRenderProcessHost(
+      ShellContentBrowserClient::Get()->off_the_record_browser_context());
+  RenderProcessHost* spare_renderer = FirstRenderProcessHost();
+  GURL test_url = embedded_test_server()->GetURL("/simple_page.html");
+  NavigateToURL(CreateBrowser(), test_url);
+
+  // There should have been another process created for the navigation.
+  EXPECT_NE(spare_renderer, FirstRenderProcessHost());

[Charlie Reis, 2017/06/26 21:22:50]

Same here.

[mattcary, 2017/06/28 13:14:38]

Done.

+
+  // The spare RenderProcessHost should have been cleaned up. Note this
+  // behavior is identical to what would have happened if the RenderProcessHost
+  // were taken.
+  EXPECT_EQ(nullptr,
+            RenderProcessHostImpl::GetSpareRenderProcessHostForTesting());
+}
+
+IN_PROC_BROWSER_TEST_F(RenderProcessHostTest, SpareRenderProcessHostKilled) {
+  RenderProcessHost::WarmupSpareRenderProcessHost(
+      ShellContentBrowserClient::Get()->browser_context());
+
+  RenderProcessHost* spare =
+      RenderProcessHostImpl::GetSpareRenderProcessHostForTesting();
+  mojom::TestServicePtr service;
+  ASSERT_NE(nullptr, spare);
+  BindInterface(spare, &service);
+
+  base::RunLoop run_loop;
+  set_process_exit_callback(run_loop.QuitClosure());
+  spare->AddObserver(this);  // For process_exit_callback.
+
+  // Should reply with a bad message and cause process death.
+  service->DoSomething(base::Bind(&base::DoNothing));
+  run_loop.Run();
+
+  // The spare RenderProcessHost should disappear when its process dies.
+  EXPECT_EQ(nullptr,
+            RenderProcessHostImpl::GetSpareRenderProcessHostForTesting());
+}
+
+IN_PROC_BROWSER_TEST_F(RenderProcessHostTest,
+                       SpareRenderProcessHostStoragePartitionKilled) {
+  RenderProcessHost::WarmupSpareRenderProcessHost(
+      ShellContentBrowserClient::Get()->browser_context());
+  EXPECT_NE(nullptr,
+            RenderProcessHostImpl::GetSpareRenderProcessHostForTesting());
+
+  ShellContentBrowserClient::Get()
+      ->browser_context()
+      ->ShutdownStoragePartitions();
+
+  // The spare RenderProcessHost should disappear along with the
+  // StoragePartitions.
+  EXPECT_EQ(nullptr,
+            RenderProcessHostImpl::GetSpareRenderProcessHostForTesting());
+}
+
 class ShellCloser : public RenderProcessHostObserver {
  public:
   ShellCloser(Shell* shell, std::string* logging_string)
       : shell_(shell), logging_string_(logging_string) {}
 
  protected:
   // RenderProcessHostObserver:
   void RenderProcessExited(RenderProcessHost* host,
                            base::TerminationStatus status,
                            int exit_code) override {
@@ skipping 179 matching lines @@
   // Verify shutdown went as expected.
   EXPECT_EQ(0, rph->get_audio_stream_count_for_testing());
   EXPECT_EQ(1, process_exits_);
   EXPECT_EQ(0, host_destructions_);
   if (!host_destructions_)
     rph->RemoveObserver(this);
 }
 
 }  // namespace
 }  // namespace content