chrome/browser/task_manager/task_manager_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 "chrome/browser/task_manager/task_manager.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/browser_process.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/browser/devtools/devtools_window_testing.h"
  13 #include "chrome/browser/extensions/extension_browsertest.h"
  14 #include "chrome/browser/extensions/extension_service.h"
  15 #include "chrome/browser/infobars/infobar_service.h"
  16 #include "chrome/browser/notifications/desktop_notification_service.h"
  17 #include "chrome/browser/notifications/notification.h"
  18 #include "chrome/browser/notifications/notification_test_util.h"
  19 #include "chrome/browser/notifications/notification_ui_manager.h"
  20 #include "chrome/browser/profiles/profile.h"
  21 #include "chrome/browser/task_manager/resource_provider.h"
  22 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
  23 #include "chrome/browser/ui/browser.h"
  24 #include "chrome/browser/ui/browser_commands.h"
  25 #include "chrome/browser/ui/browser_dialogs.h"
  26 #include "chrome/browser/ui/browser_navigator.h"
  27 #include "chrome/browser/ui/browser_window.h"
  28 #include "chrome/browser/ui/panels/panel.h"
  29 #include "chrome/browser/ui/panels/panel_manager.h"
  30 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  31 #include "chrome/browser/web_applications/web_app.h"
  32 #include "chrome/common/chrome_switches.h"
  33 #include "chrome/grit/generated_resources.h"
  34 #include "chrome/test/base/in_process_browser_test.h"
  35 #include "chrome/test/base/ui_test_utils.h"
  36 #include "components/infobars/core/confirm_infobar_delegate.h"
  37 #include "components/infobars/core/infobar.h"
  38 #include "content/public/browser/notification_service.h"
  39 #include "content/public/browser/page_navigator.h"
  40 #include "content/public/browser/render_frame_host.h"
  41 #include "content/public/common/content_switches.h"
  42 #include "content/public/test/browser_test_utils.h"
  43 #include "content/public/test/content_browser_test_utils.h"
  44 #include "extensions/browser/extension_system.h"
  45 #include "extensions/common/extension.h"
  46 #include "net/dns/mock_host_resolver.h"
  47 #include "net/test/embedded_test_server/embedded_test_server.h"
  48 #include "testing/gtest/include/gtest/gtest.h"
  49 #include "ui/base/l10n/l10n_util.h"
  50 #include "ui/base/page_transition_types.h"
  51
  52 using content::WebContents;
  53 using task_manager::browsertest_util::MatchAboutBlankTab;
  54 using task_manager::browsertest_util::MatchAnyApp;
  55 using task_manager::browsertest_util::MatchAnyExtension;
  56 using task_manager::browsertest_util::MatchAnySubframe;
  57 using task_manager::browsertest_util::MatchAnyTab;
  58 using task_manager::browsertest_util::MatchAnyUtility;
  59 using task_manager::browsertest_util::MatchApp;
  60 using task_manager::browsertest_util::MatchExtension;
  61 using task_manager::browsertest_util::MatchSubframe;
  62 using task_manager::browsertest_util::MatchTab;
  63 using task_manager::browsertest_util::MatchUtility;
  64 using task_manager::browsertest_util::WaitForTaskManagerRows;
  65 using task_manager::browsertest_util::WaitForTaskManagerStatToExceed;
  66
  67 namespace {
  68
  69 const base::FilePath::CharType* kTitle1File = FILE_PATH_LITERAL("title1.html");
  70
  71 }  // namespace
  72
  73 class TaskManagerBrowserTest : public ExtensionBrowserTest {
  74  public:
  75   TaskManagerBrowserTest() {}
  76   ~TaskManagerBrowserTest() override {}
  77
  78   TaskManagerModel* model() const {
  79     return TaskManager::GetInstance()->model();
  80   }
  81
  82   void ShowTaskManager() {
  83     EXPECT_EQ(0, model()->ResourceCount());
  84
  85     // Show the task manager. This populates the model, and helps with debugging
  86     // (you see the task manager).
  87     chrome::ShowTaskManager(browser());
  88   }
  89
  90   void HideTaskManager() {
  91     // Hide the task manager, and wait for the model to be depopulated.
  92     chrome::HideTaskManager();
  93     base::RunLoop().RunUntilIdle();  // OnWindowClosed happens asynchronously.
  94     EXPECT_EQ(0, model()->ResourceCount());
  95   }
  96
  97   void Refresh() {
  98     model()->Refresh();
  99   }
 100
 101   int GetUpdateTimeMs() {
 102     return TaskManagerModel::kUpdateTimeMs;
 103   }
 104
 105   GURL GetTestURL() {
 106     return ui_test_utils::GetTestUrl(
 107         base::FilePath(base::FilePath::kCurrentDirectory),
 108         base::FilePath(kTitle1File));
 109   }
 110
 111   int FindResourceIndex(const base::string16& title) {
 112     for (int i = 0; i < model()->ResourceCount(); ++i) {
 113       if (title == model()->GetResourceTitle(i))
 114         return i;
 115     }
 116     return -1;
 117   }
 118
 119  protected:
 120   void SetUpCommandLine(base::CommandLine* command_line) override {
 121     ExtensionBrowserTest::SetUpCommandLine(command_line);
 122
 123     // Do not launch device discovery process.
 124     command_line->AppendSwitch(switches::kDisableDeviceDiscoveryNotifications);
 125   }
 126
 127  private:
 128   DISALLOW_COPY_AND_ASSIGN(TaskManagerBrowserTest);
 129 };
 130
 131 class TaskManagerUtilityProcessBrowserTest : public TaskManagerBrowserTest {
 132  public:
 133   TaskManagerUtilityProcessBrowserTest() {}
 134
 135  protected:
 136   void SetUpCommandLine(base::CommandLine* command_line) override {
 137     TaskManagerBrowserTest::SetUpCommandLine(command_line);
 138
 139     // Enable out-of-process proxy resolver. Use a trivial PAC script to ensure
 140     // that some javascript is being executed.
 141     command_line->AppendSwitch(switches::kV8PacMojoOutOfProcess);
 142     command_line->AppendSwitchASCII(
 143         switches::kProxyPacUrl,
 144         "data:,function FindProxyForURL(url, host){return \"DIRECT;\";}");
 145   }
 146
 147  private:
 148   DISALLOW_COPY_AND_ASSIGN(TaskManagerUtilityProcessBrowserTest);
 149 };
 150
 151 // Parameterized variant of TaskManagerBrowserTest which runs with/without
 152 // --site-per-process, which enables out of process iframes (OOPIFs).
 153 class TaskManagerOOPIFBrowserTest : public TaskManagerBrowserTest,
 154                                     public testing::WithParamInterface<bool> {
 155  public:
 156   TaskManagerOOPIFBrowserTest() {}
 157
 158  protected:
 159   void SetUpCommandLine(base::CommandLine* command_line) override {
 160     TaskManagerBrowserTest::SetUpCommandLine(command_line);
 161     if (GetParam())
 162       command_line->AppendSwitch(switches::kSitePerProcess);
 163   }
 164
 165   bool ShouldExpectSubframes() {
 166     return base::CommandLine::ForCurrentProcess()->HasSwitch(
 167         switches::kSitePerProcess);
 168   }
 169
 170  private:
 171   DISALLOW_COPY_AND_ASSIGN(TaskManagerOOPIFBrowserTest);
 172 };
 173
 174 INSTANTIATE_TEST_CASE_P(, TaskManagerOOPIFBrowserTest, ::testing::Bool());
 175
 176 #if defined(OS_MACOSX) || defined(OS_LINUX)
 177 #define MAYBE_ShutdownWhileOpen DISABLED_ShutdownWhileOpen
 178 #else
 179 #define MAYBE_ShutdownWhileOpen ShutdownWhileOpen
 180 #endif
 181
 182 // Regression test for http://crbug.com/13361
 183 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, MAYBE_ShutdownWhileOpen) {
 184   ShowTaskManager();
 185 }
 186
 187 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticeTabContentsChanges) {
 188   ShowTaskManager();
 189   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 190   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 191   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchTab("title1.html")));
 192
 193   // Open a new tab and make sure the task manager notices it.
 194   AddTabAtIndex(0, GetTestURL(), ui::PAGE_TRANSITION_TYPED);
 195
 196   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("title1.html")));
 197   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 198
 199   // Close the tab and verify that we notice.
 200   browser()->tab_strip_model()->CloseWebContentsAt(0,
 201                                                    TabStripModel::CLOSE_NONE);
 202   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchTab("title1.html")));
 203   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 204 }
 205
 206 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, KillTab) {
 207   ShowTaskManager();
 208   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 209   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 210   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchTab("title1.html")));
 211
 212   // Open a new tab and make sure the task manager notices it.
 213   AddTabAtIndex(0, GetTestURL(), ui::PAGE_TRANSITION_TYPED);
 214
 215   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("title1.html")));
 216   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 217
 218   // Killing the tab via task manager should remove the row.
 219   int tab = FindResourceIndex(MatchTab("title1.html"));
 220   ASSERT_NE(-1, tab);
 221   ASSERT_TRUE(model()->GetResourceWebContents(tab) != NULL);
 222   ASSERT_TRUE(model()->CanActivate(tab));
 223   TaskManager::GetInstance()->KillProcess(tab);
 224   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchTab("title1.html")));
 225   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 226
 227   // Tab should reappear in task manager upon reload.
 228   chrome::Reload(browser(), CURRENT_TAB);
 229   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("title1.html")));
 230   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 231 }
 232
 233 // Test for http://crbug.com/444945, which is not fixed yet.
 234 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest,
 235                        DISABLED_NavigateAwayFromHungRenderer) {
 236   host_resolver()->AddRule("*", "127.0.0.1");
 237   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 238   ShowTaskManager();
 239
 240   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 241   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 242
 243   GURL url1(embedded_test_server()->GetURL("/title2.html"));
 244   GURL url3(embedded_test_server()->GetURL("a.com", "/iframe.html"));
 245
 246   // Open a new tab and make sure the task manager notices it.
 247   AddTabAtIndex(0, url1, ui::PAGE_TRANSITION_TYPED);
 248   ASSERT_NO_FATAL_FAILURE(
 249       WaitForTaskManagerRows(1, MatchTab("Title Of Awesomeness")));
 250   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 251   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 252   WebContents* tab1 = browser()->tab_strip_model()->GetActiveWebContents();
 253
 254   // Initiate a navigation that will create a new WebContents in the same
 255   // SiteInstace...
 256   content::WebContentsAddedObserver web_contents_added_observer;
 257   tab1->GetMainFrame()->ExecuteJavaScriptWithUserGestureForTests(
 258       base::ASCIIToUTF16("window.open('title3.html', '_blank');"));
 259   // ... then immediately hang the renderer so that title3.html can't load.
 260   tab1->GetMainFrame()->ExecuteJavaScript(base::ASCIIToUTF16("while(1);"));
 261
 262   // Blocks until a new WebContents appears.
 263   WebContents* tab2 = web_contents_added_observer.GetWebContents();
 264
 265   // Make sure the new WebContents is in tab1's hung renderer process.
 266   ASSERT_NE(nullptr, tab2);
 267   ASSERT_NE(tab1, tab2);
 268   ASSERT_EQ(tab1->GetMainFrame()->GetProcess(),
 269             tab2->GetMainFrame()->GetProcess())
 270       << "New WebContents must be in the same process as the old WebContents, "
 271       << "so that the new tab doesn't finish loading (what this test is all "
 272       << "about)";
 273   ASSERT_EQ(tab1->GetSiteInstance(), tab2->GetSiteInstance())
 274       << "New WebContents must initially be in the same site instance as the "
 275       << "old WebContents";
 276
 277   // Now navigate this tab to a different site. This should wind up in a
 278   // different renderer process, so it should complete and show up in the task
 279   // manager.
 280   tab2->OpenURL(content::OpenURLParams(url3, content::Referrer(), CURRENT_TAB,
 281                                        ui::PAGE_TRANSITION_TYPED, false));
 282
 283   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("iframe test")));
 284 }
 285
 286 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticePanel) {
 287   ASSERT_TRUE(LoadExtension(
 288       test_data_dir_.AppendASCII("good").AppendASCII("Extensions")
 289                     .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
 290                     .AppendASCII("1.0.0.0")));
 291
 292   // Open a new panel to an extension url.
 293   GURL url(
 294     "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/french_sentence.html");
 295   Panel* panel = PanelManager::GetInstance()->CreatePanel(
 296       web_app::GenerateApplicationNameFromExtensionId(
 297           last_loaded_extension_id()),
 298       browser()->profile(),
 299       url,
 300       gfx::Rect(300, 400),
 301       PanelManager::CREATE_AS_DOCKED);
 302
 303   // Make sure that a task manager model created after the panel shows the
 304   // existence of the panel and the extension.
 305   ShowTaskManager();
 306   ASSERT_NO_FATAL_FAILURE(
 307       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 308   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(
 309       1,
 310       MatchExtension(
 311           "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 312           "french_sentence.html")));
 313   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyExtension()));
 314   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 315   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 316
 317   // Close the panel and verify that we notice.
 318   panel->Close();
 319   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyExtension()));
 320   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(
 321       0,
 322       MatchExtension(
 323           "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 324           "french_sentence.html")));
 325   ASSERT_NO_FATAL_FAILURE(
 326       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 327 }
 328
 329 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticePanelChanges) {
 330   ShowTaskManager();
 331   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 332   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 333
 334   ASSERT_TRUE(LoadExtension(
 335       test_data_dir_.AppendASCII("good").AppendASCII("Extensions")
 336                     .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
 337                     .AppendASCII("1.0.0.0")));
 338
 339   // Browser, the New Tab Page and Extension background page.
 340   ASSERT_NO_FATAL_FAILURE(
 341       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 342   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyExtension()));
 343   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 344
 345   // Open a new panel to an extension url and make sure we notice that.
 346   GURL url(
 347     "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/french_sentence.html");
 348   Panel* panel = PanelManager::GetInstance()->CreatePanel(
 349       web_app::GenerateApplicationNameFromExtensionId(
 350           last_loaded_extension_id()),
 351       browser()->profile(),
 352       url,
 353       gfx::Rect(300, 400),
 354       PanelManager::CREATE_AS_DOCKED);
 355   ASSERT_NO_FATAL_FAILURE(
 356       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 357   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(
 358       1,
 359       MatchExtension(
 360           "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 361           "french_sentence.html")));
 362   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyExtension()));
 363   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 364   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 365
 366   // Close the panel and verify that we notice.
 367   panel->Close();
 368   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyExtension()));
 369   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(
 370       0,
 371       MatchExtension(
 372           "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 373           "french_sentence.html")));
 374   ASSERT_NO_FATAL_FAILURE(
 375       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 376
 377   // Unload extension.
 378   UnloadExtension(last_loaded_extension_id());
 379   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 380   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 381 }
 382
 383 // Kills a process that has more than one task manager entry.
 384 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, KillPanelViaExtensionResource) {
 385   ShowTaskManager();
 386   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("good")
 387                                 .AppendASCII("Extensions")
 388                                 .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
 389                                 .AppendASCII("1.0.0.0")));
 390
 391   // Open a new panel to an extension url.
 392   GURL url(
 393       "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 394       "french_sentence.html");
 395   PanelManager::GetInstance()->CreatePanel(
 396       web_app::GenerateApplicationNameFromExtensionId(
 397           last_loaded_extension_id()),
 398       browser()->profile(),
 399       url,
 400       gfx::Rect(300, 400),
 401       PanelManager::CREATE_AS_DOCKED);
 402
 403   ASSERT_NO_FATAL_FAILURE(
 404       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 405   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(
 406       1,
 407       MatchExtension(
 408           "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 409           "french_sentence.html")));
 410   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyExtension()));
 411   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 412   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 413
 414   // Kill the process via the BACKGROUND PAGE (not the panel). Verify that both
 415   // the background page and the panel go away from the task manager.
 416   int background_page = FindResourceIndex(MatchExtension("My extension 1"));
 417   ASSERT_NE(-1, background_page);
 418   ASSERT_TRUE(model()->GetResourceWebContents(background_page) == NULL);
 419   ASSERT_FALSE(model()->CanActivate(background_page));
 420   TaskManager::GetInstance()->KillProcess(background_page);
 421   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 422   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 423 }
 424
 425 // Kills a process that has more than one task manager entry. This test is the
 426 // same as KillPanelViaExtensionResource except it does the kill via the other
 427 // entry.
 428 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, KillPanelViaPanelResource) {
 429   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("good")
 430                                 .AppendASCII("Extensions")
 431                                 .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
 432                                 .AppendASCII("1.0.0.0")));
 433
 434   // Open a new panel to an extension url.
 435   GURL url(
 436       "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 437       "french_sentence.html");
 438   PanelManager::GetInstance()->CreatePanel(
 439       web_app::GenerateApplicationNameFromExtensionId(
 440           last_loaded_extension_id()),
 441       browser()->profile(),
 442       url,
 443       gfx::Rect(300, 400),
 444       PanelManager::CREATE_AS_DOCKED);
 445
 446   ShowTaskManager();
 447   ASSERT_NO_FATAL_FAILURE(
 448       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 449   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(
 450       1,
 451       MatchExtension(
 452           "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 453           "french_sentence.html")));
 454   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyExtension()));
 455   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 456   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 457
 458   int background_page = FindResourceIndex(MatchExtension("My extension 1"));
 459   ASSERT_NE(-1, background_page);
 460   ASSERT_TRUE(model()->GetResourceWebContents(background_page) == NULL);
 461   ASSERT_FALSE(model()->CanActivate(background_page));
 462
 463   // Kill the process via the PANEL RESOURCE (not the background page). Verify
 464   // that both the background page and the panel go away from the task manager.
 465   int panel = FindResourceIndex(MatchExtension(
 466       "chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/"
 467       "french_sentence.html"));
 468   ASSERT_NE(-1, panel);
 469   ASSERT_TRUE(model()->GetResourceWebContents(panel) != NULL);
 470   ASSERT_TRUE(model()->CanActivate(panel));
 471   TaskManager::GetInstance()->KillProcess(panel);
 472   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 473   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 474 }
 475
 476 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticeExtensionTabChanges) {
 477   ShowTaskManager();
 478   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 479   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 480
 481   ASSERT_TRUE(LoadExtension(
 482       test_data_dir_.AppendASCII("good").AppendASCII("Extensions")
 483                     .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
 484                     .AppendASCII("1.0.0.0")));
 485
 486   // Browser, Extension background page, and the New Tab Page.
 487   ASSERT_NO_FATAL_FAILURE(
 488       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 489   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyExtension()));
 490   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 491
 492   // Open a new tab to an extension URL. Afterwards, the third entry (background
 493   // page) should be an extension resource whose title starts with "Extension:".
 494   // The fourth entry (page.html) is also of type extension and has both a
 495   // WebContents and an extension. The title should start with "Extension:".
 496   GURL url("chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/page.html");
 497   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_TYPED);
 498   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchExtension("Foobar")));
 499   ASSERT_NO_FATAL_FAILURE(
 500       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 501   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyExtension()));
 502   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 503   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 504
 505   int extension_tab = FindResourceIndex(MatchExtension("Foobar"));
 506   ASSERT_NE(-1, extension_tab);
 507   ASSERT_TRUE(model()->GetResourceWebContents(extension_tab) != NULL);
 508   ASSERT_TRUE(model()->CanActivate(extension_tab));
 509
 510   int background_page = FindResourceIndex(MatchExtension("My extension 1"));
 511   ASSERT_NE(-1, background_page);
 512   ASSERT_TRUE(model()->GetResourceWebContents(background_page) == NULL);
 513   ASSERT_FALSE(model()->CanActivate(background_page));
 514 }
 515
 516 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticeExtensionTab) {
 517   // With the task manager closed, open a new tab to an extension URL.
 518   // Afterwards, when we open the task manager, the third entry (background
 519   // page) should be an extension resource whose title starts with "Extension:".
 520   // The fourth entry (page.html) is also of type extension and has both a
 521   // WebContents and an extension. The title should start with "Extension:".
 522   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("good")
 523                                 .AppendASCII("Extensions")
 524                                 .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
 525                                 .AppendASCII("1.0.0.0")));
 526   GURL url("chrome-extension://behllobkkfkfnphdnhnkndlbkcpglgmj/page.html");
 527   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_TYPED);
 528
 529   ShowTaskManager();
 530   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchExtension("Foobar")));
 531   ASSERT_NO_FATAL_FAILURE(
 532       WaitForTaskManagerRows(1, MatchExtension("My extension 1")));
 533   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyExtension()));
 534   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 535   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 536
 537   int extension_tab = FindResourceIndex(MatchExtension("Foobar"));
 538   ASSERT_NE(-1, extension_tab);
 539   ASSERT_TRUE(model()->GetResourceWebContents(extension_tab) != NULL);
 540   ASSERT_TRUE(model()->CanActivate(extension_tab));
 541
 542   int background_page = FindResourceIndex(MatchExtension("My extension 1"));
 543   ASSERT_NE(-1, background_page);
 544   ASSERT_TRUE(model()->GetResourceWebContents(background_page) == NULL);
 545   ASSERT_FALSE(model()->CanActivate(background_page));
 546 }
 547
 548 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticeAppTabChanges) {
 549   ShowTaskManager();
 550
 551   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("packaged_app")));
 552   ExtensionService* service = extensions::ExtensionSystem::Get(
 553                                   browser()->profile())->extension_service();
 554   const extensions::Extension* extension =
 555       service->GetExtensionById(last_loaded_extension_id(), false);
 556
 557   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 558   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 559   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 560   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyApp()));
 561
 562   // Open a new tab to the app's launch URL and make sure we notice that.
 563   GURL url(extension->GetResourceURL("main.html"));
 564   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_TYPED);
 565
 566   // There should be 1 "App: " tab and the original new tab page.
 567   ASSERT_NO_FATAL_FAILURE(
 568       WaitForTaskManagerRows(1, MatchApp("Packaged App Test")));
 569   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyApp()));
 570   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 571   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 572   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 573
 574   // Check that the third entry (main.html) is of type extension and has both
 575   // a tab contents and an extension.
 576   int app_tab = FindResourceIndex(MatchApp("Packaged App Test"));
 577   ASSERT_NE(-1, app_tab);
 578   ASSERT_TRUE(model()->GetResourceWebContents(app_tab) != NULL);
 579   ASSERT_TRUE(model()->CanActivate(app_tab));
 580   ASSERT_EQ(task_manager::Resource::EXTENSION,
 581             model()->GetResourceType(app_tab));
 582   ASSERT_EQ(2, browser()->tab_strip_model()->count());
 583
 584   // Unload extension to make sure the tab goes away.
 585   UnloadExtension(last_loaded_extension_id());
 586
 587   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 588   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyApp()));
 589   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 590   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 591   ASSERT_EQ(1, browser()->tab_strip_model()->count());
 592 }
 593
 594 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticeAppTab) {
 595   ASSERT_TRUE(LoadExtension(
 596       test_data_dir_.AppendASCII("packaged_app")));
 597   ExtensionService* service = extensions::ExtensionSystem::Get(
 598       browser()->profile())->extension_service();
 599   const extensions::Extension* extension =
 600       service->GetExtensionById(last_loaded_extension_id(), false);
 601
 602   // Open a new tab to the app's launch URL and make sure we notice that.
 603   GURL url(extension->GetResourceURL("main.html"));
 604   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_TYPED);
 605
 606   ShowTaskManager();
 607
 608   ASSERT_NO_FATAL_FAILURE(
 609       WaitForTaskManagerRows(1, MatchApp("Packaged App Test")));
 610   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 611   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 612   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyApp()));
 613
 614   // Check that the third entry (main.html) is of type extension and has both
 615   // a tab contents and an extension.
 616   int app_tab = FindResourceIndex(MatchApp("Packaged App Test"));
 617   ASSERT_NE(-1, app_tab);
 618   ASSERT_TRUE(model()->GetResourceWebContents(app_tab) != NULL);
 619   ASSERT_TRUE(model()->CanActivate(app_tab));
 620   ASSERT_EQ(task_manager::Resource::EXTENSION,
 621             model()->GetResourceType(app_tab));
 622 }
 623
 624 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticeHostedAppTabChanges) {
 625   ShowTaskManager();
 626
 627   // The app under test acts on URLs whose host is "localhost",
 628   // so the URLs we navigate to must have host "localhost".
 629   host_resolver()->AddRule("*", "127.0.0.1");
 630   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 631   GURL::Replacements replace_host;
 632   replace_host.SetHostStr("localhost");
 633   GURL base_url = embedded_test_server()->GetURL(
 634       "/extensions/api_test/app_process/");
 635   base_url = base_url.ReplaceComponents(replace_host);
 636
 637   // Open a new tab to an app URL before the app is loaded.
 638   GURL url(base_url.Resolve("path1/empty.html"));
 639   content::WindowedNotificationObserver observer(
 640       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 641       content::NotificationService::AllSources());
 642   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_TYPED);
 643   observer.Wait();
 644
 645   // Check that the new entry's title starts with "Tab:".
 646   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 647
 648   // Load the hosted app and make sure it still starts with "Tab:",
 649   // since it hasn't changed to an app process yet.
 650   ASSERT_TRUE(LoadExtension(
 651       test_data_dir_.AppendASCII("api_test").AppendASCII("app_process")));
 652   // Force the TaskManager to query the title.
 653   Refresh();
 654   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 655   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 656   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("Unmodified")));
 657   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 658
 659   // Now reload and check that the last entry's title now starts with "App:".
 660   ui_test_utils::NavigateToURL(browser(), url);
 661
 662   // Force the TaskManager to query the title.
 663   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 664   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 665   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyApp()));
 666   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchApp("Unmodified")));
 667   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 668
 669   // Disable extension.
 670   DisableExtension(last_loaded_extension_id());
 671
 672   // The hosted app should now show up as a normal "Tab: ".
 673   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 674   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 675   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("Unmodified")));
 676   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 677   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyApp()));
 678
 679   // Reload the page.
 680   ui_test_utils::NavigateToURL(browser(), url);
 681
 682   // No change expected.
 683   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 684   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab()));
 685   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("Unmodified")));
 686   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 687   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyApp()));
 688 }
 689
 690 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticeHostedAppTabAfterReload) {
 691   // The app under test acts on URLs whose host is "localhost",
 692   // so the URLs we navigate to must have host "localhost".
 693   host_resolver()->AddRule("*", "127.0.0.1");
 694   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 695   GURL::Replacements replace_host;
 696   replace_host.SetHostStr("localhost");
 697   GURL base_url =
 698       embedded_test_server()->GetURL("/extensions/api_test/app_process/");
 699   base_url = base_url.ReplaceComponents(replace_host);
 700
 701   // Open a new tab to an app URL before the app is loaded.
 702   GURL url(base_url.Resolve("path1/empty.html"));
 703   content::WindowedNotificationObserver observer(
 704       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 705       content::NotificationService::AllSources());
 706   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_TYPED);
 707   observer.Wait();
 708
 709   // Load the hosted app and make sure it still starts with "Tab:",
 710   // since it hasn't changed to an app process yet.
 711   ASSERT_TRUE(LoadExtension(
 712       test_data_dir_.AppendASCII("api_test").AppendASCII("app_process")));
 713
 714   // Now reload, which should transition this tab to being an App.
 715   ui_test_utils::NavigateToURL(browser(), url);
 716
 717   ShowTaskManager();
 718
 719   // The TaskManager should show this as an "App: "
 720   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 721   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyApp()));
 722   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 723 }
 724
 725 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, NoticeHostedAppTabBeforeReload) {
 726   // The app under test acts on URLs whose host is "localhost",
 727   // so the URLs we navigate to must have host "localhost".
 728   host_resolver()->AddRule("*", "127.0.0.1");
 729   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 730   GURL::Replacements replace_host;
 731   replace_host.SetHostStr("localhost");
 732   GURL base_url =
 733       embedded_test_server()->GetURL("/extensions/api_test/app_process/");
 734   base_url = base_url.ReplaceComponents(replace_host);
 735
 736   // Open a new tab to an app URL before the app is loaded.
 737   GURL url(base_url.Resolve("path1/empty.html"));
 738   content::WindowedNotificationObserver observer(
 739       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
 740       content::NotificationService::AllSources());
 741   AddTabAtIndex(0, url, ui::PAGE_TRANSITION_TYPED);
 742   observer.Wait();
 743
 744   // Load the hosted app and make sure it still starts with "Tab:",
 745   // since it hasn't changed to an app process yet.
 746   ASSERT_TRUE(LoadExtension(
 747       test_data_dir_.AppendASCII("api_test").AppendASCII("app_process")));
 748
 749   ShowTaskManager();
 750
 751   // The TaskManager should show this as a "Tab: " because the page hasn't been
 752   // reloaded since the hosted app was installed.
 753   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 754   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyApp()));
 755   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnyExtension()));
 756 }
 757
 758 // Regression test for http://crbug.com/18693.
 759 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, ReloadExtension) {
 760   ShowTaskManager();
 761   ASSERT_TRUE(LoadExtension(
 762       test_data_dir_.AppendASCII("common").AppendASCII("background_page")));
 763
 764   // Wait until we see the loaded extension in the task manager (the three
 765   // resources are: the browser process, New Tab Page, and the extension).
 766   ASSERT_NO_FATAL_FAILURE(
 767       WaitForTaskManagerRows(1, MatchExtension("background_page")));
 768
 769   // Reload the extension a few times and make sure our resource count doesn't
 770   // increase.
 771   std::string extension_id = last_loaded_extension_id();
 772   for (int i = 1; i <= 5; i++) {
 773     SCOPED_TRACE(testing::Message() << "Reloading extension for the " << i
 774                                     << "th time.");
 775     ReloadExtension(extension_id);
 776     ASSERT_NO_FATAL_FAILURE(
 777         WaitForTaskManagerRows(1, MatchExtension("background_page")));
 778   }
 779 }
 780
 781 // Crashy, http://crbug.com/42301.
 782 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest,
 783                        DISABLED_PopulateWebCacheFields) {
 784   ShowTaskManager();
 785   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 786
 787   int resource_count = TaskManager::GetInstance()->model()->ResourceCount();
 788
 789   // Open a new tab and make sure we notice that.
 790   AddTabAtIndex(0, GetTestURL(), ui::PAGE_TRANSITION_TYPED);
 791   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 792
 793   // Check that we get some value for the cache columns.
 794   DCHECK_NE(model()->GetResourceWebCoreImageCacheSize(resource_count),
 795             l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT));
 796   DCHECK_NE(model()->GetResourceWebCoreScriptsCacheSize(resource_count),
 797             l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT));
 798   DCHECK_NE(model()->GetResourceWebCoreCSSCacheSize(resource_count),
 799             l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT));
 800 }
 801
 802 // Checks that task manager counts a worker thread JS heap size.
 803 // http://crbug.com/241066
 804 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, WebWorkerJSHeapMemory) {
 805   ShowTaskManager();
 806   ui_test_utils::NavigateToURL(browser(), GetTestURL());
 807   size_t minimal_heap_size = 4 * 1024 * 1024 * sizeof(void*);
 808   std::string test_js = base::StringPrintf(
 809       "var blob = new Blob([\n"
 810       "    'mem = new Array(%lu);',\n"
 811       "    'for (var i = 0; i < mem.length; i += 16)',"
 812       "    '  mem[i] = i;',\n"
 813       "    'postMessage(\"okay\");']);\n"
 814       "blobURL = window.URL.createObjectURL(blob);\n"
 815       "var worker = new Worker(blobURL);\n"
 816       "worker.addEventListener('message', function(e) {\n"
 817       "  window.domAutomationController.send(e.data);\n"  // e.data == "okay"
 818       "});\n"
 819       "worker.postMessage('go');\n",
 820       static_cast<unsigned long>(minimal_heap_size));
 821   std::string ok;
 822   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 823       browser()->tab_strip_model()->GetActiveWebContents(), test_js, &ok));
 824   ASSERT_EQ("okay", ok);
 825
 826   // The worker has allocated objects of at least |minimal_heap_size| bytes.
 827   // Wait for the heap stats to reflect this.
 828   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerStatToExceed(
 829       MatchTab("title1.html"), task_manager::browsertest_util::V8_MEMORY,
 830       minimal_heap_size));
 831   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerStatToExceed(
 832       MatchTab("title1.html"), task_manager::browsertest_util::V8_MEMORY_USED,
 833       minimal_heap_size));
 834   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 835   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("title1.html")));
 836 }
 837
 838 // Checks that task manager counts renderer JS heap size.
 839 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, JSHeapMemory) {
 840   ShowTaskManager();
 841   ui_test_utils::NavigateToURL(browser(), GetTestURL());
 842   size_t minimal_heap_size = 4 * 1024 * 1024 * sizeof(void*);
 843   std::string test_js = base::StringPrintf(
 844       "mem = new Array(%lu);\n"
 845       "for (var i = 0; i < mem.length; i += 16)\n"
 846       "  mem[i] = i;\n"
 847       "window.domAutomationController.send(\"okay\");\n",
 848       static_cast<unsigned long>(minimal_heap_size));
 849   std::string ok;
 850   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
 851       browser()->tab_strip_model()->GetActiveWebContents(), test_js, &ok));
 852   ASSERT_EQ("okay", ok);
 853
 854   // The page's js has allocated objects of at least |minimal_heap_size| bytes.
 855   // Wait for the heap stats to reflect this.
 856   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerStatToExceed(
 857       MatchTab("title1.html"), task_manager::browsertest_util::V8_MEMORY,
 858       minimal_heap_size));
 859   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerStatToExceed(
 860       MatchTab("title1.html"), task_manager::browsertest_util::V8_MEMORY_USED,
 861       minimal_heap_size));
 862   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 863   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("title1.html")));
 864 }
 865
 866 // Checks that task manager counts utility process JS heap size.
 867 IN_PROC_BROWSER_TEST_F(TaskManagerUtilityProcessBrowserTest,
 868                        UtilityJSHeapMemory) {
 869   ShowTaskManager();
 870   ui_test_utils::NavigateToURL(browser(), GetTestURL());
 871   // The PAC script is trivial, so don't expect a large heap.
 872   size_t minimal_heap_size = 1024;
 873   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerStatToExceed(
 874       MatchUtility(
 875           l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME)),
 876       task_manager::browsertest_util::V8_MEMORY,
 877       minimal_heap_size));
 878   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerStatToExceed(
 879       MatchUtility(
 880           l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME)),
 881       task_manager::browsertest_util::V8_MEMORY_USED,
 882       minimal_heap_size));
 883   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyUtility()));
 884   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(
 885       1, MatchUtility(l10n_util::GetStringUTF16(
 886           IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME))));
 887 }
 888
 889 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, DevToolsNewDockedWindow) {
 890   ShowTaskManager();  // Task manager shown BEFORE dev tools window.
 891
 892   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 893   DevToolsWindow* devtools =
 894       DevToolsWindowTesting::OpenDevToolsWindowSync(browser(), true);
 895   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 896   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 897   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
 898 }
 899
 900 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, DevToolsNewUndockedWindow) {
 901   ShowTaskManager();  // Task manager shown BEFORE dev tools window.
 902   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 903   DevToolsWindow* devtools =
 904       DevToolsWindowTesting::OpenDevToolsWindowSync(browser(), false);
 905   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(3, MatchAnyTab()));
 906   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(3, MatchAnyTab()));
 907   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
 908 }
 909
 910 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, DevToolsOldDockedWindow) {
 911   DevToolsWindow* devtools =
 912       DevToolsWindowTesting::OpenDevToolsWindowSync(browser(), true);
 913   ShowTaskManager();  // Task manager shown AFTER dev tools window.
 914   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 915   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnyTab()));
 916   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
 917 }
 918
 919 IN_PROC_BROWSER_TEST_F(TaskManagerBrowserTest, DevToolsOldUnockedWindow) {
 920   DevToolsWindow* devtools =
 921       DevToolsWindowTesting::OpenDevToolsWindowSync(browser(), false);
 922   ShowTaskManager();  // Task manager shown AFTER dev tools window.
 923   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(3, MatchAnyTab()));
 924   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(3, MatchAnyTab()));
 925   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
 926 }
 927
 928 IN_PROC_BROWSER_TEST_P(TaskManagerOOPIFBrowserTest, KillSubframe) {
 929   ShowTaskManager();
 930
 931   host_resolver()->AddRule("*", "127.0.0.1");
 932   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 933   content::SetupCrossSiteRedirector(embedded_test_server());
 934
 935   GURL main_url(embedded_test_server()->GetURL(
 936       "/cross-site/a.com/iframe_cross_site.html"));
 937   browser()->OpenURL(content::OpenURLParams(main_url, content::Referrer(),
 938                                             CURRENT_TAB,
 939                                             ui::PAGE_TRANSITION_TYPED, false));
 940
 941   ASSERT_NO_FATAL_FAILURE(
 942       WaitForTaskManagerRows(1, MatchTab("cross-site iframe test")));
 943   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
 944
 945   if (!ShouldExpectSubframes()) {
 946     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
 947   } else {
 948     ASSERT_NO_FATAL_FAILURE(
 949         WaitForTaskManagerRows(1, MatchSubframe("http://b.com/")));
 950     ASSERT_NO_FATAL_FAILURE(
 951         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
 952     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnySubframe()));
 953     int subframe_b = FindResourceIndex(MatchSubframe("http://b.com/"));
 954     ASSERT_NE(-1, subframe_b);
 955     ASSERT_TRUE(model()->GetResourceWebContents(subframe_b) != NULL);
 956     ASSERT_TRUE(model()->CanActivate(subframe_b));
 957
 958     TaskManager::GetInstance()->KillProcess(subframe_b);
 959
 960     ASSERT_NO_FATAL_FAILURE(
 961         WaitForTaskManagerRows(0, MatchSubframe("http://b.com/")));
 962     ASSERT_NO_FATAL_FAILURE(
 963         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
 964     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnySubframe()));
 965     ASSERT_NO_FATAL_FAILURE(
 966         WaitForTaskManagerRows(1, MatchTab("cross-site iframe test")));
 967   }
 968
 969   HideTaskManager();
 970   ShowTaskManager();
 971
 972   if (!ShouldExpectSubframes()) {
 973     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
 974   } else {
 975     ASSERT_NO_FATAL_FAILURE(
 976         WaitForTaskManagerRows(0, MatchSubframe("http://b.com/")));
 977     ASSERT_NO_FATAL_FAILURE(
 978         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
 979     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnySubframe()));
 980     ASSERT_NO_FATAL_FAILURE(
 981         WaitForTaskManagerRows(1, MatchTab("cross-site iframe test")));
 982   }
 983 }
 984
 985 // Tests what happens when a tab navigates to a site (a.com) that it previously
 986 // has a cross-process subframe into (b.com).
 987 //
 988 // TODO(nick): http://crbug.com/442532. Disabled because the second navigation
 989 // hits an ASSERT(frame()) in WebLocalFrameImpl::loadRequest under --site-per-
 990 // process.
 991 IN_PROC_BROWSER_TEST_P(TaskManagerOOPIFBrowserTest,
 992                        DISABLED_NavigateToSubframeProcess) {
 993   ShowTaskManager();
 994
 995   host_resolver()->AddRule("*", "127.0.0.1");
 996   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 997   content::SetupCrossSiteRedirector(embedded_test_server());
 998
 999   // Navigate the tab to a page on a.com with cross-process subframes to
1000   // b.com and c.com.
1001   GURL a_dotcom(embedded_test_server()->GetURL(
1002       "/cross-site/a.com/iframe_cross_site.html"));
1003   browser()->OpenURL(content::OpenURLParams(a_dotcom, content::Referrer(),
1004                                             CURRENT_TAB,
1005                                             ui::PAGE_TRANSITION_TYPED, false));
1006
1007   ASSERT_NO_FATAL_FAILURE(
1008       WaitForTaskManagerRows(1, MatchTab("cross-site iframe test")));
1009   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1010
1011   if (!ShouldExpectSubframes()) {
1012     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1013   } else {
1014     ASSERT_NO_FATAL_FAILURE(
1015         WaitForTaskManagerRows(1, MatchSubframe("http://b.com/")));
1016     ASSERT_NO_FATAL_FAILURE(
1017         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
1018     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnySubframe()));
1019   }
1020
1021   // Now navigate to a page on b.com with a simple (same-site) iframe.
1022   // This should not show any subframe resources in the task manager.
1023   GURL b_dotcom(
1024       embedded_test_server()->GetURL("/cross-site/b.com/iframe.html"));
1025
1026   browser()->OpenURL(content::OpenURLParams(b_dotcom, content::Referrer(),
1027                                             CURRENT_TAB,
1028                                             ui::PAGE_TRANSITION_TYPED, false));
1029
1030   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("iframe test")));
1031   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1032   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1033   HideTaskManager();
1034   ShowTaskManager();
1035   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("iframe test")));
1036   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1037   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1038 }
1039
1040 // TODO(nick): Fails flakily under OOPIF due to a ASSERT_NOT_REACHED in
1041 // WebRemoteFrame, at least under debug OSX. http://crbug.com/437956
1042 IN_PROC_BROWSER_TEST_P(TaskManagerOOPIFBrowserTest,
1043                        DISABLED_NavigateToSiteWithSubframeToOriginalSite) {
1044   ShowTaskManager();
1045
1046   host_resolver()->AddRule("*", "127.0.0.1");
1047   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
1048   content::SetupCrossSiteRedirector(embedded_test_server());
1049
1050   // Navigate to a page on b.com with a simple (same-site) iframe.
1051   // This should not show any subframe resources in the task manager.
1052   GURL b_dotcom(
1053       embedded_test_server()->GetURL("/cross-site/b.com/iframe.html"));
1054
1055   browser()->OpenURL(content::OpenURLParams(b_dotcom, content::Referrer(),
1056                                             CURRENT_TAB,
1057                                             ui::PAGE_TRANSITION_TYPED, false));
1058
1059   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("iframe test")));
1060   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1061   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1062
1063   // Now navigate the tab to a page on a.com with cross-process subframes to
1064   // b.com and c.com.
1065   GURL a_dotcom(embedded_test_server()->GetURL(
1066       "/cross-site/a.com/iframe_cross_site.html"));
1067   browser()->OpenURL(content::OpenURLParams(a_dotcom, content::Referrer(),
1068                                             CURRENT_TAB,
1069                                             ui::PAGE_TRANSITION_TYPED, false));
1070
1071   ASSERT_NO_FATAL_FAILURE(
1072       WaitForTaskManagerRows(1, MatchTab("cross-site iframe test")));
1073   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1074
1075   if (!ShouldExpectSubframes()) {
1076     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1077   } else {
1078     ASSERT_NO_FATAL_FAILURE(
1079         WaitForTaskManagerRows(1, MatchSubframe("http://b.com/")));
1080     ASSERT_NO_FATAL_FAILURE(
1081         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
1082     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnySubframe()));
1083   }
1084
1085   HideTaskManager();
1086   ShowTaskManager();
1087
1088   if (!ShouldExpectSubframes()) {
1089     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1090   } else {
1091     ASSERT_NO_FATAL_FAILURE(
1092         WaitForTaskManagerRows(1, MatchSubframe("http://b.com/")));
1093     ASSERT_NO_FATAL_FAILURE(
1094         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
1095     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnySubframe()));
1096   }
1097 }
1098
1099 // Tests what happens when a tab navigates a cross-frame iframe (to b.com)
1100 // back to the site of the parent document (a.com).
1101 IN_PROC_BROWSER_TEST_P(TaskManagerOOPIFBrowserTest,
1102                        CrossSiteIframeBecomesSameSite) {
1103   ShowTaskManager();
1104
1105   host_resolver()->AddRule("*", "127.0.0.1");
1106   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
1107   content::SetupCrossSiteRedirector(embedded_test_server());
1108
1109   // Navigate the tab to a page on a.com with cross-process subframes to
1110   // b.com and c.com.
1111   GURL a_dotcom(embedded_test_server()->GetURL(
1112       "/cross-site/a.com/iframe_cross_site.html"));
1113   browser()->OpenURL(content::OpenURLParams(a_dotcom, content::Referrer(),
1114                                             CURRENT_TAB,
1115                                             ui::PAGE_TRANSITION_TYPED, false));
1116
1117   ASSERT_NO_FATAL_FAILURE(
1118       WaitForTaskManagerRows(1, MatchTab("cross-site iframe test")));
1119   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1120
1121   if (!ShouldExpectSubframes()) {
1122     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1123   } else {
1124     ASSERT_NO_FATAL_FAILURE(
1125         WaitForTaskManagerRows(1, MatchSubframe("http://b.com/")));
1126     ASSERT_NO_FATAL_FAILURE(
1127         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
1128     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnySubframe()));
1129   }
1130
1131   // Navigate the b.com frame back to a.com. It is no longer a cross-site iframe
1132   ASSERT_TRUE(content::ExecuteScript(
1133       browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame(),
1134       "document.getElementById('frame1').src='/title1.html';"
1135       "document.title='aac';"));
1136   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("aac")));
1137   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1138   if (!ShouldExpectSubframes()) {
1139     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1140   } else {
1141     ASSERT_NO_FATAL_FAILURE(
1142         WaitForTaskManagerRows(0, MatchSubframe("http://b.com/")));
1143     ASSERT_NO_FATAL_FAILURE(
1144         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
1145     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnySubframe()));
1146   }
1147   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("aac")));
1148   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1149
1150   HideTaskManager();
1151   ShowTaskManager();
1152
1153   if (!ShouldExpectSubframes()) {
1154     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1155   } else {
1156     ASSERT_NO_FATAL_FAILURE(
1157         WaitForTaskManagerRows(0, MatchSubframe("http://b.com/")));
1158     ASSERT_NO_FATAL_FAILURE(
1159         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
1160     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnySubframe()));
1161   }
1162   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchTab("aac")));
1163   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1164 }
1165
1166 // Tests what happens when a tab does a same-site navigation away from a page
1167 // with cross-site iframes.
1168 IN_PROC_BROWSER_TEST_P(TaskManagerOOPIFBrowserTest,
1169                        LeavePageWithCrossSiteIframes) {
1170   ShowTaskManager();
1171
1172   host_resolver()->AddRule("*", "127.0.0.1");
1173   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
1174   content::SetupCrossSiteRedirector(embedded_test_server());
1175
1176   // Navigate the tab to a page on a.com with cross-process subframes.
1177   GURL a_dotcom_with_iframes(embedded_test_server()->GetURL(
1178       "/cross-site/a.com/iframe_cross_site.html"));
1179   browser()->OpenURL(content::OpenURLParams(a_dotcom_with_iframes,
1180                                             content::Referrer(), CURRENT_TAB,
1181                                             ui::PAGE_TRANSITION_TYPED, false));
1182
1183   ASSERT_NO_FATAL_FAILURE(
1184       WaitForTaskManagerRows(1, MatchTab("cross-site iframe test")));
1185   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab()));
1186
1187   if (!ShouldExpectSubframes()) {
1188     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1189   } else {
1190     ASSERT_NO_FATAL_FAILURE(
1191         WaitForTaskManagerRows(1, MatchSubframe("http://b.com/")));
1192     ASSERT_NO_FATAL_FAILURE(
1193         WaitForTaskManagerRows(1, MatchSubframe("http://c.com/")));
1194     ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(2, MatchAnySubframe()));
1195   }
1196
1197   // Navigate the tab to a page on a.com without cross-process subframes, and
1198   // the subframe processes should disappear.
1199   GURL a_dotcom_simple(
1200       embedded_test_server()->GetURL("/cross-site/a.com/title2.html"));
1201   browser()->OpenURL(content::OpenURLParams(a_dotcom_simple,
1202                                             content::Referrer(), CURRENT_TAB,
1203                                             ui::PAGE_TRANSITION_TYPED, false));
1204   ASSERT_NO_FATAL_FAILURE(
1205       WaitForTaskManagerRows(1, MatchTab("Title Of Awesomeness")));
1206   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1207
1208   HideTaskManager();
1209   ShowTaskManager();
1210
1211   ASSERT_NO_FATAL_FAILURE(
1212       WaitForTaskManagerRows(1, MatchTab("Title Of Awesomeness")));
1213   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, MatchAnySubframe()));
1214 }