chrome/browser/extensions/window_open_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 "base/memory/scoped_vector.h"
   7 #include "base/path_service.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "chrome/browser/extensions/extension_apitest.h"
  10 #include "chrome/browser/extensions/extension_host.h"
  11 #include "chrome/browser/extensions/extension_system.h"
  12 #include "chrome/browser/extensions/extension_test_message_listener.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/ui/browser.h"
  15 #include "chrome/browser/ui/browser_finder.h"
  16 #include "chrome/browser/ui/browser_iterator.h"
  17 #include "chrome/browser/ui/panels/panel_manager.h"
  18 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  19 #include "chrome/common/chrome_paths.h"
  20 #include "chrome/common/chrome_switches.h"
  21 #include "chrome/test/base/test_switches.h"
  22 #include "chrome/test/base/ui_test_utils.h"
  23 #include "content/public/browser/render_process_host.h"
  24 #include "content/public/browser/web_contents.h"
  25 #include "content/public/common/result_codes.h"
  26 #include "content/public/test/browser_test_utils.h"
  27 #include "extensions/browser/process_manager.h"
  28 #include "extensions/common/extension.h"
  29 #include "extensions/common/switches.h"
  30 #include "net/dns/mock_host_resolver.h"
  31 #include "net/test/embedded_test_server/embedded_test_server.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 #if defined(USE_ASH)
  35 #include "apps/shell_window_registry.h"
  36 #endif
  37
  38 #if defined(USE_ASH) && !defined(OS_WIN)
  39 // TODO(stevenjb): Figure out the correct behavior for Ash + Win
  40 #define USE_ASH_PANELS
  41 #endif
  42
  43 using content::OpenURLParams;
  44 using content::Referrer;
  45 using content::WebContents;
  46
  47 // Disabled, http://crbug.com/64899.
  48 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, DISABLED_WindowOpen) {
  49   CommandLine::ForCurrentProcess()->AppendSwitch(
  50       extensions::switches::kEnableExperimentalExtensionApis);
  51
  52   ResultCatcher catcher;
  53   ASSERT_TRUE(LoadExtensionIncognito(test_data_dir_
  54       .AppendASCII("window_open").AppendASCII("spanning")));
  55   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
  56 }
  57
  58 int GetPanelCount(Browser* browser) {
  59 #if defined(USE_ASH_PANELS)
  60   return static_cast<int>(apps::ShellWindowRegistry::Get(
  61       browser->profile())->shell_windows().size());
  62 #else
  63   return PanelManager::GetInstance()->num_panels();
  64 #endif
  65 }
  66
  67 bool WaitForTabsAndPopups(Browser* browser,
  68                           int num_tabs,
  69                           int num_popups,
  70                           int num_panels) {
  71   SCOPED_TRACE(
  72       base::StringPrintf("WaitForTabsAndPopups tabs:%d, popups:%d, panels:%d",
  73                          num_tabs, num_popups, num_panels));
  74   // We start with one tab and one browser already open.
  75   ++num_tabs;
  76   size_t num_browsers = static_cast<size_t>(num_popups) + 1;
  77
  78   const base::TimeDelta kWaitTime = base::TimeDelta::FromSeconds(10);
  79   base::TimeTicks end_time = base::TimeTicks::Now() + kWaitTime;
  80   while (base::TimeTicks::Now() < end_time) {
  81     if (chrome::GetBrowserCount(browser->profile(),
  82                                 browser->host_desktop_type()) == num_browsers &&
  83         browser->tab_strip_model()->count() == num_tabs &&
  84         GetPanelCount(browser) == num_panels)
  85       break;
  86
  87     content::RunAllPendingInMessageLoop();
  88   }
  89
  90   EXPECT_EQ(num_browsers,
  91             chrome::GetBrowserCount(browser->profile(),
  92                                     browser->host_desktop_type()));
  93   EXPECT_EQ(num_tabs, browser->tab_strip_model()->count());
  94   EXPECT_EQ(num_panels, GetPanelCount(browser));
  95
  96   int num_popups_seen = 0;
  97   for (chrome::BrowserIterator iter; !iter.done(); iter.Next()) {
  98     if (*iter == browser)
  99       continue;
 100
 101     EXPECT_TRUE((*iter)->is_type_popup());
 102     ++num_popups_seen;
 103   }
 104   EXPECT_EQ(num_popups, num_popups_seen);
 105
 106   return ((num_browsers ==
 107                chrome::GetBrowserCount(browser->profile(),
 108                                        browser->host_desktop_type())) &&
 109           (num_tabs == browser->tab_strip_model()->count()) &&
 110           (num_panels == GetPanelCount(browser)) &&
 111           (num_popups == num_popups_seen));
 112 }
 113
 114 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, BrowserIsApp) {
 115   host_resolver()->AddRule("a.com", "127.0.0.1");
 116   ASSERT_TRUE(StartEmbeddedTestServer());
 117   ASSERT_TRUE(LoadExtension(
 118       test_data_dir_.AppendASCII("window_open").AppendASCII("browser_is_app")));
 119
 120   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 0, 2, 0));
 121
 122   for (chrome::BrowserIterator iter; !iter.done(); iter.Next()) {
 123     if (*iter == browser())
 124       ASSERT_FALSE(iter->is_app());
 125     else
 126       ASSERT_TRUE(iter->is_app());
 127   }
 128 }
 129
 130 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, WindowOpenPopupDefault) {
 131   ASSERT_TRUE(StartEmbeddedTestServer());
 132   ASSERT_TRUE(LoadExtension(
 133       test_data_dir_.AppendASCII("window_open").AppendASCII("popup")));
 134
 135   const int num_tabs = 1;
 136   const int num_popups = 0;
 137   EXPECT_TRUE(WaitForTabsAndPopups(browser(), num_tabs, num_popups, 0));
 138 }
 139
 140 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, WindowOpenPopupIframe) {
 141   ASSERT_TRUE(StartEmbeddedTestServer());
 142   base::FilePath test_data_dir;
 143   PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
 144   embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
 145   ASSERT_TRUE(LoadExtension(
 146       test_data_dir_.AppendASCII("window_open").AppendASCII("popup_iframe")));
 147
 148   const int num_tabs = 0;
 149   const int num_popups = 1;
 150   EXPECT_TRUE(WaitForTabsAndPopups(browser(), num_tabs, num_popups, 0));
 151 }
 152
 153 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, WindowOpenPopupLarge) {
 154   ASSERT_TRUE(StartEmbeddedTestServer());
 155   ASSERT_TRUE(LoadExtension(
 156       test_data_dir_.AppendASCII("window_open").AppendASCII("popup_large")));
 157
 158   // On other systems this should open a new popup window.
 159   const int num_tabs = 0;
 160   const int num_popups = 1;
 161   EXPECT_TRUE(WaitForTabsAndPopups(browser(), num_tabs, num_popups, 0));
 162 }
 163
 164 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, WindowOpenPopupSmall) {
 165   ASSERT_TRUE(StartEmbeddedTestServer());
 166   ASSERT_TRUE(LoadExtension(
 167       test_data_dir_.AppendASCII("window_open").AppendASCII("popup_small")));
 168
 169   // On ChromeOS this should open a new panel (acts like a new popup window).
 170   // On other systems this should open a new popup window.
 171   const int num_tabs = 0;
 172   const int num_popups = 1;
 173   EXPECT_TRUE(WaitForTabsAndPopups(browser(), num_tabs, num_popups, 0));
 174 }
 175
 176 // Disabled on Windows. Often times out or fails: crbug.com/177530
 177 #if defined(OS_WIN)
 178 #define MAYBE_PopupBlockingExtension DISABLED_PopupBlockingExtension
 179 #else
 180 #define MAYBE_PopupBlockingExtension PopupBlockingExtension
 181 #endif
 182 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_PopupBlockingExtension) {
 183   host_resolver()->AddRule("*", "127.0.0.1");
 184   ASSERT_TRUE(StartEmbeddedTestServer());
 185
 186   ASSERT_TRUE(LoadExtension(
 187       test_data_dir_.AppendASCII("window_open").AppendASCII("popup_blocking")
 188       .AppendASCII("extension")));
 189
 190   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 5, 3, 0));
 191 }
 192
 193 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, PopupBlockingHostedApp) {
 194   host_resolver()->AddRule("*", "127.0.0.1");
 195   ASSERT_TRUE(test_server()->Start());
 196
 197   ASSERT_TRUE(LoadExtension(
 198       test_data_dir_.AppendASCII("window_open").AppendASCII("popup_blocking")
 199       .AppendASCII("hosted_app")));
 200
 201   // The app being tested owns the domain a.com .  The test URLs we navigate
 202   // to below must be within that domain, so that they fall within the app's
 203   // web extent.
 204   GURL::Replacements replace_host;
 205   std::string a_dot_com = "a.com";
 206   replace_host.SetHostStr(a_dot_com);
 207
 208   const std::string popup_app_contents_path(
 209     "files/extensions/api_test/window_open/popup_blocking/hosted_app/");
 210
 211   GURL open_tab =
 212       test_server()->GetURL(popup_app_contents_path + "open_tab.html")
 213           .ReplaceComponents(replace_host);
 214   GURL open_popup =
 215       test_server()->GetURL(popup_app_contents_path + "open_popup.html")
 216           .ReplaceComponents(replace_host);
 217
 218   browser()->OpenURL(OpenURLParams(
 219       open_tab, Referrer(), NEW_FOREGROUND_TAB, content::PAGE_TRANSITION_TYPED,
 220       false));
 221   browser()->OpenURL(OpenURLParams(
 222       open_popup, Referrer(), NEW_FOREGROUND_TAB,
 223       content::PAGE_TRANSITION_TYPED, false));
 224
 225   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 3, 1, 0));
 226 }
 227
 228 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, WindowArgumentsOverflow) {
 229   ASSERT_TRUE(RunExtensionTest("window_open/argument_overflow")) << message_;
 230 }
 231
 232 class WindowOpenPanelDisabledTest : public ExtensionApiTest {
 233   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 234     ExtensionApiTest::SetUpCommandLine(command_line);
 235     // TODO(jennb): Re-enable when panels are enabled by default.
 236     // command_line->AppendSwitch(switches::kDisablePanels);
 237   }
 238 };
 239
 240 IN_PROC_BROWSER_TEST_F(WindowOpenPanelDisabledTest,
 241                        DISABLED_WindowOpenPanelNotEnabled) {
 242   ASSERT_TRUE(RunExtensionTest("window_open/panel_not_enabled")) << message_;
 243 }
 244
 245 class WindowOpenPanelTest : public ExtensionApiTest {
 246   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 247     ExtensionApiTest::SetUpCommandLine(command_line);
 248     command_line->AppendSwitch(switches::kEnablePanels);
 249   }
 250 };
 251
 252 #if defined(USE_ASH_PANELS)
 253 // On Ash, this currently fails because we're currently opening new panel
 254 // windows as popup windows instead.
 255 #define MAYBE_WindowOpenPanel DISABLED_WindowOpenPanel
 256 #else
 257 #define MAYBE_WindowOpenPanel WindowOpenPanel
 258 #endif
 259 IN_PROC_BROWSER_TEST_F(WindowOpenPanelTest, MAYBE_WindowOpenPanel) {
 260   ASSERT_TRUE(RunExtensionTest("window_open/panel")) << message_;
 261 }
 262
 263 #if defined(USE_ASH_PANELS)
 264 // On Ash, this currently fails because we're currently opening new panel
 265 // windows as popup windows instead.
 266 #define MAYBE_WindowOpenPanelDetached DISABLED_WindowOpenPanelDetached
 267 #else
 268 #define MAYBE_WindowOpenPanelDetached WindowOpenPanelDetached
 269 #endif
 270 IN_PROC_BROWSER_TEST_F(WindowOpenPanelTest, MAYBE_WindowOpenPanelDetached) {
 271   ASSERT_TRUE(RunExtensionTest("window_open/panel_detached")) << message_;
 272 }
 273
 274 IN_PROC_BROWSER_TEST_F(WindowOpenPanelTest,
 275                        CloseNonExtensionPanelsOnUninstall) {
 276 #if defined(OS_WIN) && defined(USE_ASH)
 277   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 278   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
 279     return;
 280 #endif
 281
 282 #if defined(USE_ASH_PANELS)
 283   // On Ash, new panel windows open as popup windows instead.
 284   int num_popups, num_panels;
 285   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePanels)) {
 286     num_popups = 2;
 287     num_panels = 2;
 288   } else {
 289     num_popups = 4;
 290     num_panels = 0;
 291   }
 292 #else
 293   int num_popups = 2;
 294   int num_panels = 2;
 295 #endif
 296   ASSERT_TRUE(StartEmbeddedTestServer());
 297
 298   // Setup listeners to wait on strings we expect the extension pages to send.
 299   std::vector<std::string> test_strings;
 300   test_strings.push_back("content_tab");
 301   if (num_panels)
 302     test_strings.push_back("content_panel");
 303   test_strings.push_back("content_popup");
 304
 305   ScopedVector<ExtensionTestMessageListener> listeners;
 306   for (size_t i = 0; i < test_strings.size(); ++i) {
 307     listeners.push_back(
 308         new ExtensionTestMessageListener(test_strings[i], false));
 309   }
 310
 311   const extensions::Extension* extension = LoadExtension(
 312       test_data_dir_.AppendASCII("window_open").AppendASCII(
 313           "close_panels_on_uninstall"));
 314   ASSERT_TRUE(extension);
 315
 316   // Two tabs. One in extension domain and one in non-extension domain.
 317   // Two popups - one in extension domain and one in non-extension domain.
 318   // Two panels - one in extension domain and one in non-extension domain.
 319   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 2, num_popups, num_panels));
 320
 321   // Wait on test messages to make sure the pages loaded.
 322   for (size_t i = 0; i < listeners.size(); ++i)
 323     ASSERT_TRUE(listeners[i]->WaitUntilSatisfied());
 324
 325   UninstallExtension(extension->id());
 326
 327   // Wait for the tabs and popups in non-extension domain to stay open.
 328   // Expect everything else, including panels, to close.
 329   num_popups -= 1;
 330 #if defined(USE_ASH_PANELS)
 331   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePanels)) {
 332     // On Ash, new panel windows open as popup windows instead, so there are 2
 333     // extension domain popups that will close (instead of 1 popup on non-Ash).
 334     num_popups -= 1;
 335   }
 336 #endif
 337 #if defined(USE_ASH)
 338 #if !defined(OS_WIN)
 339   // On linux ash we close all popup applications when closing its extension.
 340   num_popups = 0;
 341 #endif
 342 #endif
 343   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 1, num_popups, 0));
 344 }
 345
 346 // This test isn't applicable on Chrome OS, which automatically reloads
 347 // crashed pages.
 348 #if !defined(OS_CHROMEOS)
 349 IN_PROC_BROWSER_TEST_F(WindowOpenPanelTest, ClosePanelsOnExtensionCrash) {
 350 #if defined(USE_ASH_PANELS)
 351   // On Ash, new panel windows open as popup windows instead.
 352   int num_popups = 4;
 353   int num_panels = 0;
 354 #else
 355   int num_popups = 2;
 356   int num_panels = 2;
 357 #endif
 358   ASSERT_TRUE(StartEmbeddedTestServer());
 359
 360   // Setup listeners to wait on strings we expect the extension pages to send.
 361   std::vector<std::string> test_strings;
 362   test_strings.push_back("content_tab");
 363   if (num_panels)
 364     test_strings.push_back("content_panel");
 365   test_strings.push_back("content_popup");
 366
 367   ScopedVector<ExtensionTestMessageListener> listeners;
 368   for (size_t i = 0; i < test_strings.size(); ++i) {
 369     listeners.push_back(
 370         new ExtensionTestMessageListener(test_strings[i], false));
 371   }
 372
 373   const extensions::Extension* extension = LoadExtension(
 374       test_data_dir_.AppendASCII("window_open").AppendASCII(
 375           "close_panels_on_uninstall"));
 376   ASSERT_TRUE(extension);
 377
 378   // Two tabs. One in extension domain and one in non-extension domain.
 379   // Two popups - one in extension domain and one in non-extension domain.
 380   // Two panels - one in extension domain and one in non-extension domain.
 381   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 2, num_popups, num_panels));
 382
 383   // Wait on test messages to make sure the pages loaded.
 384   for (size_t i = 0; i < listeners.size(); ++i)
 385     ASSERT_TRUE(listeners[i]->WaitUntilSatisfied());
 386
 387   // Crash the extension.
 388   extensions::ExtensionHost* extension_host =
 389       extensions::ExtensionSystem::Get(browser()->profile())->
 390           process_manager()->GetBackgroundHostForExtension(extension->id());
 391   ASSERT_TRUE(extension_host);
 392   base::KillProcess(extension_host->render_process_host()->GetHandle(),
 393                     content::RESULT_CODE_KILLED, false);
 394   WaitForExtensionCrash(extension->id());
 395
 396   // Only expect panels to close. The rest stay open to show a sad-tab.
 397   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 2, num_popups, 0));
 398 }
 399 #endif  // !defined(OS_CHROMEOS)
 400
 401 #if defined(USE_ASH_PANELS)
 402 // This test is not applicable on Ash. The modified window.open behavior only
 403 // applies to non-Ash panel windows.
 404 #define MAYBE_WindowOpenFromPanel DISABLED_WindowOpenFromPanel
 405 #else
 406 #define MAYBE_WindowOpenFromPanel WindowOpenFromPanel
 407 #endif
 408 IN_PROC_BROWSER_TEST_F(WindowOpenPanelTest, MAYBE_WindowOpenFromPanel) {
 409   ASSERT_TRUE(StartEmbeddedTestServer());
 410
 411   // Load the extension that will open a panel which then calls window.open.
 412   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("window_open").
 413                             AppendASCII("panel_window_open")));
 414
 415   // Expect one panel (opened by extension) and one tab (from the panel calling
 416   // window.open). Panels modify the WindowOpenDisposition in window.open
 417   // to always open in a tab.
 418   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 1, 0, 1));
 419 }
 420
 421 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, DISABLED_WindowOpener) {
 422   ASSERT_TRUE(RunExtensionTest("window_open/opener")) << message_;
 423 }
 424
 425 #if defined(OS_MACOSX)
 426 // Extension popup windows are incorrectly sized on OSX, crbug.com/225601
 427 #define MAYBE_WindowOpenSized DISABLED_WindowOpenSized
 428 #else
 429 #define MAYBE_WindowOpenSized WindowOpenSized
 430 #endif
 431 // Ensure that the width and height properties of a window opened with
 432 // chrome.windows.create match the creation parameters. See crbug.com/173831.
 433 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_WindowOpenSized) {
 434   ASSERT_TRUE(RunExtensionTest("window_open/window_size")) << message_;
 435   EXPECT_TRUE(WaitForTabsAndPopups(browser(), 0, 1, 0));
 436 }
 437
 438 // Tests that an extension page can call window.open to an extension URL and
 439 // the new window has extension privileges.
 440 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, WindowOpenExtension) {
 441   ASSERT_TRUE(LoadExtension(
 442       test_data_dir_.AppendASCII("uitest").AppendASCII("window_open")));
 443
 444   GURL start_url(std::string("chrome-extension://") +
 445       last_loaded_extension_id() + "/test.html");
 446   ui_test_utils::NavigateToURL(browser(), start_url);
 447   WebContents* newtab = NULL;
 448   ASSERT_NO_FATAL_FAILURE(
 449       OpenWindow(browser()->tab_strip_model()->GetActiveWebContents(),
 450       start_url.Resolve("newtab.html"), true, &newtab));
 451
 452   bool result = false;
 453   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(newtab, "testExtensionApi()",
 454                                                    &result));
 455   EXPECT_TRUE(result);
 456 }
 457
 458 // Tests that if an extension page calls window.open to an invalid extension
 459 // URL, the browser doesn't crash.
 460 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, WindowOpenInvalidExtension) {
 461   ASSERT_TRUE(LoadExtension(
 462       test_data_dir_.AppendASCII("uitest").AppendASCII("window_open")));
 463
 464   GURL start_url(std::string("chrome-extension://") +
 465       last_loaded_extension_id() + "/test.html");
 466   ui_test_utils::NavigateToURL(browser(), start_url);
 467   ASSERT_NO_FATAL_FAILURE(
 468       OpenWindow(browser()->tab_strip_model()->GetActiveWebContents(),
 469       GURL("chrome-extension://thisissurelynotavalidextensionid/newtab.html"),
 470       false, NULL));
 471
 472   // If we got to this point, we didn't crash, so we're good.
 473 }
 474
 475 // Tests that calling window.open from the newtab page to an extension URL
 476 // gives the new window extension privileges - even though the opening page
 477 // does not have extension privileges, we break the script connection, so
 478 // there is no privilege leak.
 479 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, WindowOpenNoPrivileges) {
 480   ASSERT_TRUE(LoadExtension(
 481       test_data_dir_.AppendASCII("uitest").AppendASCII("window_open")));
 482
 483   ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
 484   WebContents* newtab = NULL;
 485   ASSERT_NO_FATAL_FAILURE(
 486       OpenWindow(browser()->tab_strip_model()->GetActiveWebContents(),
 487       GURL(std::string("chrome-extension://") + last_loaded_extension_id() +
 488           "/newtab.html"), false, &newtab));
 489
 490   // Extension API should succeed.
 491   bool result = false;
 492   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(newtab, "testExtensionApi()",
 493                                                    &result));
 494   EXPECT_TRUE(result);
 495 }