Home | History | Annotate | Download | only in renderer_host 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/browser/renderer_host/render_process_host_impl.h"
      6 #include "content/common/child_process_messages.h"
      7 #include "content/public/browser/render_process_host.h"
      8 #include "content/public/browser/render_process_host_observer.h"
      9 #include "content/public/browser/render_view_host.h"
     10 #include "content/public/browser/web_contents.h"
     11 #include "content/public/common/url_constants.h"
     12 #include "content/public/test/content_browser_test.h"
     13 #include "content/public/test/content_browser_test_utils.h"
     14 #include "content/shell/browser/shell.h"
     15 #include "net/test/embedded_test_server/embedded_test_server.h"
     16 
     17 namespace content {
     18 namespace {
     19 
     20 int RenderProcessHostCount() {
     21   content::RenderProcessHost::iterator hosts =
     22       content::RenderProcessHost::AllHostsIterator();
     23   int count = 0;
     24   while (!hosts.IsAtEnd()) {
     25     if (hosts.GetCurrentValue()->HasConnection())
     26       count++;
     27     hosts.Advance();
     28   }
     29   return count;
     30 }
     31 
     32 class RenderProcessHostTest : public ContentBrowserTest,
     33                               public RenderProcessHostObserver {
     34  public:
     35   RenderProcessHostTest() : process_exits_(0), host_destructions_(0) {}
     36 
     37  protected:
     38   // RenderProcessHostObserver:
     39   virtual void RenderProcessExited(RenderProcessHost* host,
     40                                    base::ProcessHandle handle,
     41                                    base::TerminationStatus status,
     42                                    int exit_code) OVERRIDE {
     43     ++process_exits_;
     44   }
     45   virtual void RenderProcessHostDestroyed(RenderProcessHost* host) OVERRIDE {
     46     ++host_destructions_;
     47   }
     48 
     49   int process_exits_;
     50   int host_destructions_;
     51 };
     52 
     53 // Sometimes the renderer process's ShutdownRequest (corresponding to the
     54 // ViewMsg_WasSwappedOut from a previous navigation) doesn't arrive until after
     55 // the browser process decides to re-use the renderer for a new purpose.  This
     56 // test makes sure the browser doesn't let the renderer die in that case.  See
     57 // http://crbug.com/87176.
     58 IN_PROC_BROWSER_TEST_F(RenderProcessHostTest,
     59                        ShutdownRequestFromActiveTabIgnored) {
     60   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
     61 
     62   GURL test_url = embedded_test_server()->GetURL("/simple_page.html");
     63   NavigateToURL(shell(), test_url);
     64   RenderProcessHost* rph =
     65       shell()->web_contents()->GetRenderViewHost()->GetProcess();
     66 
     67   host_destructions_ = 0;
     68   process_exits_ = 0;
     69   rph->AddObserver(this);
     70   ChildProcessHostMsg_ShutdownRequest msg;
     71   rph->OnMessageReceived(msg);
     72 
     73   // If the RPH sends a mistaken ChildProcessMsg_Shutdown, the renderer process
     74   // will take some time to die. Wait for a second tab to load in order to give
     75   // that time to happen.
     76   NavigateToURL(CreateBrowser(), test_url);
     77 
     78   EXPECT_EQ(0, process_exits_);
     79   if (!host_destructions_)
     80     rph->RemoveObserver(this);
     81 }
     82 
     83 IN_PROC_BROWSER_TEST_F(RenderProcessHostTest,
     84                        GuestsAreNotSuitableHosts) {
     85   // Set max renderers to 1 to force running out of processes.
     86   content::RenderProcessHost::SetMaxRendererProcessCount(1);
     87 
     88   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
     89 
     90   GURL test_url = embedded_test_server()->GetURL("/simple_page.html");
     91   NavigateToURL(shell(), test_url);
     92   RenderProcessHost* rph =
     93       shell()->web_contents()->GetRenderViewHost()->GetProcess();
     94   // Make it believe it's a guest.
     95   reinterpret_cast<RenderProcessHostImpl*>(rph)->
     96       set_is_isolated_guest_for_testing(true);
     97   EXPECT_EQ(1, RenderProcessHostCount());
     98 
     99   // Navigate to a different page.
    100   GURL::Replacements replace_host;
    101   std::string host_str("localhost");  // Must stay in scope with replace_host.
    102   replace_host.SetHostStr(host_str);
    103   GURL another_url = embedded_test_server()->GetURL("/simple_page.html");
    104   another_url = another_url.ReplaceComponents(replace_host);
    105   NavigateToURL(CreateBrowser(), another_url);
    106 
    107   // Expect that we got another process (the guest renderer was not reused).
    108   EXPECT_EQ(2, RenderProcessHostCount());
    109 }
    110 
    111 class ShellCloser : public RenderProcessHostObserver {
    112  public:
    113   ShellCloser(Shell* shell, std::string* logging_string)
    114       : shell_(shell), logging_string_(logging_string) {}
    115 
    116  protected:
    117   // RenderProcessHostObserver:
    118   virtual void RenderProcessExited(RenderProcessHost* host,
    119                                    base::ProcessHandle handle,
    120                                    base::TerminationStatus status,
    121                                    int exit_code) OVERRIDE {
    122     logging_string_->append("ShellCloser::RenderProcessExited ");
    123     shell_->Close();
    124   }
    125 
    126   virtual void RenderProcessHostDestroyed(RenderProcessHost* host) OVERRIDE {
    127     logging_string_->append("ShellCloser::RenderProcessHostDestroyed ");
    128   }
    129 
    130   Shell* shell_;
    131   std::string* logging_string_;
    132 };
    133 
    134 class ObserverLogger : public RenderProcessHostObserver {
    135  public:
    136   explicit ObserverLogger(std::string* logging_string)
    137       : logging_string_(logging_string), host_destroyed_(false) {}
    138 
    139   bool host_destroyed() { return host_destroyed_; }
    140 
    141  protected:
    142   // RenderProcessHostObserver:
    143   virtual void RenderProcessExited(RenderProcessHost* host,
    144                                    base::ProcessHandle handle,
    145                                    base::TerminationStatus status,
    146                                    int exit_code) OVERRIDE {
    147     logging_string_->append("ObserverLogger::RenderProcessExited ");
    148   }
    149 
    150   virtual void RenderProcessHostDestroyed(RenderProcessHost* host) OVERRIDE {
    151     logging_string_->append("ObserverLogger::RenderProcessHostDestroyed ");
    152     host_destroyed_ = true;
    153   }
    154 
    155   std::string* logging_string_;
    156   bool host_destroyed_;
    157 };
    158 
    159 IN_PROC_BROWSER_TEST_F(RenderProcessHostTest,
    160                        AllProcessExitedCallsBeforeAnyHostDestroyedCalls) {
    161   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
    162 
    163   GURL test_url = embedded_test_server()->GetURL("/simple_page.html");
    164   NavigateToURL(shell(), test_url);
    165 
    166   std::string logging_string;
    167   ShellCloser shell_closer(shell(), &logging_string);
    168   ObserverLogger observer_logger(&logging_string);
    169   RenderProcessHost* rph =
    170       shell()->web_contents()->GetRenderViewHost()->GetProcess();
    171 
    172   // Ensure that the ShellCloser observer is first, so that it will have first
    173   // dibs on the ProcessExited callback.
    174   rph->AddObserver(&shell_closer);
    175   rph->AddObserver(&observer_logger);
    176 
    177   // This will crash the render process, and start all the callbacks.
    178   NavigateToURL(shell(), GURL(kChromeUICrashURL));
    179 
    180   // The key here is that all the RenderProcessExited callbacks precede all the
    181   // RenderProcessHostDestroyed callbacks.
    182   EXPECT_EQ("ShellCloser::RenderProcessExited "
    183             "ObserverLogger::RenderProcessExited "
    184             "ShellCloser::RenderProcessHostDestroyed "
    185             "ObserverLogger::RenderProcessHostDestroyed ", logging_string);
    186 
    187   // If the test fails, and somehow the RPH is still alive somehow, at least
    188   // deregister the observers so that the test fails and doesn't also crash.
    189   if (!observer_logger.host_destroyed()) {
    190     rph->RemoveObserver(&shell_closer);
    191     rph->RemoveObserver(&observer_logger);
    192   }
    193 }
    194 
    195 }  // namespace
    196 }  // namespace content
    197