chrome/browser/extensions/app_process_apitest.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/extensions/extension_apitest.h"
   8 #include "chrome/browser/extensions/extension_host.h"
   9 #include "chrome/browser/extensions/extension_service.h"
  10 #include "chrome/browser/extensions/extension_system.h"
  11 #include "chrome/browser/profiles/profile.h"
  12 #include "chrome/browser/ui/blocked_content/popup_blocker_tab_helper.h"
  13 #include "chrome/browser/ui/browser.h"
  14 #include "chrome/browser/ui/browser_commands.h"
  15 #include "chrome/browser/ui/browser_finder.h"
  16 #include "chrome/browser/ui/browser_list.h"
  17 #include "chrome/browser/ui/browser_window.h"
  18 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  19 #include "chrome/common/chrome_switches.h"
  20 #include "chrome/common/extensions/extension_file_util.h"
  21 #include "chrome/test/base/test_switches.h"
  22 #include "chrome/test/base/ui_test_utils.h"
  23 #include "content/public/browser/navigation_entry.h"
  24 #include "content/public/browser/notification_service.h"
  25 #include "content/public/browser/render_process_host.h"
  26 #include "content/public/browser/render_view_host.h"
  27 #include "content/public/browser/site_instance.h"
  28 #include "content/public/browser/web_contents.h"
  29 #include "content/public/test/browser_test_utils.h"
  30 #include "content/public/test/test_navigation_observer.h"
  31 #include "extensions/browser/process_map.h"
  32 #include "extensions/common/extension.h"
  33 #include "extensions/common/switches.h"
  34 #include "net/dns/mock_host_resolver.h"
  35 #include "net/test/embedded_test_server/embedded_test_server.h"
  36 #include "sync/api/string_ordinal.h"
  37
  38 using content::NavigationController;
  39 using content::RenderViewHost;
  40 using content::SiteInstance;
  41 using content::WebContents;
  42 using extensions::Extension;
  43
  44 class AppApiTest : public ExtensionApiTest {
  45  protected:
  46   // Gets the base URL for files for a specific test, making sure that it uses
  47   // "localhost" as the hostname, since that is what the extent is declared
  48   // as in the test apps manifests.
  49   GURL GetTestBaseURL(std::string test_directory) {
  50     GURL::Replacements replace_host;
  51     std::string host_str("localhost");  // must stay in scope with replace_host
  52     replace_host.SetHostStr(host_str);
  53     GURL base_url = embedded_test_server()->GetURL(
  54         "/extensions/api_test/" + test_directory + "/");
  55     return base_url.ReplaceComponents(replace_host);
  56   }
  57
  58   // Pass flags to make testing apps easier.
  59   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  60     ExtensionApiTest::SetUpCommandLine(command_line);
  61     CommandLine::ForCurrentProcess()->AppendSwitch(
  62         switches::kDisablePopupBlocking);
  63     CommandLine::ForCurrentProcess()->AppendSwitch(
  64         extensions::switches::kAllowHTTPBackgroundPage);
  65   }
  66
  67   // Helper function to test that independent tabs of the named app are loaded
  68   // into separate processes.
  69   void TestAppInstancesHelper(std::string app_name) {
  70     LOG(INFO) << "Start of test.";
  71
  72     extensions::ProcessMap* process_map =
  73         extensions::ProcessMap::Get(browser()->profile());
  74
  75     host_resolver()->AddRule("*", "127.0.0.1");
  76     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
  77
  78     ASSERT_TRUE(LoadExtension(
  79         test_data_dir_.AppendASCII(app_name)));
  80     const Extension* extension = GetSingleLoadedExtension();
  81
  82     // Open two tabs in the app, one outside it.
  83     GURL base_url = GetTestBaseURL(app_name);
  84
  85     // Test both opening a URL in a new tab, and opening a tab and then
  86     // navigating it.  Either way, app tabs should be considered extension
  87     // processes, but they have no elevated privileges and thus should not
  88     // have WebUI bindings.
  89     ui_test_utils::NavigateToURLWithDisposition(
  90         browser(), base_url.Resolve("path1/empty.html"), NEW_FOREGROUND_TAB,
  91         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
  92     LOG(INFO) << "Nav 1.";
  93     EXPECT_TRUE(process_map->Contains(
  94         browser()->tab_strip_model()->GetWebContentsAt(1)->
  95             GetRenderProcessHost()->GetID()));
  96     EXPECT_FALSE(browser()->tab_strip_model()->GetWebContentsAt(1)->GetWebUI());
  97
  98     content::WindowedNotificationObserver tab_added_observer(
  99         chrome::NOTIFICATION_TAB_ADDED,
 100         content::NotificationService::AllSources());
 101     chrome::NewTab(browser());
 102     tab_added_observer.Wait();
 103     LOG(INFO) << "New tab.";
 104     ui_test_utils::NavigateToURL(browser(),
 105                                  base_url.Resolve("path2/empty.html"));
 106     LOG(INFO) << "Nav 2.";
 107     EXPECT_TRUE(process_map->Contains(
 108         browser()->tab_strip_model()->GetWebContentsAt(2)->
 109             GetRenderProcessHost()->GetID()));
 110     EXPECT_FALSE(browser()->tab_strip_model()->GetWebContentsAt(2)->GetWebUI());
 111
 112     // We should have opened 2 new extension tabs. Including the original blank
 113     // tab, we now have 3 tabs. The two app tabs should not be in the same
 114     // process, since they do not have the background permission.  (Thus, we
 115     // want to separate them to improve responsiveness.)
 116     ASSERT_EQ(3, browser()->tab_strip_model()->count());
 117     WebContents* tab1 = browser()->tab_strip_model()->GetWebContentsAt(1);
 118     WebContents* tab2 = browser()->tab_strip_model()->GetWebContentsAt(2);
 119     EXPECT_NE(tab1->GetRenderProcessHost(), tab2->GetRenderProcessHost());
 120
 121     // Opening tabs with window.open should keep the page in the opener's
 122     // process.
 123     ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 124                                           browser()->host_desktop_type()));
 125     OpenWindow(tab1, base_url.Resolve("path1/empty.html"), true, NULL);
 126     LOG(INFO) << "WindowOpenHelper 1.";
 127     OpenWindow(tab2, base_url.Resolve("path2/empty.html"), true, NULL);
 128     LOG(INFO) << "End of test.";
 129     UnloadExtension(extension->id());
 130   }
 131 };
 132
 133 // Omits the disable-popup-blocking flag so we can cover that case.
 134 class BlockedAppApiTest : public AppApiTest {
 135  protected:
 136   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 137     ExtensionApiTest::SetUpCommandLine(command_line);
 138     CommandLine::ForCurrentProcess()->AppendSwitch(
 139         extensions::switches::kAllowHTTPBackgroundPage);
 140   }
 141 };
 142
 143 // Tests that hosted apps with the background permission get a process-per-app
 144 // model, since all pages need to be able to script the background page.
 145 // http://crbug.com/172750
 146 IN_PROC_BROWSER_TEST_F(AppApiTest, DISABLED_AppProcess) {
 147   LOG(INFO) << "Start of test.";
 148
 149   extensions::ProcessMap* process_map =
 150       extensions::ProcessMap::Get(browser()->profile());
 151
 152   host_resolver()->AddRule("*", "127.0.0.1");
 153   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 154
 155   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("app_process")));
 156
 157   LOG(INFO) << "Loaded extension.";
 158
 159   // Open two tabs in the app, one outside it.
 160   GURL base_url = GetTestBaseURL("app_process");
 161
 162   // Test both opening a URL in a new tab, and opening a tab and then navigating
 163   // it.  Either way, app tabs should be considered extension processes, but
 164   // they have no elevated privileges and thus should not have WebUI bindings.
 165   ui_test_utils::NavigateToURLWithDisposition(
 166       browser(), base_url.Resolve("path1/empty.html"), NEW_FOREGROUND_TAB,
 167       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 168   EXPECT_TRUE(process_map->Contains(
 169       browser()->tab_strip_model()->GetWebContentsAt(1)->
 170           GetRenderProcessHost()->GetID()));
 171   EXPECT_FALSE(browser()->tab_strip_model()->GetWebContentsAt(1)->GetWebUI());
 172   LOG(INFO) << "Nav 1.";
 173
 174   ui_test_utils::NavigateToURLWithDisposition(
 175       browser(), base_url.Resolve("path2/empty.html"), NEW_FOREGROUND_TAB,
 176       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 177   EXPECT_TRUE(process_map->Contains(
 178       browser()->tab_strip_model()->GetWebContentsAt(2)->
 179           GetRenderProcessHost()->GetID()));
 180   EXPECT_FALSE(browser()->tab_strip_model()->GetWebContentsAt(2)->GetWebUI());
 181   LOG(INFO) << "Nav 2.";
 182
 183   content::WindowedNotificationObserver tab_added_observer(
 184       chrome::NOTIFICATION_TAB_ADDED,
 185       content::NotificationService::AllSources());
 186   chrome::NewTab(browser());
 187   tab_added_observer.Wait();
 188   LOG(INFO) << "New tab.";
 189   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path3/empty.html"));
 190   LOG(INFO) << "Nav 3.";
 191   EXPECT_FALSE(process_map->Contains(
 192       browser()->tab_strip_model()->GetWebContentsAt(3)->
 193           GetRenderProcessHost()->GetID()));
 194   EXPECT_FALSE(browser()->tab_strip_model()->GetWebContentsAt(3)->GetWebUI());
 195
 196   // We should have opened 3 new extension tabs. Including the original blank
 197   // tab, we now have 4 tabs. Because the app_process app has the background
 198   // permission, all of its instances are in the same process.  Thus two tabs
 199   // should be part of the extension app and grouped in the same process.
 200   ASSERT_EQ(4, browser()->tab_strip_model()->count());
 201   WebContents* tab = browser()->tab_strip_model()->GetWebContentsAt(1);
 202
 203   EXPECT_EQ(tab->GetRenderProcessHost(),
 204             browser()->tab_strip_model()->GetWebContentsAt(2)->
 205                 GetRenderProcessHost());
 206   EXPECT_NE(tab->GetRenderProcessHost(),
 207             browser()->tab_strip_model()->GetWebContentsAt(3)->
 208                 GetRenderProcessHost());
 209
 210   // Now let's do the same using window.open. The same should happen.
 211   ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 212                                         browser()->host_desktop_type()));
 213   OpenWindow(tab, base_url.Resolve("path1/empty.html"), true, NULL);
 214   LOG(INFO) << "WindowOpenHelper 1.";
 215   OpenWindow(tab, base_url.Resolve("path2/empty.html"), true, NULL);
 216   LOG(INFO) << "WindowOpenHelper 2.";
 217   // TODO(creis): This should open in a new process (i.e., false for the last
 218   // argument), but we temporarily avoid swapping processes away from a hosted
 219   // app if it has an opener, because some OAuth providers make script calls
 220   // between non-app popups and non-app iframes in the app process.
 221   // See crbug.com/59285.
 222   OpenWindow(tab, base_url.Resolve("path3/empty.html"), true, NULL);
 223   LOG(INFO) << "WindowOpenHelper 3.";
 224
 225   // Now let's have these pages navigate, into or out of the extension web
 226   // extent. They should switch processes.
 227   const GURL& app_url(base_url.Resolve("path1/empty.html"));
 228   const GURL& non_app_url(base_url.Resolve("path3/empty.html"));
 229   NavigateInRenderer(browser()->tab_strip_model()->GetWebContentsAt(2),
 230                      non_app_url);
 231   LOG(INFO) << "NavigateTabHelper 1.";
 232   NavigateInRenderer(browser()->tab_strip_model()->GetWebContentsAt(3),
 233                      app_url);
 234   LOG(INFO) << "NavigateTabHelper 2.";
 235   EXPECT_NE(tab->GetRenderProcessHost(),
 236             browser()->tab_strip_model()->GetWebContentsAt(2)->
 237                 GetRenderProcessHost());
 238   EXPECT_EQ(tab->GetRenderProcessHost(),
 239             browser()->tab_strip_model()->GetWebContentsAt(3)->
 240                 GetRenderProcessHost());
 241
 242   // If one of the popup tabs navigates back to the app, window.opener should
 243   // be valid.
 244   NavigateInRenderer(browser()->tab_strip_model()->GetWebContentsAt(6),
 245                      app_url);
 246   LOG(INFO) << "NavigateTabHelper 3.";
 247   EXPECT_EQ(tab->GetRenderProcessHost(),
 248             browser()->tab_strip_model()->GetWebContentsAt(6)->
 249                 GetRenderProcessHost());
 250   bool windowOpenerValid = false;
 251   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 252       browser()->tab_strip_model()->GetWebContentsAt(6),
 253       "window.domAutomationController.send(window.opener != null)",
 254       &windowOpenerValid));
 255   ASSERT_TRUE(windowOpenerValid);
 256
 257   LOG(INFO) << "End of test.";
 258 }
 259
 260 // Test that hosted apps without the background permission use a process per app
 261 // instance model, such that separate instances are in separate processes.
 262 // Flaky on Windows. http://crbug.com/248047
 263 #if defined(OS_WIN)
 264 #define MAYBE_AppProcessInstances DISABLED_AppProcessInstances
 265 #else
 266 #define MAYBE_AppProcessInstances AppProcessInstances
 267 #endif
 268 IN_PROC_BROWSER_TEST_F(AppApiTest, MAYBE_AppProcessInstances) {
 269   TestAppInstancesHelper("app_process_instances");
 270 }
 271
 272 // Test that hosted apps with the background permission but that set
 273 // allow_js_access to false also use a process per app instance model.
 274 // Separate instances should be in separate processes.
 275 // Flaky on XP: http://crbug.com/165834
 276 #if defined(OS_WIN)
 277 #define MAYBE_AppProcessBackgroundInstances \
 278     DISABLED_AppProcessBackgroundInstances
 279 #else
 280 #define MAYBE_AppProcessBackgroundInstances AppProcessBackgroundInstances
 281 #endif
 282 IN_PROC_BROWSER_TEST_F(AppApiTest, MAYBE_AppProcessBackgroundInstances) {
 283   TestAppInstancesHelper("app_process_background_instances");
 284 }
 285
 286 // Tests that bookmark apps do not use the app process model and are treated
 287 // like normal web pages instead.  http://crbug.com/104636.
 288 // Timing out on Windows. http://crbug.com/238777
 289 #if defined(OS_WIN)
 290 #define MAYBE_BookmarkAppGetsNormalProcess DISABLED_BookmarkAppGetsNormalProcess
 291 #else
 292 #define MAYBE_BookmarkAppGetsNormalProcess BookmarkAppGetsNormalProcess
 293 #endif
 294 IN_PROC_BROWSER_TEST_F(AppApiTest, MAYBE_BookmarkAppGetsNormalProcess) {
 295   ExtensionService* service = extensions::ExtensionSystem::Get(
 296       browser()->profile())->extension_service();
 297   extensions::ProcessMap* process_map =
 298       extensions::ProcessMap::Get(browser()->profile());
 299
 300   host_resolver()->AddRule("*", "127.0.0.1");
 301   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 302   GURL base_url = GetTestBaseURL("app_process");
 303
 304   // Load an app as a bookmark app.
 305   std::string error;
 306   scoped_refptr<const Extension> extension(extension_file_util::LoadExtension(
 307       test_data_dir_.AppendASCII("app_process"),
 308       extensions::Manifest::UNPACKED,
 309       Extension::FROM_BOOKMARK,
 310       &error));
 311   service->OnExtensionInstalled(extension.get(),
 312                                 syncer::StringOrdinal::CreateInitialOrdinal(),
 313                                 false /* no requirement errors */,
 314                                 extensions::NOT_BLACKLISTED,
 315                                 false /* don't wait for idle */);
 316   ASSERT_TRUE(extension.get());
 317   ASSERT_TRUE(extension->from_bookmark());
 318
 319   // Test both opening a URL in a new tab, and opening a tab and then navigating
 320   // it.  Either way, bookmark app tabs should be considered normal processes
 321   // with no elevated privileges and no WebUI bindings.
 322   ui_test_utils::NavigateToURLWithDisposition(
 323       browser(), base_url.Resolve("path1/empty.html"), NEW_FOREGROUND_TAB,
 324       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 325   EXPECT_FALSE(process_map->Contains(
 326       browser()->tab_strip_model()->GetWebContentsAt(1)->
 327           GetRenderProcessHost()->GetID()));
 328   EXPECT_FALSE(browser()->tab_strip_model()->GetWebContentsAt(1)->GetWebUI());
 329
 330   content::WindowedNotificationObserver tab_added_observer(
 331       chrome::NOTIFICATION_TAB_ADDED,
 332       content::NotificationService::AllSources());
 333   chrome::NewTab(browser());
 334   tab_added_observer.Wait();
 335   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path2/empty.html"));
 336   EXPECT_FALSE(process_map->Contains(
 337       browser()->tab_strip_model()->GetWebContentsAt(2)->
 338           GetRenderProcessHost()->GetID()));
 339   EXPECT_FALSE(browser()->tab_strip_model()->GetWebContentsAt(2)->GetWebUI());
 340
 341   // We should have opened 2 new bookmark app tabs. Including the original blank
 342   // tab, we now have 3 tabs.  Because normal pages use the
 343   // process-per-site-instance model, each should be in its own process.
 344   ASSERT_EQ(3, browser()->tab_strip_model()->count());
 345   WebContents* tab = browser()->tab_strip_model()->GetWebContentsAt(1);
 346   EXPECT_NE(tab->GetRenderProcessHost(),
 347             browser()->tab_strip_model()->GetWebContentsAt(2)->
 348                 GetRenderProcessHost());
 349
 350   // Now let's do the same using window.open. The same should happen.
 351   ASSERT_EQ(1u, chrome::GetBrowserCount(browser()->profile(),
 352                                         browser()->host_desktop_type()));
 353   OpenWindow(tab, base_url.Resolve("path1/empty.html"), true, NULL);
 354   OpenWindow(tab, base_url.Resolve("path2/empty.html"), true, NULL);
 355
 356   // Now let's have a tab navigate out of and back into the app's web
 357   // extent. Neither navigation should switch processes.
 358   const GURL& app_url(base_url.Resolve("path1/empty.html"));
 359   const GURL& non_app_url(base_url.Resolve("path3/empty.html"));
 360   RenderViewHost* host2 =
 361       browser()->tab_strip_model()->GetWebContentsAt(2)->GetRenderViewHost();
 362   NavigateInRenderer(browser()->tab_strip_model()->GetWebContentsAt(2),
 363                      non_app_url);
 364   EXPECT_EQ(host2->GetProcess(),
 365             browser()->tab_strip_model()->GetWebContentsAt(2)->
 366                 GetRenderProcessHost());
 367   NavigateInRenderer(browser()->tab_strip_model()->GetWebContentsAt(2),
 368                      app_url);
 369   EXPECT_EQ(host2->GetProcess(),
 370             browser()->tab_strip_model()->GetWebContentsAt(2)->
 371                 GetRenderProcessHost());
 372 }
 373
 374 // Tests that app process switching works properly in the following scenario:
 375 // 1. navigate to a page1 in the app
 376 // 2. page1 redirects to a page2 outside the app extent (ie, "/server-redirect")
 377 // 3. page2 redirects back to a page in the app
 378 // The final navigation should end up in the app process.
 379 // See http://crbug.com/61757
 380 IN_PROC_BROWSER_TEST_F(AppApiTest, AppProcessRedirectBack) {
 381   host_resolver()->AddRule("*", "127.0.0.1");
 382   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 383
 384   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("app_process")));
 385
 386   // Open two tabs in the app.
 387   GURL base_url = GetTestBaseURL("app_process");
 388
 389   chrome::NewTab(browser());
 390   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path1/empty.html"));
 391   chrome::NewTab(browser());
 392   // Wait until the second tab finishes its redirect train (2 hops).
 393   // 1. We navigate to redirect.html
 394   // 2. Renderer navigates and finishes, counting as a load stop.
 395   // 3. Renderer issues the meta refresh to navigate to server-redirect.
 396   // 4. Renderer is now in a "provisional load", waiting for navigation to
 397   //    complete.
 398   // 5. Browser sees a redirect response from server-redirect to empty.html, and
 399   //    transfers that to a new navigation, using RequestTransferURL.
 400   // 6. Renderer navigates to empty.html, and finishes loading, counting as the
 401   //    second load stop
 402   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
 403       browser(), base_url.Resolve("path1/redirect.html"), 2);
 404
 405   // 3 tabs, including the initial about:blank. The last 2 should be the same
 406   // process.
 407   ASSERT_EQ(3, browser()->tab_strip_model()->count());
 408   EXPECT_EQ("/extensions/api_test/app_process/path1/empty.html",
 409             browser()->tab_strip_model()->GetWebContentsAt(2)->
 410                 GetController().GetLastCommittedEntry()->GetURL().path());
 411   EXPECT_EQ(browser()->tab_strip_model()->GetWebContentsAt(1)->
 412                 GetRenderProcessHost(),
 413             browser()->tab_strip_model()->GetWebContentsAt(2)->
 414                 GetRenderProcessHost());
 415 }
 416
 417 // Ensure that re-navigating to a URL after installing or uninstalling it as an
 418 // app correctly swaps the tab to the app process.  (http://crbug.com/80621)
 419 //
 420 // Fails on Windows. http://crbug.com/238670
 421 // Added logging to help diagnose the location of the problem.
 422 IN_PROC_BROWSER_TEST_F(AppApiTest, NavigateIntoAppProcess) {
 423   extensions::ProcessMap* process_map =
 424       extensions::ProcessMap::Get(browser()->profile());
 425
 426   host_resolver()->AddRule("*", "127.0.0.1");
 427   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 428
 429   // The app under test acts on URLs whose host is "localhost",
 430   // so the URLs we navigate to must have host "localhost".
 431   GURL base_url = GetTestBaseURL("app_process");
 432
 433   // Load an app URL before loading the app.
 434   LOG(INFO) << "Loading path1/empty.html.";
 435   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path1/empty.html"));
 436   LOG(INFO) << "Loading path1/empty.html - done.";
 437   WebContents* contents = browser()->tab_strip_model()->GetWebContentsAt(0);
 438   EXPECT_FALSE(process_map->Contains(
 439       contents->GetRenderProcessHost()->GetID()));
 440
 441   // Load app and re-navigate to the page.
 442   LOG(INFO) << "Loading extension.";
 443   const Extension* app =
 444       LoadExtension(test_data_dir_.AppendASCII("app_process"));
 445   LOG(INFO) << "Loading extension - done.";
 446   ASSERT_TRUE(app);
 447   LOG(INFO) << "Loading path1/empty.html.";
 448   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path1/empty.html"));
 449   LOG(INFO) << "Loading path1/empty.html - done.";
 450   EXPECT_TRUE(process_map->Contains(
 451       contents->GetRenderProcessHost()->GetID()));
 452
 453   // Disable app and re-navigate to the page.
 454   LOG(INFO) << "Disabling extension.";
 455   DisableExtension(app->id());
 456   LOG(INFO) << "Disabling extension - done.";
 457   LOG(INFO) << "Loading path1/empty.html.";
 458   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path1/empty.html"));
 459   LOG(INFO) << "Loading path1/empty.html - done.";
 460   EXPECT_FALSE(process_map->Contains(
 461       contents->GetRenderProcessHost()->GetID()));
 462 }
 463
 464 // Ensure that reloading a URL after installing or uninstalling it as an app
 465 // correctly swaps the tab to the app process.  (http://crbug.com/80621)
 466 //
 467 // Added logging to help diagnose the location of the problem.
 468 // http://crbug.com/238670
 469 IN_PROC_BROWSER_TEST_F(AppApiTest, ReloadIntoAppProcess) {
 470   extensions::ProcessMap* process_map =
 471       extensions::ProcessMap::Get(browser()->profile());
 472
 473   host_resolver()->AddRule("*", "127.0.0.1");
 474   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 475
 476   // The app under test acts on URLs whose host is "localhost",
 477   // so the URLs we navigate to must have host "localhost".
 478   GURL base_url = GetTestBaseURL("app_process");
 479
 480   // Load app, disable it, and navigate to the page.
 481   LOG(INFO) << "Loading extension.";
 482   const Extension* app =
 483       LoadExtension(test_data_dir_.AppendASCII("app_process"));
 484   LOG(INFO) << "Loading extension - done.";
 485   ASSERT_TRUE(app);
 486   LOG(INFO) << "Disabling extension.";
 487   DisableExtension(app->id());
 488   LOG(INFO) << "Disabling extension - done.";
 489   LOG(INFO) << "Navigate to path1/empty.html.";
 490   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path1/empty.html"));
 491   LOG(INFO) << "Navigate to path1/empty.html - done.";
 492   WebContents* contents = browser()->tab_strip_model()->GetWebContentsAt(0);
 493   EXPECT_FALSE(process_map->Contains(
 494       contents->GetRenderProcessHost()->GetID()));
 495
 496   // Enable app and reload the page.
 497   LOG(INFO) << "Enabling extension.";
 498   EnableExtension(app->id());
 499   LOG(INFO) << "Enabling extension - done.";
 500   content::WindowedNotificationObserver reload_observer(
 501       content::NOTIFICATION_LOAD_STOP,
 502       content::Source<NavigationController>(
 503           &browser()->tab_strip_model()->GetActiveWebContents()->
 504               GetController()));
 505   LOG(INFO) << "Reloading.";
 506   chrome::Reload(browser(), CURRENT_TAB);
 507   reload_observer.Wait();
 508   LOG(INFO) << "Reloading - done.";
 509   EXPECT_TRUE(process_map->Contains(
 510       contents->GetRenderProcessHost()->GetID()));
 511
 512   // Disable app and reload the page.
 513   LOG(INFO) << "Disabling extension.";
 514   DisableExtension(app->id());
 515   LOG(INFO) << "Disabling extension - done.";
 516   content::WindowedNotificationObserver reload_observer2(
 517       content::NOTIFICATION_LOAD_STOP,
 518       content::Source<NavigationController>(
 519           &browser()->tab_strip_model()->GetActiveWebContents()->
 520               GetController()));
 521   LOG(INFO) << "Reloading.";
 522   chrome::Reload(browser(), CURRENT_TAB);
 523   reload_observer2.Wait();
 524   LOG(INFO) << "Reloading - done.";
 525   EXPECT_FALSE(process_map->Contains(
 526       contents->GetRenderProcessHost()->GetID()));
 527 }
 528
 529 // Ensure that reloading a URL with JavaScript after installing or uninstalling
 530 // it as an app correctly swaps the process.  (http://crbug.com/80621)
 531 //
 532 // Crashes on Windows and Mac. http://crbug.com/238670
 533 // Added logging to help diagnose the location of the problem.
 534 IN_PROC_BROWSER_TEST_F(AppApiTest, ReloadIntoAppProcessWithJavaScript) {
 535   extensions::ProcessMap* process_map =
 536       extensions::ProcessMap::Get(browser()->profile());
 537
 538   host_resolver()->AddRule("*", "127.0.0.1");
 539   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 540
 541   // The app under test acts on URLs whose host is "localhost",
 542   // so the URLs we navigate to must have host "localhost".
 543   GURL base_url = GetTestBaseURL("app_process");
 544
 545   // Load app, disable it, and navigate to the page.
 546   LOG(INFO) << "Loading extension.";
 547   const Extension* app =
 548       LoadExtension(test_data_dir_.AppendASCII("app_process"));
 549   LOG(INFO) << "Loading extension - done.";
 550   ASSERT_TRUE(app);
 551   LOG(INFO) << "Disabling extension.";
 552   DisableExtension(app->id());
 553   LOG(INFO) << "Disabling extension - done.";
 554   LOG(INFO) << "Navigate to path1/empty.html.";
 555   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path1/empty.html"));
 556   LOG(INFO) << "Navigate to path1/empty.html - done.";
 557   WebContents* contents = browser()->tab_strip_model()->GetWebContentsAt(0);
 558   EXPECT_FALSE(process_map->Contains(
 559       contents->GetRenderProcessHost()->GetID()));
 560
 561   // Enable app and reload via JavaScript.
 562   LOG(INFO) << "Enabling extension.";
 563   EnableExtension(app->id());
 564   LOG(INFO) << "Enabling extension - done.";
 565   content::WindowedNotificationObserver js_reload_observer(
 566       content::NOTIFICATION_LOAD_STOP,
 567       content::Source<NavigationController>(
 568           &browser()->tab_strip_model()->GetActiveWebContents()->
 569               GetController()));
 570   LOG(INFO) << "Executing location.reload().";
 571   ASSERT_TRUE(content::ExecuteScript(contents, "location.reload();"));
 572   js_reload_observer.Wait();
 573   LOG(INFO) << "Executing location.reload() - done.";
 574   EXPECT_TRUE(process_map->Contains(
 575       contents->GetRenderProcessHost()->GetID()));
 576
 577   // Disable app and reload via JavaScript.
 578   LOG(INFO) << "Disabling extension.";
 579   DisableExtension(app->id());
 580   LOG(INFO) << "Disabling extension - done.";
 581   content::WindowedNotificationObserver js_reload_observer2(
 582       content::NOTIFICATION_LOAD_STOP,
 583       content::Source<NavigationController>(
 584           &browser()->tab_strip_model()->GetActiveWebContents()->
 585               GetController()));
 586   LOG(INFO) << "Executing location = location.";
 587   ASSERT_TRUE(content::ExecuteScript(contents, "location = location;"));
 588   js_reload_observer2.Wait();
 589   LOG(INFO) << "Executing location = location - done.";
 590   EXPECT_FALSE(process_map->Contains(
 591       contents->GetRenderProcessHost()->GetID()));
 592 }
 593
 594 // Tests that if we have a non-app process (path3/container.html) that has an
 595 // iframe with  a URL in the app's extent (path1/iframe.html), then opening a
 596 // link from that iframe to a new window to a URL in the app's extent (path1/
 597 // empty.html) results in the new window being in an app process. See
 598 // http://crbug.com/89272 for more details.
 599 IN_PROC_BROWSER_TEST_F(AppApiTest, OpenAppFromIframe) {
 600 #if defined(OS_WIN) && defined(USE_ASH)
 601   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 602   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 603     return;
 604 #endif
 605
 606   extensions::ProcessMap* process_map =
 607       extensions::ProcessMap::Get(browser()->profile());
 608
 609   host_resolver()->AddRule("*", "127.0.0.1");
 610   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 611
 612   GURL base_url = GetTestBaseURL("app_process");
 613
 614   // Load app and start URL (not in the app).
 615   const Extension* app =
 616       LoadExtension(test_data_dir_.AppendASCII("app_process"));
 617   ASSERT_TRUE(app);
 618
 619   ui_test_utils::NavigateToURL(browser(),
 620                                base_url.Resolve("path3/container.html"));
 621   EXPECT_FALSE(process_map->Contains(
 622       browser()->tab_strip_model()->GetWebContentsAt(0)->
 623           GetRenderProcessHost()->GetID()));
 624
 625   const BrowserList* active_browser_list =
 626       BrowserList::GetInstance(chrome::GetActiveDesktop());
 627   EXPECT_EQ(2U, active_browser_list->size());
 628   content::WebContents* popup_contents =
 629       active_browser_list->get(1)->tab_strip_model()->GetActiveWebContents();
 630   content::WaitForLoadStop(popup_contents);
 631
 632   // Popup window should be in the app's process.
 633   RenderViewHost* popup_host = popup_contents->GetRenderViewHost();
 634   EXPECT_TRUE(process_map->Contains(popup_host->GetProcess()->GetID()));
 635 }
 636
 637 // Similar to the previous test, but ensure that popup blocking bypass
 638 // isn't granted to the iframe.  See crbug.com/117446.
 639 #if defined(OS_CHROMEOS)
 640 // http://crbug.com/153513
 641 #define MAYBE_OpenAppFromIframe DISABLED_OpenAppFromIframe
 642 #else
 643 #define MAYBE_OpenAppFromIframe OpenAppFromIframe
 644 #endif
 645 IN_PROC_BROWSER_TEST_F(BlockedAppApiTest, MAYBE_OpenAppFromIframe) {
 646   host_resolver()->AddRule("*", "127.0.0.1");
 647   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 648
 649   // Load app and start URL (not in the app).
 650   const Extension* app =
 651       LoadExtension(test_data_dir_.AppendASCII("app_process"));
 652   ASSERT_TRUE(app);
 653
 654   ui_test_utils::NavigateToURL(
 655       browser(), GetTestBaseURL("app_process").Resolve("path3/container.html"));
 656
 657   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
 658   PopupBlockerTabHelper* popup_blocker_tab_helper =
 659       PopupBlockerTabHelper::FromWebContents(tab);
 660   if (!popup_blocker_tab_helper->GetBlockedPopupsCount()) {
 661     content::WindowedNotificationObserver observer(
 662         chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
 663         content::NotificationService::AllSources());
 664     observer.Wait();
 665   }
 666
 667   EXPECT_EQ(1u, popup_blocker_tab_helper->GetBlockedPopupsCount());
 668 }
 669
 670 // Tests that if an extension launches an app via chrome.tabs.create with an URL
 671 // that's not in the app's extent but that server redirects to it, we still end
 672 // up with an app process. See http://crbug.com/99349 for more details.
 673 IN_PROC_BROWSER_TEST_F(AppApiTest, ServerRedirectToAppFromExtension) {
 674   host_resolver()->AddRule("*", "127.0.0.1");
 675   ASSERT_TRUE(StartEmbeddedTestServer());
 676
 677   LoadExtension(test_data_dir_.AppendASCII("app_process"));
 678   const Extension* launcher =
 679       LoadExtension(test_data_dir_.AppendASCII("app_launcher"));
 680
 681   // There should be two navigations by the time the app page is loaded.
 682   // 1. The extension launcher page.
 683   // 2. The app's URL (which includes a server redirect).
 684   // Note that the server redirect does not generate a navigation event.
 685   content::TestNavigationObserver test_navigation_observer(
 686       browser()->tab_strip_model()->GetActiveWebContents(),
 687       2);
 688   test_navigation_observer.StartWatchingNewWebContents();
 689
 690   // Load the launcher extension, which should launch the app.
 691   ui_test_utils::NavigateToURLWithDisposition(
 692       browser(),
 693       launcher->GetResourceURL("server_redirect.html"),
 694       CURRENT_TAB,
 695       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 696
 697   // Wait for app tab to be created and loaded.
 698   test_navigation_observer.Wait();
 699
 700   // App has loaded, and chrome.app.isInstalled should be true.
 701   bool is_installed = false;
 702   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 703       browser()->tab_strip_model()->GetActiveWebContents(),
 704       "window.domAutomationController.send(chrome.app.isInstalled)",
 705       &is_installed));
 706   ASSERT_TRUE(is_installed);
 707 }
 708
 709 // Tests that if an extension launches an app via chrome.tabs.create with an URL
 710 // that's not in the app's extent but that client redirects to it, we still end
 711 // up with an app process.
 712 IN_PROC_BROWSER_TEST_F(AppApiTest, ClientRedirectToAppFromExtension) {
 713   host_resolver()->AddRule("*", "127.0.0.1");
 714   ASSERT_TRUE(StartEmbeddedTestServer());
 715
 716   LoadExtension(test_data_dir_.AppendASCII("app_process"));
 717   const Extension* launcher =
 718       LoadExtension(test_data_dir_.AppendASCII("app_launcher"));
 719
 720   // There should be three navigations by the time the app page is loaded.
 721   // 1. The extension launcher page.
 722   // 2. The URL that the extension launches, which client redirects.
 723   // 3. The app's URL.
 724   content::TestNavigationObserver test_navigation_observer(
 725       browser()->tab_strip_model()->GetActiveWebContents(),
 726       3);
 727   test_navigation_observer.StartWatchingNewWebContents();
 728
 729   // Load the launcher extension, which should launch the app.
 730   ui_test_utils::NavigateToURLWithDisposition(
 731       browser(),
 732       launcher->GetResourceURL("client_redirect.html"),
 733       CURRENT_TAB,
 734       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 735
 736   // Wait for app tab to be created and loaded.
 737   test_navigation_observer.Wait();
 738
 739   // App has loaded, and chrome.app.isInstalled should be true.
 740   bool is_installed = false;
 741   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 742       browser()->tab_strip_model()->GetActiveWebContents(),
 743       "window.domAutomationController.send(chrome.app.isInstalled)",
 744       &is_installed));
 745   ASSERT_TRUE(is_installed);
 746 }
 747
 748 // Tests that if we have an app process (path1/container.html) with a non-app
 749 // iframe (path3/iframe.html), then opening a link from that iframe to a new
 750 // window to a same-origin non-app URL (path3/empty.html) should keep the window
 751 // in the app process.
 752 // This is in contrast to OpenAppFromIframe, since here the popup will not be
 753 // missing special permissions and should be scriptable from the iframe.
 754 // See http://crbug.com/92669 for more details.
 755 IN_PROC_BROWSER_TEST_F(AppApiTest, OpenWebPopupFromWebIframe) {
 756   extensions::ProcessMap* process_map =
 757       extensions::ProcessMap::Get(browser()->profile());
 758
 759   host_resolver()->AddRule("*", "127.0.0.1");
 760   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 761
 762   GURL base_url = GetTestBaseURL("app_process");
 763
 764   // Load app and start URL (in the app).
 765   const Extension* app =
 766       LoadExtension(test_data_dir_.AppendASCII("app_process"));
 767   ASSERT_TRUE(app);
 768
 769   ui_test_utils::NavigateToURL(browser(),
 770                                base_url.Resolve("path1/container.html"));
 771   content::RenderProcessHost* process =
 772       browser()->tab_strip_model()->GetWebContentsAt(0)->GetRenderProcessHost();
 773   EXPECT_TRUE(process_map->Contains(process->GetID()));
 774
 775   // Popup window should be in the app's process.
 776   const BrowserList* active_browser_list =
 777       BrowserList::GetInstance(chrome::GetActiveDesktop());
 778   EXPECT_EQ(2U, active_browser_list->size());
 779   content::WebContents* popup_contents =
 780       active_browser_list->get(1)->tab_strip_model()->GetActiveWebContents();
 781   content::WaitForLoadStop(popup_contents);
 782
 783   RenderViewHost* popup_host = popup_contents->GetRenderViewHost();
 784   EXPECT_EQ(process, popup_host->GetProcess());
 785 }
 786
 787 // http://crbug.com/118502
 788 #if defined(OS_MACOSX) || defined(OS_LINUX)
 789 #define MAYBE_ReloadAppAfterCrash DISABLED_ReloadAppAfterCrash
 790 #else
 791 #define MAYBE_ReloadAppAfterCrash ReloadAppAfterCrash
 792 #endif
 793 IN_PROC_BROWSER_TEST_F(AppApiTest, MAYBE_ReloadAppAfterCrash) {
 794   extensions::ProcessMap* process_map =
 795       extensions::ProcessMap::Get(browser()->profile());
 796
 797   host_resolver()->AddRule("*", "127.0.0.1");
 798   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 799
 800   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("app_process")));
 801
 802   GURL base_url = GetTestBaseURL("app_process");
 803
 804   // Load the app, chrome.app.isInstalled should be true.
 805   ui_test_utils::NavigateToURL(browser(), base_url.Resolve("path1/empty.html"));
 806   WebContents* contents = browser()->tab_strip_model()->GetWebContentsAt(0);
 807   EXPECT_TRUE(process_map->Contains(
 808       contents->GetRenderProcessHost()->GetID()));
 809   bool is_installed = false;
 810   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 811       contents,
 812       "window.domAutomationController.send(chrome.app.isInstalled)",
 813       &is_installed));
 814   ASSERT_TRUE(is_installed);
 815
 816   // Crash the tab and reload it, chrome.app.isInstalled should still be true.
 817   content::CrashTab(browser()->tab_strip_model()->GetActiveWebContents());
 818   content::WindowedNotificationObserver observer(
 819       content::NOTIFICATION_LOAD_STOP,
 820       content::Source<NavigationController>(
 821           &browser()->tab_strip_model()->GetActiveWebContents()->
 822               GetController()));
 823   chrome::Reload(browser(), CURRENT_TAB);
 824   observer.Wait();
 825   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 826       contents,
 827       "window.domAutomationController.send(chrome.app.isInstalled)",
 828       &is_installed));
 829   ASSERT_TRUE(is_installed);
 830 }
 831
 832 // Test that a cross-process navigation away from a hosted app stays in the same
 833 // BrowsingInstance, so that postMessage calls to the app's other windows still
 834 // work.
 835 IN_PROC_BROWSER_TEST_F(AppApiTest, SameBrowsingInstanceAfterSwap) {
 836   extensions::ProcessMap* process_map =
 837       extensions::ProcessMap::Get(browser()->profile());
 838
 839   host_resolver()->AddRule("*", "127.0.0.1");
 840   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 841
 842   GURL base_url = GetTestBaseURL("app_process");
 843
 844   // Load app and start URL (in the app).
 845   const Extension* app =
 846       LoadExtension(test_data_dir_.AppendASCII("app_process"));
 847   ASSERT_TRUE(app);
 848
 849   ui_test_utils::NavigateToURL(browser(),
 850                                base_url.Resolve("path1/iframe.html"));
 851   content::SiteInstance* app_instance =
 852       browser()->tab_strip_model()->GetWebContentsAt(0)->GetSiteInstance();
 853   EXPECT_TRUE(process_map->Contains(app_instance->GetProcess()->GetID()));
 854
 855   // Popup window should be in the app's process.
 856   const BrowserList* active_browser_list =
 857       BrowserList::GetInstance(chrome::GetActiveDesktop());
 858   EXPECT_EQ(2U, active_browser_list->size());
 859   content::WebContents* popup_contents =
 860       active_browser_list->get(1)->tab_strip_model()->GetActiveWebContents();
 861   content::WaitForLoadStop(popup_contents);
 862
 863   SiteInstance* popup_instance = popup_contents->GetSiteInstance();
 864   EXPECT_EQ(app_instance, popup_instance);
 865
 866   // Navigate the popup to another process outside the app.
 867   GURL non_app_url(base_url.Resolve("path3/empty.html"));
 868   ui_test_utils::NavigateToURL(active_browser_list->get(1), non_app_url);
 869   SiteInstance* new_instance = popup_contents->GetSiteInstance();
 870   EXPECT_NE(app_instance, new_instance);
 871
 872   // It should still be in the same BrowsingInstance, allowing postMessage to
 873   // work.
 874   EXPECT_TRUE(app_instance->IsRelatedSiteInstance(new_instance));
 875 }