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;
 }
 
+int32_t FirstRenderProcessHostKey() {
+  content::RenderProcessHost::iterator hosts =
+      content::RenderProcessHost::AllHostsIterator();
+  if (!hosts.IsAtEnd()) {
+    return hosts.GetCurrentKey();
+  }
+  return 0;
+}
+
 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());
+  int32_t spare_key = FirstRenderProcessHostKey();

[Benoit L, 2017/06/19 11:30:35]

nit:
EXPECT_NE(0, spare_key);
?

[mattcary, 2017/06/19 12:55:10]

Done.

+
+  GURL test_url = embedded_test_server()->GetURL("/simple_page.html");
+  NavigateToURL(CreateBrowser(), test_url);
+
+  EXPECT_EQ(spare_key, FirstRenderProcessHostKey());
+
+  // 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());
+  int32_t spare_key = FirstRenderProcessHostKey();

[Benoit L, 2017/06/19 11:30:35]

Question: Actually, should we warmup a spare renderprocesshost at all for
incognito?

The potential to reuse it seems lower than for a regular profile.

[mattcary, 2017/06/19 12:55:10]

That's a good question, although shouldn't that be handled at the layer above
this one? The caller has a profile and knows whether it's incognito or not, and
so can make an informed decision. For example, the omnibox use case probably
will work equally well for incognito as for cognito.

[Benoit L, 2017/06/19 13:20:42]

Acknowledged.

+  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_key, FirstRenderProcessHostKey());
+
+  // 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