Don't allow a renderer to exit if we are using it in other views.

content/browser/renderer_host/render_process_host_browsertest.cc

 // 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.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/process.h"
+#include "chrome/browser/chrome_content_browser_client.h"

[jam, 2012/03/21 23:30:12]

you're going to get a checkdeps failure for this.. i should have thought about
this more before my suggestion over email. you can't derive from the chrome impl
since you're in content.

[Charlie Reis, 2012/03/21 23:44:14]

Yeah, I realized that...  This seems like a limitation on what we can test in
browser_tests, since those have a full Chrome instance that we'd like to
interact with.  Should browsertest.cc files live in chrome, or have an exception
that allows them to include chrome files (like the chrome/browser/ui/browser.h
below)?

If we had browser_tests that just ran on content_shell, that would probably work
too, but we're not there yet.

I suppose the best option at the moment is to create a new test file in chrome
for just this new test?

[Charlie Reis, 2012/03/21 23:51:17]

Actually, we've already got a render_process_host_chrome_browsertest.cc in
chrome!  I'll put it there.

 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/child_process_messages.h"
 #include "content/common/test_url_constants.h"
+#include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/page_navigator.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/referrer.h"
+#include "ipc/ipc_message_macros.h"
 
 using content::WebContents;
 
 void PostQuit(MessageLoop* loop) {
   loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
+namespace {
+
+// Custom message filter to consume shutdown messages on demand.
+class RenderProcessHostTestMessageFilter
+    : public content::BrowserMessageFilter {
+ public:
+  RenderProcessHostTestMessageFilter() :
+      should_filter_shutdown_requests_(false) {}
+  virtual ~RenderProcessHostTestMessageFilter() {}
+
+  void set_should_filter_shutdown_requests(bool should_filter) {
+    should_filter_shutdown_requests_ = should_filter;
+  }
+
+  bool OnMessageReceived(const IPC::Message& message,
+                         bool* message_was_ok) OVERRIDE {
+    if (!should_filter_shutdown_requests_)
+      return false;
+
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP_EX(RenderProcessHostTestMessageFilter,
+                             message, *message_was_ok)
+      IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ShutdownRequest,
+                          OnShutdownRequest)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled;
+  }
+
+  void OnShutdownRequest() {
+    // Discard the message so the browser doesn't see it.
+  }
+
+ private:
+  bool should_filter_shutdown_requests_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenderProcessHostTestMessageFilter);
+};
+
+class RenderProcessHostTestBrowserClient
+    : public chrome::ChromeContentBrowserClient {
+ public:
+  RenderProcessHostTestBrowserClient() :
+      message_filter_(new RenderProcessHostTestMessageFilter()) {}
+  virtual ~RenderProcessHostTestBrowserClient() {}
+
+  // ChromeContentBrowserClient implementation.
+  virtual void RenderProcessHostCreated(content::RenderProcessHost* host)
+      OVERRIDE {
+    // Install our custom filter first.
+    host->GetChannel()->AddFilter(message_filter_);
+
+    // Install the remaining message filters.
+    ChromeContentBrowserClient::RenderProcessHostCreated(host);
+  }
+
+  scoped_refptr<RenderProcessHostTestMessageFilter> message_filter_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenderProcessHostTestBrowserClient);
+};
+
+}  // namespace
+
 class RenderProcessHostTest : public InProcessBrowserTest {
  public:
   RenderProcessHostTest() {
     EnableDOMAutomation();
   }
 
   int RenderProcessHostCount() {
     content::RenderProcessHost::iterator hosts =
         content::RenderProcessHost::AllHostsIterator();
     int count = 0;
@@ skipping 15 matching lines @@
 
     // Ensure that the backgrounding / foregrounding gets a chance to run.
     content::BrowserThread::PostTaskAndReply(
         content::BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
         base::Bind(&base::DoNothing), MessageLoop::QuitClosure());
     MessageLoop::current()->Run();
 
     return wc->GetRenderProcessHost()->GetHandle();
   }
 
+  virtual void SetUp() OVERRIDE {
+    old_browser_client_ = content::GetContentClient()->browser();
+    content::GetContentClient()->set_browser(&browser_client_);
+    InProcessBrowserTest::SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    InProcessBrowserTest::TearDown();
+    content::GetContentClient()->set_browser(old_browser_client_);
+  }
+
   // When we hit the max number of renderers, verify that the way we do process
   // sharing behaves correctly.  In particular, this test is verifying that even
   // when we hit the max process limit, that renderers of each type will wind up
   // in a process of that type, even if that means creating a new process.
   void TestProcessOverflow() {
     int tab_count = 1;
     int host_count = 1;
     WebContents* tab1 = NULL;
     WebContents* tab2 = NULL;
     content::RenderProcessHost* rph1 = NULL;
@@ skipping 67 matching lines @@
     host_count++;
 #endif
     EXPECT_EQ(tab_count, browser()->tab_count());
     tab1 = browser()->GetWebContentsAt(tab_count - 1);
     rph3 = tab1->GetRenderProcessHost();
     EXPECT_EQ(tab1->GetURL(), bookmarks);
     EXPECT_EQ(host_count, RenderProcessHostCount());
     EXPECT_NE(rph1, rph3);
     EXPECT_NE(rph2, rph3);
   }
+
+ protected:
+  RenderProcessHostTestBrowserClient browser_client_;
+
+ private:
+  content::ContentBrowserClient* old_browser_client_;
 };
 
 
 class RenderProcessHostTestWithCommandLine : public RenderProcessHostTest {
  protected:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     InProcessBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(switches::kRendererProcessLimit, "1");
   }
 };
@@ skipping 94 matching lines @@
   // Set max renderers to 1 to force running out of processes.
   content::RenderProcessHost::SetMaxRendererProcessCount(1);
   TestProcessOverflow();
 }
 
 // Variation of the ProcessOverflow test, which is driven through command line
 // parameter instead of direct function call into the class.
 IN_PROC_BROWSER_TEST_F(RenderProcessHostTestWithCommandLine, ProcessOverflow) {
   TestProcessOverflow();
 }
+
+// Ensure that if a second NTP is opened as the first one is exiting, we don't
+// end up killing the second NTP as well.  http://crbug.com/87176.
+IN_PROC_BROWSER_TEST_F(RenderProcessHostTest, DontPutNTPInDyingProcess) {
+  // Change the first tab to be the new tab page (TYPE_WEBUI).
+  GURL newtab(chrome::kTestNewTabURL);
+  ui_test_utils::NavigateToURL(browser(), newtab);
+  content::RenderProcessHost* rph =
+      browser()->GetSelectedWebContents()->GetRenderProcessHost();
+  RenderProcessHostImpl* process = static_cast<RenderProcessHostImpl*>(rph);
+
+  // Before navigating away, make sure the ShutdownRequest message is "delayed"
+  // by consuming it and sending a new one later.
+  browser_client_.message_filter_->set_should_filter_shutdown_requests(true);
+
+  // Now navigate to a page that causes a process swap, causing the NTP's
+  // process to send a ShutdownRequest message (which we "delay").
+  GURL page1("data:text/html,hello world1");
+  ui_test_utils::NavigateToURL(browser(), page1);
+
+  // Before the ShutdownRequest message arrives, open a new tab with the NTP.
+  ui_test_utils::WindowedNotificationObserver nav_observer(
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED,
+      content::NotificationService::AllSources());
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(), newtab, NEW_FOREGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
+
+  // After the tab opens but before the navigation completes, simulate the
+  // ShutdownRequest message arriving.
+  browser_client_.message_filter_->set_should_filter_shutdown_requests(false);
+  process->OnShutdownRequest();
+
+  // Wait for the NTP navigation to finish.
+  nav_observer.Wait();
+  WebContents* contents = browser()->GetSelectedWebContents();
+  EXPECT_EQ(process, contents->GetRenderProcessHost());
+  EXPECT_TRUE(process->HasConnection());
+}