src/chrome/browser/renderer_host/render_process_host_chrome_browsertest.cc

   1 // Copyright (c) 2012 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 "base/command_line.h"
   6 #include "chrome/browser/chrome_notification_types.h"
   7 #include "chrome/browser/devtools/devtools_window.h"
   8 #include "chrome/browser/search/search.h"
   9 #include "chrome/browser/ui/browser.h"
  10 #include "chrome/browser/ui/browser_commands.h"
  11 #include "chrome/browser/ui/singleton_tabs.h"
  12 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  13 #include "chrome/common/chrome_switches.h"
  14 #include "chrome/common/url_constants.h"
  15 #include "chrome/test/base/in_process_browser_test.h"
  16 #include "chrome/test/base/test_switches.h"
  17 #include "chrome/test/base/ui_test_utils.h"
  18 #include "content/public/browser/notification_service.h"
  19 #include "content/public/browser/render_process_host.h"
  20 #include "content/public/browser/render_view_host.h"
  21 #include "content/public/browser/render_widget_host_iterator.h"
  22 #include "content/public/browser/web_contents.h"
  23 #include "content/public/browser/web_contents_observer.h"
  24 #include "content/public/test/browser_test_utils.h"
  25
  26 using content::RenderViewHost;
  27 using content::RenderWidgetHost;
  28 using content::WebContents;
  29
  30 namespace {
  31
  32 int RenderProcessHostCount() {
  33   content::RenderProcessHost::iterator hosts =
  34       content::RenderProcessHost::AllHostsIterator();
  35   int count = 0;
  36   while (!hosts.IsAtEnd()) {
  37     if (hosts.GetCurrentValue()->HasConnection())
  38       count++;
  39     hosts.Advance();
  40   }
  41   return count;
  42 }
  43
  44 RenderViewHost* FindFirstDevToolsHost() {
  45   scoped_ptr<content::RenderWidgetHostIterator> widgets(
  46       RenderWidgetHost::GetRenderWidgetHosts());
  47   while (content::RenderWidgetHost* widget = widgets->GetNextHost()) {
  48     if (!widget->GetProcess()->HasConnection())
  49       continue;
  50     if (!widget->IsRenderView())
  51       continue;
  52     RenderViewHost* host = RenderViewHost::From(widget);
  53     WebContents* contents = WebContents::FromRenderViewHost(host);
  54     GURL url = contents->GetURL();
  55     if (url.SchemeIs(content::kChromeDevToolsScheme))
  56       return host;
  57   }
  58   return NULL;
  59 }
  60
  61 }  // namespace
  62
  63 class ChromeRenderProcessHostTest : public InProcessBrowserTest {
  64  public:
  65   ChromeRenderProcessHostTest() {}
  66
  67   // Show a tab, activating the current one if there is one, and wait for
  68   // the renderer process to be created or foregrounded, returning the process
  69   // handle.
  70   base::ProcessHandle ShowSingletonTab(const GURL& page) {
  71     chrome::ShowSingletonTab(browser(), page);
  72     WebContents* wc = browser()->tab_strip_model()->GetActiveWebContents();
  73     CHECK(wc->GetURL() == page);
  74
  75     WaitForLauncherThread();
  76     WaitForMessageProcessing(wc);
  77     return wc->GetRenderProcessHost()->GetHandle();
  78   }
  79
  80   // Loads the given url in a new background tab and returns the handle of its
  81   // renderer.
  82   base::ProcessHandle OpenBackgroundTab(const GURL& page) {
  83     ui_test_utils::NavigateToURLWithDisposition(browser(), page,
  84         NEW_BACKGROUND_TAB, ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
  85
  86     TabStripModel* tab_strip = browser()->tab_strip_model();
  87     WebContents* wc = tab_strip->GetWebContentsAt(
  88         tab_strip->active_index() + 1);
  89     CHECK(wc->GetVisibleURL() == page);
  90
  91     WaitForLauncherThread();
  92     WaitForMessageProcessing(wc);
  93     return wc->GetRenderProcessHost()->GetHandle();
  94   }
  95
  96   // Ensures that the backgrounding / foregrounding gets a chance to run.
  97   void WaitForLauncherThread() {
  98     content::BrowserThread::PostTaskAndReply(
  99         content::BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
 100         base::Bind(&base::DoNothing), base::MessageLoop::QuitClosure());
 101     base::MessageLoop::current()->Run();
 102   }
 103
 104   // Implicitly waits for the renderer process associated with the specified
 105   // WebContents to process outstanding IPC messages by running some JavaScript
 106   // and waiting for the result.
 107   void WaitForMessageProcessing(WebContents* wc) {
 108     bool result = false;
 109     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 110         wc, "window.domAutomationController.send(true);", &result));
 111     ASSERT_TRUE(result);
 112   }
 113
 114   // When we hit the max number of renderers, verify that the way we do process
 115   // sharing behaves correctly.  In particular, this test is verifying that even
 116   // when we hit the max process limit, that renderers of each type will wind up
 117   // in a process of that type, even if that means creating a new process.
 118   void TestProcessOverflow() {
 119     int tab_count = 1;
 120     int host_count = 1;
 121     WebContents* tab1 = NULL;
 122     WebContents* tab2 = NULL;
 123     content::RenderProcessHost* rph1 = NULL;
 124     content::RenderProcessHost* rph2 = NULL;
 125     content::RenderProcessHost* rph3 = NULL;
 126
 127     // Change the first tab to be the omnibox page (TYPE_WEBUI).
 128     GURL omnibox(chrome::kChromeUIOmniboxURL);
 129     ui_test_utils::NavigateToURL(browser(), omnibox);
 130     EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 131     tab1 = browser()->tab_strip_model()->GetWebContentsAt(tab_count - 1);
 132     rph1 = tab1->GetRenderProcessHost();
 133     EXPECT_EQ(omnibox, tab1->GetURL());
 134     EXPECT_EQ(host_count, RenderProcessHostCount());
 135
 136     // Create a new TYPE_TABBED tab.  It should be in its own process.
 137     GURL page1("data:text/html,hello world1");
 138
 139     ui_test_utils::WindowedTabAddedNotificationObserver observer1(
 140         content::NotificationService::AllSources());
 141     chrome::ShowSingletonTab(browser(), page1);
 142     observer1.Wait();
 143
 144     tab_count++;
 145     host_count++;
 146     EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 147     tab1 = browser()->tab_strip_model()->GetWebContentsAt(tab_count - 1);
 148     rph2 = tab1->GetRenderProcessHost();
 149     EXPECT_EQ(tab1->GetURL(), page1);
 150     EXPECT_EQ(host_count, RenderProcessHostCount());
 151     EXPECT_NE(rph1, rph2);
 152
 153     // Create another TYPE_TABBED tab.  It should share the previous process.
 154     GURL page2("data:text/html,hello world2");
 155     ui_test_utils::WindowedTabAddedNotificationObserver observer2(
 156         content::NotificationService::AllSources());
 157     chrome::ShowSingletonTab(browser(), page2);
 158     observer2.Wait();
 159     tab_count++;
 160     EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 161     tab2 = browser()->tab_strip_model()->GetWebContentsAt(tab_count - 1);
 162     EXPECT_EQ(tab2->GetURL(), page2);
 163     EXPECT_EQ(host_count, RenderProcessHostCount());
 164     EXPECT_EQ(tab2->GetRenderProcessHost(), rph2);
 165
 166     // Create another TYPE_WEBUI tab.  It should share the process with omnibox.
 167     // Note: intentionally create this tab after the TYPE_TABBED tabs to
 168     // exercise bug 43448 where extension and WebUI tabs could get combined into
 169     // normal renderers.
 170     GURL history(chrome::kChromeUIHistoryURL);
 171     ui_test_utils::WindowedTabAddedNotificationObserver observer3(
 172         content::NotificationService::AllSources());
 173     chrome::ShowSingletonTab(browser(), history);
 174     observer3.Wait();
 175     tab_count++;
 176     EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 177     tab2 = browser()->tab_strip_model()->GetWebContentsAt(tab_count - 1);
 178     EXPECT_EQ(tab2->GetURL(), GURL(history));
 179     EXPECT_EQ(host_count, RenderProcessHostCount());
 180     EXPECT_EQ(tab2->GetRenderProcessHost(), rph1);
 181
 182     // Create a TYPE_EXTENSION tab.  It should be in its own process.
 183     // (the bookmark manager is implemented as an extension)
 184     GURL bookmarks(chrome::kChromeUIBookmarksURL);
 185     ui_test_utils::WindowedTabAddedNotificationObserver observer4(
 186         content::NotificationService::AllSources());
 187     chrome::ShowSingletonTab(browser(), bookmarks);
 188     observer4.Wait();
 189     tab_count++;
 190     host_count++;
 191     EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 192     tab1 = browser()->tab_strip_model()->GetWebContentsAt(tab_count - 1);
 193     rph3 = tab1->GetRenderProcessHost();
 194     EXPECT_EQ(tab1->GetURL(), bookmarks);
 195     EXPECT_EQ(host_count, RenderProcessHostCount());
 196     EXPECT_NE(rph1, rph3);
 197     EXPECT_NE(rph2, rph3);
 198   }
 199 };
 200
 201
 202 class ChromeRenderProcessHostTestWithCommandLine
 203     : public ChromeRenderProcessHostTest {
 204  protected:
 205   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 206     command_line->AppendSwitchASCII(switches::kRendererProcessLimit, "1");
 207   }
 208 };
 209
 210 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTest, ProcessPerTab) {
 211   // Set max renderers to 1 to force running out of processes.
 212   content::RenderProcessHost::SetMaxRendererProcessCount(1);
 213
 214   CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
 215   parsed_command_line.AppendSwitch(switches::kProcessPerTab);
 216
 217   int tab_count = 1;
 218   int host_count = 1;
 219
 220   // Change the first tab to be the new tab page (TYPE_WEBUI).
 221   GURL omnibox(chrome::kChromeUIOmniboxURL);
 222   ui_test_utils::NavigateToURL(browser(), omnibox);
 223   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 224   EXPECT_EQ(host_count, RenderProcessHostCount());
 225
 226   // Create a new TYPE_TABBED tab.  It should be in its own process.
 227   GURL page1("data:text/html,hello world1");
 228   ui_test_utils::WindowedTabAddedNotificationObserver observer1(
 229       content::NotificationService::AllSources());
 230   chrome::ShowSingletonTab(browser(), page1);
 231   observer1.Wait();
 232   tab_count++;
 233   host_count++;
 234   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 235   EXPECT_EQ(host_count, RenderProcessHostCount());
 236
 237   // Create another TYPE_TABBED tab.  It should share the previous process.
 238   GURL page2("data:text/html,hello world2");
 239   ui_test_utils::WindowedTabAddedNotificationObserver observer2(
 240       content::NotificationService::AllSources());
 241   chrome::ShowSingletonTab(browser(), page2);
 242   observer2.Wait();
 243   tab_count++;
 244   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 245   EXPECT_EQ(host_count, RenderProcessHostCount());
 246
 247   // Create another omnibox tab.  It should share the process with the other
 248   // WebUI.
 249   ui_test_utils::NavigateToURLWithDisposition(
 250       browser(), omnibox, NEW_FOREGROUND_TAB,
 251       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 252   tab_count++;
 253   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 254   EXPECT_EQ(host_count, RenderProcessHostCount());
 255
 256   // Create another omnibox tab.  It should share the process with the other
 257   // WebUI.
 258   ui_test_utils::NavigateToURLWithDisposition(
 259       browser(), omnibox, NEW_FOREGROUND_TAB,
 260       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 261   tab_count++;
 262   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 263   EXPECT_EQ(host_count, RenderProcessHostCount());
 264 }
 265
 266 // We don't change process priorities on Mac or Posix because the user lacks the
 267 // permission to raise a process' priority even after lowering it.
 268 // flaky, disabling on branch
 269 #if defined(OS_WIN) || defined(OS_LINUX)
 270 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTest, DISABLED_Backgrounding) {
 271   if (!base::Process::CanBackgroundProcesses()) {
 272     LOG(ERROR) << "Can't background processes";
 273     return;
 274   }
 275   CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
 276   parsed_command_line.AppendSwitch(switches::kProcessPerTab);
 277
 278   // Change the first tab to be the omnibox page (TYPE_WEBUI).
 279   GURL omnibox(chrome::kChromeUIOmniboxURL);
 280   ui_test_utils::NavigateToURL(browser(), omnibox);
 281
 282   // Create a new tab. It should be foreground.
 283   GURL page1("data:text/html,hello world1");
 284   base::ProcessHandle pid1 = ShowSingletonTab(page1);
 285   EXPECT_FALSE(base::Process(pid1).IsProcessBackgrounded());
 286
 287   // Create another tab. It should be foreground, and the first tab should
 288   // now be background.
 289   GURL page2("data:text/html,hello world2");
 290   base::ProcessHandle pid2 = ShowSingletonTab(page2);
 291   EXPECT_NE(pid1, pid2);
 292   EXPECT_TRUE(base::Process(pid1).IsProcessBackgrounded());
 293   EXPECT_FALSE(base::Process(pid2).IsProcessBackgrounded());
 294
 295   // Load another tab in background. The renderer of the new tab should be
 296   // backgrounded, while visibility of the other renderers should not change.
 297   GURL page3("data:text/html,hello world3");
 298   base::ProcessHandle pid3 = OpenBackgroundTab(page3);
 299   EXPECT_NE(pid3, pid1);
 300   EXPECT_NE(pid3, pid2);
 301   EXPECT_TRUE(base::Process(pid1).IsProcessBackgrounded());
 302   EXPECT_FALSE(base::Process(pid2).IsProcessBackgrounded());
 303   EXPECT_TRUE(base::Process(pid3).IsProcessBackgrounded());
 304
 305   // Navigate back to the first page. Its renderer should be in foreground
 306   // again while the other renderers should be backgrounded.
 307   EXPECT_EQ(pid1, ShowSingletonTab(page1));
 308   EXPECT_FALSE(base::Process(pid1).IsProcessBackgrounded());
 309   EXPECT_TRUE(base::Process(pid2).IsProcessBackgrounded());
 310   EXPECT_TRUE(base::Process(pid3).IsProcessBackgrounded());
 311 }
 312 #endif
 313
 314 // TODO(nasko): crbug.com/173137
 315 #if defined(OS_WIN)
 316 #define MAYBE_ProcessOverflow DISABLED_ProcessOverflow
 317 #else
 318 #define MAYBE_ProcessOverflow ProcessOverflow
 319 #endif
 320
 321 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTest, MAYBE_ProcessOverflow) {
 322   // Set max renderers to 1 to force running out of processes.
 323   content::RenderProcessHost::SetMaxRendererProcessCount(1);
 324   TestProcessOverflow();
 325 }
 326
 327 // Variation of the ProcessOverflow test, which is driven through command line
 328 // parameter instead of direct function call into the class.
 329 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTestWithCommandLine,
 330                        ProcessOverflow) {
 331   TestProcessOverflow();
 332 }
 333
 334 // Ensure that DevTools opened to debug DevTools is launched in a separate
 335 // process when --process-per-tab is set. See crbug.com/69873.
 336 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTest,
 337                        DevToolsOnSelfInOwnProcessPPT) {
 338 #if defined(OS_WIN) && defined(USE_ASH)
 339   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 340   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 341     return;
 342 #endif
 343
 344   CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
 345   parsed_command_line.AppendSwitch(switches::kProcessPerTab);
 346
 347   int tab_count = 1;
 348   int host_count = 1;
 349
 350   GURL page1("data:text/html,hello world1");
 351   ui_test_utils::WindowedTabAddedNotificationObserver observer1(
 352       content::NotificationService::AllSources());
 353   chrome::ShowSingletonTab(browser(), page1);
 354   observer1.Wait();
 355   tab_count++;
 356   host_count++;
 357   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 358   EXPECT_EQ(host_count, RenderProcessHostCount());
 359
 360   // DevTools start in docked mode (no new tab), in a separate process.
 361   chrome::ToggleDevToolsWindow(browser(), DevToolsToggleAction::Inspect());
 362   host_count++;
 363   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 364   EXPECT_EQ(host_count, RenderProcessHostCount());
 365
 366   RenderViewHost* devtools = FindFirstDevToolsHost();
 367   DCHECK(devtools);
 368
 369   // DevTools start in a separate process.
 370   DevToolsWindow::OpenDevToolsWindow(devtools, DevToolsToggleAction::Inspect());
 371   host_count++;
 372   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 373   EXPECT_EQ(host_count, RenderProcessHostCount());
 374
 375   // close docked devtools
 376   content::WindowedNotificationObserver close_observer(
 377       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
 378       content::Source<WebContents>(WebContents::FromRenderViewHost(devtools)));
 379
 380   chrome::ToggleDevToolsWindow(browser(), DevToolsToggleAction::Toggle());
 381   close_observer.Wait();
 382 }
 383
 384 // Ensure that DevTools opened to debug DevTools is launched in a separate
 385 // process. See crbug.com/69873.
 386 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTest,
 387                        DevToolsOnSelfInOwnProcess) {
 388 #if defined(OS_WIN) && defined(USE_ASH)
 389   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 390   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 391     return;
 392 #endif
 393
 394   int tab_count = 1;
 395   int host_count = 1;
 396
 397   GURL page1("data:text/html,hello world1");
 398   ui_test_utils::WindowedTabAddedNotificationObserver observer1(
 399       content::NotificationService::AllSources());
 400   chrome::ShowSingletonTab(browser(), page1);
 401   observer1.Wait();
 402   tab_count++;
 403   host_count++;
 404   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 405   EXPECT_EQ(host_count, RenderProcessHostCount());
 406
 407   // DevTools start in docked mode (no new tab), in a separate process.
 408   chrome::ToggleDevToolsWindow(browser(), DevToolsToggleAction::Inspect());
 409   host_count++;
 410   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 411   EXPECT_EQ(host_count, RenderProcessHostCount());
 412
 413   RenderViewHost* devtools = FindFirstDevToolsHost();
 414   DCHECK(devtools);
 415
 416   // DevTools start in a separate process.
 417   DevToolsWindow::OpenDevToolsWindow(devtools, DevToolsToggleAction::Inspect());
 418   host_count++;
 419   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
 420   EXPECT_EQ(host_count, RenderProcessHostCount());
 421
 422   // close docked devtools
 423   content::WindowedNotificationObserver close_observer(
 424       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
 425       content::Source<content::WebContents>(
 426           WebContents::FromRenderViewHost(devtools)));
 427   chrome::ToggleDevToolsWindow(browser(), DevToolsToggleAction::Toggle());
 428   close_observer.Wait();
 429 }
 430
 431 // This class's goal is to close the browser window when a renderer process has
 432 // crashed. It does so by monitoring WebContents for RenderProcessGone event and
 433 // closing the passed in TabStripModel. This is used in the following test case.
 434 class WindowDestroyer : public content::WebContentsObserver {
 435  public:
 436   WindowDestroyer(content::WebContents* web_contents, TabStripModel* model)
 437       : content::WebContentsObserver(web_contents),
 438         tab_strip_model_(model) {
 439   }
 440
 441   virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE {
 442     // Wait for the window to be destroyed, which will ensure all other
 443     // RenderViewHost objects are deleted before we return and proceed with
 444     // the next iteration of notifications.
 445     content::WindowedNotificationObserver observer(
 446         chrome::NOTIFICATION_BROWSER_CLOSED,
 447         content::NotificationService::AllSources());
 448     tab_strip_model_->CloseAllTabs();
 449     observer.Wait();
 450   }
 451
 452  private:
 453   TabStripModel* tab_strip_model_;
 454
 455   DISALLOW_COPY_AND_ASSIGN(WindowDestroyer);
 456 };
 457
 458 // Test to ensure that while iterating through all listeners in
 459 // RenderProcessHost and invalidating them, we remove them properly and don't
 460 // access already freed objects. See http://crbug.com/255524.
 461 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTest,
 462                        CloseAllTabsDuringProcessDied) {
 463   GURL url(chrome::kChromeUIOmniboxURL);
 464
 465   ui_test_utils::NavigateToURL(browser(), url);
 466   ui_test_utils::NavigateToURLWithDisposition(
 467       browser(), url, NEW_BACKGROUND_TAB,
 468       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 469
 470   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 471
 472   WebContents* wc1 = browser()->tab_strip_model()->GetWebContentsAt(0);
 473   WebContents* wc2 = browser()->tab_strip_model()->GetWebContentsAt(1);
 474   EXPECT_EQ(wc1->GetRenderProcessHost(), wc2->GetRenderProcessHost());
 475
 476   // Create an object that will close the window on a process crash.
 477   WindowDestroyer destroyer(wc1, browser()->tab_strip_model());
 478
 479   // Use NOTIFICATION_BROWSER_CLOSED instead of NOTIFICATION_WINDOW_CLOSED,
 480   // since the latter is not implemented on OSX and the test will timeout,
 481   // causing it to fail.
 482   content::WindowedNotificationObserver observer(
 483       chrome::NOTIFICATION_BROWSER_CLOSED,
 484       content::NotificationService::AllSources());
 485
 486   // Kill the renderer process, simulating a crash. This should the ProcessDied
 487   // method to be called. Alternatively, RenderProcessHost::OnChannelError can
 488   // be called to directly force a call to ProcessDied.
 489   base::KillProcess(wc1->GetRenderProcessHost()->GetHandle(), -1, true);
 490
 491   observer.Wait();
 492 }