chrome/browser/ui/browser_navigator_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/ui/browser_navigator_browsertest.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "chrome/app/chrome_command_ids.h"
  12 #include "chrome/browser/prefs/incognito_mode_prefs.h"
  13 #include "chrome/browser/profiles/profile.h"
  14 #include "chrome/browser/ui/browser.h"
  15 #include "chrome/browser/ui/browser_commands.h"
  16 #include "chrome/browser/ui/browser_finder.h"
  17 #include "chrome/browser/ui/browser_navigator.h"
  18 #include "chrome/browser/ui/browser_tabstrip.h"
  19 #include "chrome/browser/ui/browser_window.h"
  20 #include "chrome/browser/ui/chrome_pages.h"
  21 #include "chrome/browser/ui/singleton_tabs.h"
  22 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  23 #include "chrome/common/chrome_switches.h"
  24 #include "chrome/common/pref_names.h"
  25 #include "chrome/common/url_constants.h"
  26 #include "chrome/test/base/ui_test_utils.h"
  27 #include "content/public/browser/notification_service.h"
  28 #include "content/public/browser/notification_types.h"
  29 #include "content/public/browser/web_contents.h"
  30
  31 using content::WebContents;
  32
  33 namespace {
  34
  35 const char kExpectedTitle[] = "PASSED!";
  36 const char kEchoTitleCommand[] = "echotitle";
  37
  38 GURL GetGoogleURL() {
  39   return GURL("http://www.google.com/");
  40 }
  41
  42 GURL GetSettingsURL() {
  43   return GURL(chrome::kChromeUISettingsURL);
  44 }
  45
  46 GURL GetContentSettingsURL() {
  47   return GetSettingsURL().Resolve(chrome::kContentSettingsExceptionsSubPage);
  48 }
  49
  50 GURL GetClearBrowsingDataURL() {
  51   return GetSettingsURL().Resolve(chrome::kClearBrowserDataSubPage);
  52 }
  53
  54 // Converts long uber URLs ("chrome://chrome/foo/") to short (virtual) URLs
  55 // ("chrome://foo/"). This should be used to convert the return value of
  56 // WebContentsImpl::GetURL before comparison because it can return either the
  57 // real URL or the virtual URL.
  58 GURL ShortenUberURL(const GURL& url) {
  59   std::string url_string = url.spec();
  60   const std::string long_prefix = "chrome://chrome/";
  61   const std::string short_prefix = "chrome://";
  62   if (url_string.find(long_prefix) != 0)
  63     return url;
  64   url_string.replace(0, long_prefix.length(), short_prefix);
  65   return GURL(url_string);
  66 }
  67
  68 }  // namespace
  69
  70 chrome::NavigateParams BrowserNavigatorTest::MakeNavigateParams() const {
  71   return MakeNavigateParams(browser());
  72 }
  73
  74 chrome::NavigateParams BrowserNavigatorTest::MakeNavigateParams(
  75     Browser* browser) const {
  76   chrome::NavigateParams params(browser, GetGoogleURL(),
  77                                 content::PAGE_TRANSITION_LINK);
  78   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
  79   return params;
  80 }
  81
  82 bool BrowserNavigatorTest::OpenPOSTURLInNewForegroundTabAndGetTitle(
  83     const GURL& url, const std::string& post_data, bool is_browser_initiated,
  84     base::string16* title) {
  85   chrome::NavigateParams param(MakeNavigateParams());
  86   param.disposition = NEW_FOREGROUND_TAB;
  87   param.url = url;
  88   param.is_renderer_initiated = !is_browser_initiated;
  89   param.uses_post = true;
  90   param.browser_initiated_post_data = new base::RefCountedStaticMemory(
  91       post_data.data(), post_data.size());
  92
  93   ui_test_utils::NavigateToURL(&param);
  94   if (!param.target_contents)
  95     return false;
  96
  97   // Navigate() should have opened the contents in new foreground tab in the
  98   // current Browser.
  99   EXPECT_EQ(browser(), param.browser);
 100   EXPECT_EQ(browser()->tab_strip_model()->GetActiveWebContents(),
 101             param.target_contents);
 102   // We should have one window, with one tab.
 103   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 104   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 105
 106   *title = param.target_contents->GetTitle();
 107   return true;
 108 }
 109
 110 Browser* BrowserNavigatorTest::CreateEmptyBrowserForType(Browser::Type type,
 111                                                          Profile* profile) {
 112   Browser* browser = new Browser(
 113       Browser::CreateParams(type, profile, chrome::GetActiveDesktop()));
 114   chrome::AddTabAt(browser, GURL(), -1, true);
 115   return browser;
 116 }
 117
 118 Browser* BrowserNavigatorTest::CreateEmptyBrowserForApp(Profile* profile) {
 119   Browser* browser = new Browser(
 120       Browser::CreateParams::CreateForApp(
 121           "Test", false /* trusted_source */, gfx::Rect(), profile,
 122           chrome::GetActiveDesktop()));
 123   chrome::AddTabAt(browser, GURL(), -1, true);
 124   return browser;
 125 }
 126
 127 WebContents* BrowserNavigatorTest::CreateWebContents() {
 128   content::WebContents::CreateParams create_params(browser()->profile());
 129   content::WebContents* base_web_contents =
 130       browser()->tab_strip_model()->GetActiveWebContents();
 131   if (base_web_contents) {
 132     create_params.initial_size =
 133         base_web_contents->GetContainerBounds().size();
 134   }
 135   return WebContents::Create(create_params);
 136 }
 137
 138 void BrowserNavigatorTest::RunSuppressTest(WindowOpenDisposition disposition) {
 139   GURL old_url = browser()->tab_strip_model()->GetActiveWebContents()->GetURL();
 140   chrome::NavigateParams p(MakeNavigateParams());
 141   p.disposition = disposition;
 142   chrome::Navigate(&p);
 143
 144   // Nothing should have happened as a result of Navigate();
 145   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 146   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 147   EXPECT_EQ(old_url,
 148             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 149 }
 150
 151 void BrowserNavigatorTest::RunUseNonIncognitoWindowTest(const GURL& url) {
 152   Browser* incognito_browser = CreateIncognitoBrowser();
 153
 154   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 155   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 156   EXPECT_EQ(1, incognito_browser->tab_strip_model()->count());
 157
 158   // Navigate to the page.
 159   chrome::NavigateParams p(MakeNavigateParams(incognito_browser));
 160   p.disposition = SINGLETON_TAB;
 161   p.url = url;
 162   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
 163   chrome::Navigate(&p);
 164
 165   // This page should be opened in browser() window.
 166   EXPECT_NE(incognito_browser, p.browser);
 167   EXPECT_EQ(browser(), p.browser);
 168   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 169   EXPECT_EQ(url,
 170             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 171 }
 172
 173 void BrowserNavigatorTest::RunDoNothingIfIncognitoIsForcedTest(
 174     const GURL& url) {
 175   Browser* browser = CreateIncognitoBrowser();
 176
 177   // Set kIncognitoModeAvailability to FORCED.
 178   PrefService* prefs1 = browser->profile()->GetPrefs();
 179   prefs1->SetInteger(prefs::kIncognitoModeAvailability,
 180                      IncognitoModePrefs::FORCED);
 181   PrefService* prefs2 = browser->profile()->GetOriginalProfile()->GetPrefs();
 182   prefs2->SetInteger(prefs::kIncognitoModeAvailability,
 183                      IncognitoModePrefs::FORCED);
 184
 185   // Navigate to the page.
 186   chrome::NavigateParams p(MakeNavigateParams(browser));
 187   p.disposition = OFF_THE_RECORD;
 188   p.url = url;
 189   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
 190   chrome::Navigate(&p);
 191
 192   // The page should not be opened.
 193   EXPECT_EQ(browser, p.browser);
 194   EXPECT_EQ(1, browser->tab_strip_model()->count());
 195   EXPECT_EQ(GURL(url::kAboutBlankURL),
 196             browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 197 }
 198
 199 void BrowserNavigatorTest::SetUpCommandLine(base::CommandLine* command_line) {
 200   // Disable settings-in-a-window so that we can use the settings page and
 201   // sub-pages to test browser navigation.
 202   command_line->AppendSwitch(::switches::kDisableSettingsWindow);
 203 }
 204
 205 void BrowserNavigatorTest::Observe(
 206     int type,
 207     const content::NotificationSource& source,
 208     const content::NotificationDetails& details) {
 209   switch (type) {
 210     case content::NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED: {
 211       ++this->created_tab_contents_count_;
 212       break;
 213     }
 214     default:
 215       break;
 216   }
 217 }
 218
 219
 220 namespace {
 221
 222 // This test verifies that when a navigation occurs within a tab, the tab count
 223 // of the Browser remains the same and the current tab bears the loaded URL.
 224 // Note that network URLs are not actually loaded in tests, so this also tests
 225 // that error pages leave the intended URL in the address bar.
 226 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_CurrentTab) {
 227   ui_test_utils::NavigateToURL(browser(), GetGoogleURL());
 228   EXPECT_EQ(GetGoogleURL(),
 229             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 230   // We should have one window with one tab.
 231   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 232   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 233 }
 234
 235 // This test verifies that a singleton tab is refocused if one is already opened
 236 // in another or an existing window, or added if it is not.
 237 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_SingletonTabExisting) {
 238   GURL singleton_url1("http://maps.google.com/");
 239
 240   // Register for a notification if an additional WebContents was instantiated.
 241   // Opening a Singleton tab that is already opened should not be opening a new
 242   // tab nor be creating a new WebContents object.
 243   content::NotificationRegistrar registrar;
 244
 245   // As the registrar object goes out of scope, this will get unregistered
 246   registrar.Add(this,
 247                 content::NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
 248                 content::NotificationService::AllSources());
 249
 250   chrome::AddSelectedTabWithURL(browser(), singleton_url1,
 251                                 content::PAGE_TRANSITION_LINK);
 252   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
 253                                 content::PAGE_TRANSITION_LINK);
 254
 255   // We should have one browser with 3 tabs, the 3rd selected.
 256   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 257   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 258
 259   unsigned int previous_tab_contents_count =
 260       created_tab_contents_count_ = 0;
 261
 262   // Navigate to singleton_url1.
 263   chrome::NavigateParams p(MakeNavigateParams());
 264   p.disposition = SINGLETON_TAB;
 265   p.url = singleton_url1;
 266   chrome::Navigate(&p);
 267
 268   // The middle tab should now be selected.
 269   EXPECT_EQ(browser(), p.browser);
 270   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 271
 272   // No tab contents should have been created
 273   EXPECT_EQ(previous_tab_contents_count,
 274             created_tab_contents_count_);
 275 }
 276
 277 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 278                        Disposition_SingletonTabRespectingRef) {
 279   GURL singleton_ref_url1("http://maps.google.com/#a");
 280   GURL singleton_ref_url2("http://maps.google.com/#b");
 281   GURL singleton_ref_url3("http://maps.google.com/");
 282
 283   chrome::AddSelectedTabWithURL(browser(), singleton_ref_url1,
 284                                 content::PAGE_TRANSITION_LINK);
 285
 286   // We should have one browser with 2 tabs, 2nd selected.
 287   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 288   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 289   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 290
 291   // Navigate to singleton_url2.
 292   chrome::NavigateParams p(MakeNavigateParams());
 293   p.disposition = SINGLETON_TAB;
 294   p.url = singleton_ref_url2;
 295   chrome::Navigate(&p);
 296
 297   // We should now have 2 tabs, the 2nd one selected.
 298   EXPECT_EQ(browser(), p.browser);
 299   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 300   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 301
 302   // Navigate to singleton_url2, but with respect ref set.
 303   p = MakeNavigateParams();
 304   p.disposition = SINGLETON_TAB;
 305   p.url = singleton_ref_url2;
 306   p.ref_behavior = chrome::NavigateParams::RESPECT_REF;
 307   chrome::Navigate(&p);
 308
 309   // We should now have 3 tabs, the 3th one selected.
 310   EXPECT_EQ(browser(), p.browser);
 311   EXPECT_EQ(3, browser()->tab_strip_model()->count());
 312   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 313
 314   // Navigate to singleton_url3.
 315   p = MakeNavigateParams();
 316   p.disposition = SINGLETON_TAB;
 317   p.url = singleton_ref_url3;
 318   p.ref_behavior = chrome::NavigateParams::RESPECT_REF;
 319   chrome::Navigate(&p);
 320
 321   // We should now have 4 tabs, the 4th one selected.
 322   EXPECT_EQ(browser(), p.browser);
 323   EXPECT_EQ(4, browser()->tab_strip_model()->count());
 324   EXPECT_EQ(3, browser()->tab_strip_model()->active_index());
 325 }
 326
 327 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 328                        Disposition_SingletonTabNoneExisting) {
 329   GURL singleton_url1("http://maps.google.com/");
 330
 331   // We should have one browser with 1 tab.
 332   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 333   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
 334
 335   // Navigate to singleton_url1.
 336   chrome::NavigateParams p(MakeNavigateParams());
 337   p.disposition = SINGLETON_TAB;
 338   p.url = singleton_url1;
 339   chrome::Navigate(&p);
 340
 341   // We should now have 2 tabs, the 2nd one selected.
 342   EXPECT_EQ(browser(), p.browser);
 343   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 344   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 345 }
 346
 347 // This test verifies that when a navigation results in a foreground tab, the
 348 // tab count of the Browser increases and the selected tab shifts to the new
 349 // foreground tab.
 350 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewForegroundTab) {
 351   WebContents* old_contents =
 352       browser()->tab_strip_model()->GetActiveWebContents();
 353   chrome::NavigateParams p(MakeNavigateParams());
 354   p.disposition = NEW_FOREGROUND_TAB;
 355   chrome::Navigate(&p);
 356   EXPECT_NE(old_contents,
 357             browser()->tab_strip_model()->GetActiveWebContents());
 358   EXPECT_EQ(browser()->tab_strip_model()->GetActiveWebContents(),
 359             p.target_contents);
 360   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 361 }
 362
 363 // This test verifies that when a navigation results in a background tab, the
 364 // tab count of the Browser increases but the selected tab remains the same.
 365 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewBackgroundTab) {
 366   WebContents* old_contents =
 367       browser()->tab_strip_model()->GetActiveWebContents();
 368   chrome::NavigateParams p(MakeNavigateParams());
 369   p.disposition = NEW_BACKGROUND_TAB;
 370   chrome::Navigate(&p);
 371   WebContents* new_contents =
 372       browser()->tab_strip_model()->GetActiveWebContents();
 373   // The selected tab should have remained unchanged, since the new tab was
 374   // opened in the background.
 375   EXPECT_EQ(old_contents, new_contents);
 376   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 377 }
 378
 379 // This test verifies that when a navigation requiring a new foreground tab
 380 // occurs in a Browser that cannot host multiple tabs, the new foreground tab
 381 // is created in an existing compatible Browser.
 382 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 383                        Disposition_IncompatibleWindow_Existing) {
 384   // Open a foreground tab in a window that cannot open popups when there is an
 385   // existing compatible window somewhere else that they can be opened within.
 386   Browser* popup = CreateEmptyBrowserForType(Browser::TYPE_POPUP,
 387                                              browser()->profile());
 388   chrome::NavigateParams p(MakeNavigateParams(popup));
 389   p.disposition = NEW_FOREGROUND_TAB;
 390   chrome::Navigate(&p);
 391
 392   // Navigate() should have opened the tab in a different browser since the
 393   // one we supplied didn't support additional tabs.
 394   EXPECT_NE(popup, p.browser);
 395
 396   // Since browser() is an existing compatible tabbed browser, it should have
 397   // opened the tab there.
 398   EXPECT_EQ(browser(), p.browser);
 399
 400   // We should be left with 2 windows, the popup with one tab and the browser()
 401   // provided by the framework with two.
 402   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 403   EXPECT_EQ(1, popup->tab_strip_model()->count());
 404   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 405 }
 406
 407 // This test verifies that when a navigation requiring a new foreground tab
 408 // occurs in a Browser that cannot host multiple tabs and no compatible Browser
 409 // that can is open, a compatible Browser is created.
 410 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 411                        Disposition_IncompatibleWindow_NoExisting) {
 412   // We want to simulate not being able to find an existing window compatible
 413   // with our non-tabbed browser window so Navigate() is forced to create a
 414   // new compatible window. Because browser() supplied by the in-process
 415   // browser testing framework is compatible with browser()->profile(), we
 416   // need a different profile, and creating a popup window with an incognito
 417   // profile is a quick and dirty way of achieving this.
 418   Browser* popup = CreateEmptyBrowserForType(
 419       Browser::TYPE_POPUP,
 420       browser()->profile()->GetOffTheRecordProfile());
 421   chrome::NavigateParams p(MakeNavigateParams(popup));
 422   p.disposition = NEW_FOREGROUND_TAB;
 423   chrome::Navigate(&p);
 424
 425   // Navigate() should have opened the tab in a different browser since the
 426   // one we supplied didn't support additional tabs.
 427   EXPECT_NE(popup, p.browser);
 428
 429   // This time, browser() is _not_ compatible with popup since it is not an
 430   // incognito window.
 431   EXPECT_NE(browser(), p.browser);
 432
 433   // We should have three windows, each with one tab:
 434   // 1. the browser() provided by the framework (unchanged in this test)
 435   // 2. the incognito popup we created originally
 436   // 3. the new incognito tabbed browser that was created by Navigate().
 437   EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
 438   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 439   EXPECT_EQ(1, popup->tab_strip_model()->count());
 440   EXPECT_EQ(1, p.browser->tab_strip_model()->count());
 441   EXPECT_TRUE(p.browser->is_type_tabbed());
 442 }
 443
 444 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 445 // from a normal Browser results in a new Browser with TYPE_POPUP.
 446 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopup) {
 447   chrome::NavigateParams p(MakeNavigateParams());
 448   p.disposition = NEW_POPUP;
 449   p.window_bounds = gfx::Rect(0, 0, 200, 200);
 450   // Wait for new popup to to load and gain focus.
 451   ui_test_utils::NavigateToURL(&p);
 452
 453   // Navigate() should have opened a new, focused popup window.
 454   EXPECT_NE(browser(), p.browser);
 455 #if 0
 456   // TODO(stevenjb): Enable this test. See: crbug.com/79493
 457   EXPECT_TRUE(p.browser->window()->IsActive());
 458 #endif
 459   EXPECT_TRUE(p.browser->is_type_popup());
 460   EXPECT_FALSE(p.browser->is_app());
 461
 462   // We should have two windows, the browser() provided by the framework and the
 463   // new popup window.
 464   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 465   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 466   EXPECT_EQ(1, p.browser->tab_strip_model()->count());
 467 }
 468
 469 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 470 // from a normal Browser results in a new Browser with is_app() true.
 471 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopup_ExtensionId) {
 472   chrome::NavigateParams p(MakeNavigateParams());
 473   p.disposition = NEW_POPUP;
 474   p.extension_app_id = "extensionappid";
 475   p.window_bounds = gfx::Rect(0, 0, 200, 200);
 476   // Wait for new popup to to load and gain focus.
 477   ui_test_utils::NavigateToURL(&p);
 478
 479   // Navigate() should have opened a new, focused popup window.
 480   EXPECT_NE(browser(), p.browser);
 481   EXPECT_TRUE(p.browser->is_type_popup());
 482   EXPECT_TRUE(p.browser->is_app());
 483
 484   // We should have two windows, the browser() provided by the framework and the
 485   // new popup window.
 486   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 487   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 488   EXPECT_EQ(1, p.browser->tab_strip_model()->count());
 489 }
 490
 491 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 492 // from a normal popup results in a new Browser with TYPE_POPUP.
 493 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopupFromPopup) {
 494   // Open a popup.
 495   chrome::NavigateParams p1(MakeNavigateParams());
 496   p1.disposition = NEW_POPUP;
 497   p1.window_bounds = gfx::Rect(0, 0, 200, 200);
 498   chrome::Navigate(&p1);
 499   // Open another popup.
 500   chrome::NavigateParams p2(MakeNavigateParams(p1.browser));
 501   p2.disposition = NEW_POPUP;
 502   p2.window_bounds = gfx::Rect(0, 0, 200, 200);
 503   chrome::Navigate(&p2);
 504
 505   // Navigate() should have opened a new normal popup window.
 506   EXPECT_NE(p1.browser, p2.browser);
 507   EXPECT_TRUE(p2.browser->is_type_popup());
 508   EXPECT_FALSE(p2.browser->is_app());
 509
 510   // We should have three windows, the browser() provided by the framework,
 511   // the first popup window, and the second popup window.
 512   EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
 513   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 514   EXPECT_EQ(1, p1.browser->tab_strip_model()->count());
 515   EXPECT_EQ(1, p2.browser->tab_strip_model()->count());
 516 }
 517
 518 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 519 // from an app frame results in a new Browser with TYPE_POPUP.
 520 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 521                        Disposition_NewPopupFromAppWindow) {
 522   Browser* app_browser = CreateEmptyBrowserForApp(browser()->profile());
 523   chrome::NavigateParams p(MakeNavigateParams(app_browser));
 524   p.disposition = NEW_POPUP;
 525   p.window_bounds = gfx::Rect(0, 0, 200, 200);
 526   chrome::Navigate(&p);
 527
 528   // Navigate() should have opened a new popup app window.
 529   EXPECT_NE(app_browser, p.browser);
 530   EXPECT_NE(browser(), p.browser);
 531   EXPECT_TRUE(p.browser->is_type_popup());
 532   EXPECT_TRUE(p.browser->is_app());
 533
 534   // We should now have three windows, the app window, the app popup it created,
 535   // and the original browser() provided by the framework.
 536   EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
 537   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 538   EXPECT_EQ(1, app_browser->tab_strip_model()->count());
 539   EXPECT_EQ(1, p.browser->tab_strip_model()->count());
 540 }
 541
 542 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 543 // from an app popup results in a new Browser also of TYPE_POPUP.
 544 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 545                        Disposition_NewPopupFromAppPopup) {
 546   Browser* app_browser = CreateEmptyBrowserForApp(browser()->profile());
 547   // Open an app popup.
 548   chrome::NavigateParams p1(MakeNavigateParams(app_browser));
 549   p1.disposition = NEW_POPUP;
 550   p1.window_bounds = gfx::Rect(0, 0, 200, 200);
 551   chrome::Navigate(&p1);
 552   // Now open another app popup.
 553   chrome::NavigateParams p2(MakeNavigateParams(p1.browser));
 554   p2.disposition = NEW_POPUP;
 555   p2.window_bounds = gfx::Rect(0, 0, 200, 200);
 556   chrome::Navigate(&p2);
 557
 558   // Navigate() should have opened a new popup app window.
 559   EXPECT_NE(browser(), p1.browser);
 560   EXPECT_NE(p1.browser, p2.browser);
 561   EXPECT_TRUE(p2.browser->is_type_popup());
 562   EXPECT_TRUE(p2.browser->is_app());
 563
 564   // We should now have four windows, the app window, the first app popup,
 565   // the second app popup, and the original browser() provided by the framework.
 566   EXPECT_EQ(4u, chrome::GetTotalBrowserCount());
 567   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 568   EXPECT_EQ(1, app_browser->tab_strip_model()->count());
 569   EXPECT_EQ(1, p1.browser->tab_strip_model()->count());
 570   EXPECT_EQ(1, p2.browser->tab_strip_model()->count());
 571 }
 572
 573 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 574 // from an extension app tab results in a new Browser with TYPE_APP_POPUP.
 575 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 576                        Disposition_NewPopupFromExtensionApp) {
 577   // TODO(beng): TBD.
 578 }
 579
 580 // This test verifies that navigating with window_action = SHOW_WINDOW_INACTIVE
 581 // does not focus a new new popup window.
 582 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopupUnfocused) {
 583   chrome::NavigateParams p(MakeNavigateParams());
 584   p.disposition = NEW_POPUP;
 585   p.window_bounds = gfx::Rect(0, 0, 200, 200);
 586   p.window_action = chrome::NavigateParams::SHOW_WINDOW_INACTIVE;
 587   // Wait for new popup to load (and gain focus if the test fails).
 588   ui_test_utils::NavigateToURL(&p);
 589
 590   // Navigate() should have opened a new, unfocused, popup window.
 591   EXPECT_NE(browser(), p.browser);
 592   EXPECT_EQ(Browser::TYPE_POPUP, p.browser->type());
 593 #if 0
 594 // TODO(stevenjb): Enable this test. See: crbug.com/79493
 595   EXPECT_FALSE(p.browser->window()->IsActive());
 596 #endif
 597 }
 598
 599 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 600 // and trusted_source = true results in a new Browser where is_trusted_source()
 601 // is true.
 602 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopupTrusted) {
 603   chrome::NavigateParams p(MakeNavigateParams());
 604   p.disposition = NEW_POPUP;
 605   p.trusted_source = true;
 606   p.window_bounds = gfx::Rect(0, 0, 200, 200);
 607   // Wait for new popup to to load and gain focus.
 608   ui_test_utils::NavigateToURL(&p);
 609
 610   // Navigate() should have opened a new popup window of TYPE_TRUSTED_POPUP.
 611   EXPECT_NE(browser(), p.browser);
 612   EXPECT_TRUE(p.browser->is_type_popup());
 613   EXPECT_TRUE(p.browser->is_trusted_source());
 614 }
 615
 616
 617 // This test verifies that navigating with WindowOpenDisposition = NEW_WINDOW
 618 // always opens a new window.
 619 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewWindow) {
 620   chrome::NavigateParams p(MakeNavigateParams());
 621   p.disposition = NEW_WINDOW;
 622   chrome::Navigate(&p);
 623
 624   // Navigate() should have opened a new toplevel window.
 625   EXPECT_NE(browser(), p.browser);
 626   EXPECT_TRUE(p.browser->is_type_tabbed());
 627
 628   // We should now have two windows, the browser() provided by the framework and
 629   // the new normal window.
 630   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 631   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 632   EXPECT_EQ(1, p.browser->tab_strip_model()->count());
 633 }
 634
 635 // This test verifies that navigating with WindowOpenDisposition = INCOGNITO
 636 // opens a new incognito window if no existing incognito window is present.
 637 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_Incognito) {
 638   chrome::NavigateParams p(MakeNavigateParams());
 639   p.disposition = OFF_THE_RECORD;
 640   chrome::Navigate(&p);
 641
 642   // Navigate() should have opened a new toplevel incognito window.
 643   EXPECT_NE(browser(), p.browser);
 644   EXPECT_EQ(browser()->profile()->GetOffTheRecordProfile(),
 645             p.browser->profile());
 646
 647   // |source_contents| should be set to NULL because the profile for the new
 648   // page is different from the originating page.
 649   EXPECT_EQ(NULL, p.source_contents);
 650
 651   // We should now have two windows, the browser() provided by the framework and
 652   // the new incognito window.
 653   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 654   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 655   EXPECT_EQ(1, p.browser->tab_strip_model()->count());
 656 }
 657
 658 // This test verifies that navigating with WindowOpenDisposition = INCOGNITO
 659 // reuses an existing incognito window when possible.
 660 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_IncognitoRefocus) {
 661   Browser* incognito_browser =
 662       CreateEmptyBrowserForType(Browser::TYPE_TABBED,
 663                                 browser()->profile()->GetOffTheRecordProfile());
 664   chrome::NavigateParams p(MakeNavigateParams());
 665   p.disposition = OFF_THE_RECORD;
 666   chrome::Navigate(&p);
 667
 668   // Navigate() should have opened a new tab in the existing incognito window.
 669   EXPECT_NE(browser(), p.browser);
 670   EXPECT_EQ(p.browser, incognito_browser);
 671
 672   // We should now have two windows, the browser() provided by the framework and
 673   // the incognito window we opened earlier.
 674   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 675   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 676   EXPECT_EQ(2, incognito_browser->tab_strip_model()->count());
 677 }
 678
 679 // This test verifies that no navigation action occurs when
 680 // WindowOpenDisposition = SUPPRESS_OPEN.
 681 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_SuppressOpen) {
 682   RunSuppressTest(SUPPRESS_OPEN);
 683 }
 684
 685 // This test verifies that no navigation action occurs when
 686 // WindowOpenDisposition = SAVE_TO_DISK.
 687 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_SaveToDisk) {
 688   RunSuppressTest(SAVE_TO_DISK);
 689 }
 690
 691 // This test verifies that no navigation action occurs when
 692 // WindowOpenDisposition = IGNORE_ACTION.
 693 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_IgnoreAction) {
 694   RunSuppressTest(IGNORE_ACTION);
 695 }
 696
 697 // This tests adding a foreground tab with a predefined WebContents.
 698 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, TargetContents_ForegroundTab) {
 699   chrome::NavigateParams p(MakeNavigateParams());
 700   p.disposition = NEW_FOREGROUND_TAB;
 701   p.target_contents = CreateWebContents();
 702   chrome::Navigate(&p);
 703
 704   // Navigate() should have opened the contents in a new foreground in the
 705   // current Browser.
 706   EXPECT_EQ(browser(), p.browser);
 707   EXPECT_EQ(browser()->tab_strip_model()->GetActiveWebContents(),
 708             p.target_contents);
 709
 710   // We should have one window, with two tabs.
 711   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 712   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 713 }
 714
 715 #if defined(OS_WIN)
 716 // This tests adding a popup with a predefined WebContents.
 717 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, DISABLED_TargetContents_Popup) {
 718   chrome::NavigateParams p(MakeNavigateParams());
 719   p.disposition = NEW_POPUP;
 720   p.target_contents = CreateWebContents();
 721   p.window_bounds = gfx::Rect(10, 10, 500, 500);
 722   chrome::Navigate(&p);
 723
 724   // Navigate() should have opened a new popup window.
 725   EXPECT_NE(browser(), p.browser);
 726   EXPECT_TRUE(p.browser->is_type_popup());
 727   EXPECT_FALSE(p.browser->is_app());
 728
 729   // The web platform is weird. The window bounds specified in
 730   // |p.window_bounds| are used as follows:
 731   // - the origin is used to position the window
 732   // - the size is used to size the WebContents of the window.
 733   // As such the position of the resulting window will always match
 734   // p.window_bounds.origin(), but its size will not. We need to match
 735   // the size against the selected tab's view's container size.
 736   // Only Windows positions the window according to |p.window_bounds.origin()| -
 737   // on Mac the window is offset from the opener and on Linux it always opens
 738   // at 0,0.
 739   EXPECT_EQ(p.window_bounds.origin(),
 740             p.browser->window()->GetRestoredBounds().origin());
 741   // All platforms should respect size however provided width > 400 (Mac has a
 742   // minimum window width of 400).
 743   EXPECT_EQ(p.window_bounds.size(),
 744             p.target_contents->GetContainerBounds().size());
 745
 746   // We should have two windows, the new popup and the browser() provided by the
 747   // framework.
 748   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
 749   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 750   EXPECT_EQ(1, p.browser->tab_strip_model()->count());
 751 }
 752 #endif
 753
 754 // This tests adding a tab at a specific index.
 755 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Tabstrip_InsertAtIndex) {
 756   // This is not meant to be a comprehensive test of whether or not the tab
 757   // implementation of the browser observes the insertion index. That is
 758   // covered by the unit tests for TabStripModel. This merely verifies that
 759   // insertion index preference is reflected in common cases.
 760   chrome::NavigateParams p(MakeNavigateParams());
 761   p.disposition = NEW_FOREGROUND_TAB;
 762   p.tabstrip_index = 0;
 763   p.tabstrip_add_types = TabStripModel::ADD_FORCE_INDEX;
 764   chrome::Navigate(&p);
 765
 766   // Navigate() should have inserted a new tab at slot 0 in the tabstrip.
 767   EXPECT_EQ(browser(), p.browser);
 768   EXPECT_EQ(0, browser()->tab_strip_model()->GetIndexOfWebContents(
 769       static_cast<const WebContents*>(p.target_contents)));
 770
 771   // We should have one window - the browser() provided by the framework.
 772   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 773   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 774 }
 775
 776 // This test verifies that constructing params with disposition = SINGLETON_TAB
 777 // and IGNORE_AND_NAVIGATE opens a new tab navigated to the specified URL if
 778 // no previous tab with that URL (minus the path) exists.
 779 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 780                        Disposition_SingletonTabNew_IgnorePath) {
 781   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
 782                                 content::PAGE_TRANSITION_LINK);
 783
 784   // We should have one browser with 2 tabs, the 2nd selected.
 785   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 786   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 787   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 788
 789   // Navigate to a new singleton tab with a sub-page.
 790   chrome::NavigateParams p(MakeNavigateParams());
 791   p.disposition = SINGLETON_TAB;
 792   p.url = GetContentSettingsURL();
 793   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
 794   p.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
 795   chrome::Navigate(&p);
 796
 797   // The last tab should now be selected and navigated to the sub-page of the
 798   // URL.
 799   EXPECT_EQ(browser(), p.browser);
 800   EXPECT_EQ(3, browser()->tab_strip_model()->count());
 801   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 802   EXPECT_EQ(GetContentSettingsURL(),
 803             ShortenUberURL(browser()->tab_strip_model()->
 804                 GetActiveWebContents()->GetURL()));
 805 }
 806
 807 // This test verifies that constructing params with disposition = SINGLETON_TAB
 808 // and IGNORE_AND_NAVIGATE opens an existing tab with the matching URL (minus
 809 // the path) which is navigated to the specified URL.
 810 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 811                        Disposition_SingletonTabExisting_IgnorePath) {
 812   GURL singleton_url1(GetSettingsURL());
 813   chrome::AddSelectedTabWithURL(browser(), singleton_url1,
 814                                 content::PAGE_TRANSITION_LINK);
 815   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
 816                                 content::PAGE_TRANSITION_LINK);
 817
 818   // We should have one browser with 3 tabs, the 3rd selected.
 819   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 820   EXPECT_EQ(3, browser()->tab_strip_model()->count());
 821   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 822
 823   // Navigate to singleton_url1.
 824   chrome::NavigateParams p(MakeNavigateParams());
 825   p.disposition = SINGLETON_TAB;
 826   p.url = GetContentSettingsURL();
 827   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
 828   p.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
 829   chrome::Navigate(&p);
 830
 831   // The middle tab should now be selected and navigated to the sub-page of the
 832   // URL.
 833   EXPECT_EQ(browser(), p.browser);
 834   EXPECT_EQ(3, browser()->tab_strip_model()->count());
 835   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 836   EXPECT_EQ(GetContentSettingsURL(),
 837             ShortenUberURL(browser()->tab_strip_model()->
 838                 GetActiveWebContents()->GetURL()));
 839 }
 840
 841 // This test verifies that constructing params with disposition = SINGLETON_TAB
 842 // and IGNORE_AND_NAVIGATE opens an existing tab with the matching URL (minus
 843 // the path) which is navigated to the specified URL.
 844 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 845                        Disposition_SingletonTabExistingSubPath_IgnorePath) {
 846   GURL singleton_url1(GetContentSettingsURL());
 847   chrome::AddSelectedTabWithURL(browser(), singleton_url1,
 848                                 content::PAGE_TRANSITION_LINK);
 849   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
 850                                 content::PAGE_TRANSITION_LINK);
 851
 852   // We should have one browser with 3 tabs, the 3rd selected.
 853   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 854   EXPECT_EQ(3, browser()->tab_strip_model()->count());
 855   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 856
 857   // Navigate to singleton_url1.
 858   chrome::NavigateParams p(MakeNavigateParams());
 859   p.disposition = SINGLETON_TAB;
 860   p.url = GetClearBrowsingDataURL();
 861   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
 862   p.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
 863   chrome::Navigate(&p);
 864
 865   // The middle tab should now be selected and navigated to the sub-page of the
 866   // URL.
 867   EXPECT_EQ(browser(), p.browser);
 868   EXPECT_EQ(3, browser()->tab_strip_model()->count());
 869   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 870   EXPECT_EQ(GetClearBrowsingDataURL(),
 871             ShortenUberURL(browser()->tab_strip_model()->
 872                 GetActiveWebContents()->GetURL()));
 873 }
 874
 875 // This test verifies that constructing params with disposition = SINGLETON_TAB
 876 // and IGNORE_AND_STAY_PUT opens an existing tab with the matching URL (minus
 877 // the path).
 878 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 879                        Disposition_SingletonTabExistingSubPath_IgnorePath2) {
 880   GURL singleton_url1(GetContentSettingsURL());
 881   chrome::AddSelectedTabWithURL(browser(), singleton_url1,
 882                                 content::PAGE_TRANSITION_LINK);
 883   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
 884                                 content::PAGE_TRANSITION_LINK);
 885
 886   // We should have one browser with 3 tabs, the 3rd selected.
 887   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 888   EXPECT_EQ(3, browser()->tab_strip_model()->count());
 889   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 890
 891   // Navigate to singleton_url1.
 892   chrome::NavigateParams p(MakeNavigateParams());
 893   p.disposition = SINGLETON_TAB;
 894   p.url = GetClearBrowsingDataURL();
 895   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
 896   p.path_behavior = chrome::NavigateParams::IGNORE_AND_STAY_PUT;
 897   chrome::Navigate(&p);
 898
 899   // The middle tab should now be selected.
 900   EXPECT_EQ(browser(), p.browser);
 901   EXPECT_EQ(3, browser()->tab_strip_model()->count());
 902   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 903   EXPECT_EQ(singleton_url1,
 904             ShortenUberURL(browser()->tab_strip_model()->
 905                 GetActiveWebContents()->GetURL()));
 906 }
 907
 908 // This test verifies that constructing params with disposition = SINGLETON_TAB
 909 // and IGNORE_AND_NAVIGATE will update the current tab's URL if the currently
 910 // selected tab is a match but has a different path.
 911 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 912                        Disposition_SingletonTabFocused_IgnorePath) {
 913   GURL singleton_url_current(GetContentSettingsURL());
 914   chrome::AddSelectedTabWithURL(browser(), singleton_url_current,
 915                                 content::PAGE_TRANSITION_LINK);
 916
 917   // We should have one browser with 2 tabs, the 2nd selected.
 918   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 919   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 920   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 921
 922   // Navigate to a different settings path.
 923   GURL singleton_url_target(GetClearBrowsingDataURL());
 924   chrome::NavigateParams p(MakeNavigateParams());
 925   p.disposition = SINGLETON_TAB;
 926   p.url = singleton_url_target;
 927   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
 928   p.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
 929   chrome::Navigate(&p);
 930
 931   // The second tab should still be selected, but navigated to the new path.
 932   EXPECT_EQ(browser(), p.browser);
 933   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 934   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 935   EXPECT_EQ(singleton_url_target,
 936             ShortenUberURL(browser()->tab_strip_model()->
 937                 GetActiveWebContents()->GetURL()));
 938 }
 939
 940 // This test verifies that constructing params with disposition = SINGLETON_TAB
 941 // and IGNORE_AND_NAVIGATE will open an existing matching tab with a different
 942 // query.
 943 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 944                        Disposition_SingletonTabExisting_IgnoreQuery) {
 945   int initial_tab_count = browser()->tab_strip_model()->count();
 946   GURL singleton_url_current("chrome://settings/internet");
 947   chrome::AddSelectedTabWithURL(browser(), singleton_url_current,
 948                                 content::PAGE_TRANSITION_LINK);
 949
 950   EXPECT_EQ(initial_tab_count + 1, browser()->tab_strip_model()->count());
 951   EXPECT_EQ(initial_tab_count, browser()->tab_strip_model()->active_index());
 952
 953   // Navigate to a different settings path.
 954   GURL singleton_url_target(
 955       "chrome://settings/internet?"
 956       "servicePath=/profile/ethernet_00aa00aa00aa&networkType=1");
 957   chrome::NavigateParams p(MakeNavigateParams());
 958   p.disposition = SINGLETON_TAB;
 959   p.url = singleton_url_target;
 960   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
 961   p.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
 962   chrome::Navigate(&p);
 963
 964   // Last tab should still be selected.
 965   EXPECT_EQ(browser(), p.browser);
 966   EXPECT_EQ(initial_tab_count + 1, browser()->tab_strip_model()->count());
 967   EXPECT_EQ(initial_tab_count, browser()->tab_strip_model()->active_index());
 968 }
 969
 970 // This test verifies that the settings page isn't opened in the incognito
 971 // window.
 972 // Disabled until fixed for uber settings: http://crbug.com/111243
 973 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 974                        DISABLED_Disposition_Settings_UseNonIncognitoWindow) {
 975   RunUseNonIncognitoWindowTest(GetSettingsURL());
 976 }
 977
 978 // This test verifies that the view-source settings page isn't opened in the
 979 // incognito window.
 980 IN_PROC_BROWSER_TEST_F(
 981     BrowserNavigatorTest,
 982     Disposition_ViewSource_Settings_DoNothingIfIncognitoForced) {
 983   std::string view_source(content::kViewSourceScheme);
 984   view_source.append(":");
 985   view_source.append(chrome::kChromeUISettingsURL);
 986   RunDoNothingIfIncognitoIsForcedTest(GURL(view_source));
 987 }
 988
 989 // This test verifies that the view-source settings page isn't opened in the
 990 // incognito window even if incognito mode is forced (does nothing in that
 991 // case).
 992 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
 993                        Disposition_ViewSource_Settings_UseNonIncognitoWindow) {
 994   std::string view_source(content::kViewSourceScheme);
 995   view_source.append(":");
 996   view_source.append(chrome::kChromeUISettingsURL);
 997   RunUseNonIncognitoWindowTest(GURL(view_source));
 998 }
 999
1000 // This test verifies that the settings page isn't opened in the incognito
1001 // window from a non-incognito window (bookmark open-in-incognito trigger).
1002 // Disabled until fixed for uber settings: http://crbug.com/111243
1003 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1004     DISABLED_Disposition_Settings_UseNonIncognitoWindowForBookmark) {
1005   chrome::NavigateParams params(browser(), GetSettingsURL(),
1006                                 content::PAGE_TRANSITION_AUTO_BOOKMARK);
1007   params.disposition = OFF_THE_RECORD;
1008   {
1009     content::WindowedNotificationObserver observer(
1010         content::NOTIFICATION_LOAD_STOP,
1011         content::NotificationService::AllSources());
1012     chrome::Navigate(&params);
1013     observer.Wait();
1014   }
1015
1016   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
1017   EXPECT_EQ(GetSettingsURL(),
1018             ShortenUberURL(browser()->tab_strip_model()->
1019                 GetActiveWebContents()->GetURL()));
1020 }
1021
1022 // Settings page is expected to always open in normal mode regardless
1023 // of whether the user is trying to open it in incognito mode or not.
1024 // This test verifies that if incognito mode is forced (by policy), settings
1025 // page doesn't open at all.
1026 // Disabled until fixed for uber settings: http://crbug.com/111243
1027 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1028     DISABLED_Disposition_Settings_DoNothingIfIncognitoIsForced) {
1029   RunDoNothingIfIncognitoIsForcedTest(GetSettingsURL());
1030 }
1031
1032 // This test verifies that the bookmarks page isn't opened in the incognito
1033 // window.
1034 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1035                        Disposition_Bookmarks_UseNonIncognitoWindow) {
1036   RunUseNonIncognitoWindowTest(GURL(chrome::kChromeUIBookmarksURL));
1037 }
1038
1039 // Bookmark manager is expected to always open in normal mode regardless
1040 // of whether the user is trying to open it in incognito mode or not.
1041 // This test verifies that if incognito mode is forced (by policy), bookmark
1042 // manager doesn't open at all.
1043 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1044                        Disposition_Bookmarks_DoNothingIfIncognitoIsForced) {
1045   RunDoNothingIfIncognitoIsForcedTest(GURL(chrome::kChromeUIBookmarksURL));
1046 }
1047
1048 // This test makes sure a crashed singleton tab reloads from a new navigation.
1049 // http://crbug.com/396371
1050 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1051                        DISABLED_NavigateToCrashedSingletonTab) {
1052   GURL singleton_url(GetContentSettingsURL());
1053   WebContents* web_contents = chrome::AddSelectedTabWithURL(
1054       browser(), singleton_url, content::PAGE_TRANSITION_LINK);
1055
1056   // We should have one browser with 2 tabs, the 2nd selected.
1057   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
1058   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1059   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
1060
1061   // Kill the singleton tab.
1062   web_contents->SetIsCrashed(base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
1063   EXPECT_TRUE(web_contents->IsCrashed());
1064
1065   chrome::NavigateParams p(MakeNavigateParams());
1066   p.disposition = SINGLETON_TAB;
1067   p.url = singleton_url;
1068   p.window_action = chrome::NavigateParams::SHOW_WINDOW;
1069   p.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
1070   ui_test_utils::NavigateToURL(&p);
1071
1072   // The tab should not be sad anymore.
1073   EXPECT_FALSE(web_contents->IsCrashed());
1074 }
1075
1076 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1077                        NavigateFromDefaultToOptionsInSameTab) {
1078   {
1079     content::WindowedNotificationObserver observer(
1080         content::NOTIFICATION_LOAD_STOP,
1081         content::NotificationService::AllSources());
1082     chrome::ShowSettings(browser());
1083     observer.Wait();
1084   }
1085   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1086   EXPECT_EQ(GetSettingsURL(),
1087             ShortenUberURL(browser()->tab_strip_model()->
1088                 GetActiveWebContents()->GetURL()));
1089 }
1090
1091 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1092                        NavigateFromBlankToOptionsInSameTab) {
1093   chrome::NavigateParams p(MakeNavigateParams());
1094   p.url = GURL(url::kAboutBlankURL);
1095   ui_test_utils::NavigateToURL(&p);
1096
1097   {
1098     content::WindowedNotificationObserver observer(
1099         content::NOTIFICATION_LOAD_STOP,
1100         content::NotificationService::AllSources());
1101     chrome::ShowSettings(browser());
1102     observer.Wait();
1103   }
1104   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1105   EXPECT_EQ(GetSettingsURL(),
1106             ShortenUberURL(browser()->tab_strip_model()->
1107                 GetActiveWebContents()->GetURL()));
1108 }
1109
1110 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1111                        NavigateFromNTPToOptionsInSameTab) {
1112   chrome::NavigateParams p(MakeNavigateParams());
1113   p.url = GURL(chrome::kChromeUINewTabURL);
1114   ui_test_utils::NavigateToURL(&p);
1115   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1116   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
1117             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
1118
1119   {
1120     content::WindowedNotificationObserver observer(
1121         content::NOTIFICATION_LOAD_STOP,
1122         content::NotificationService::AllSources());
1123     chrome::ShowSettings(browser());
1124     observer.Wait();
1125   }
1126   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1127   EXPECT_EQ(GetSettingsURL(),
1128             ShortenUberURL(browser()->tab_strip_model()->
1129                 GetActiveWebContents()->GetURL()));
1130 }
1131
1132 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1133                        NavigateFromPageToOptionsInNewTab) {
1134   chrome::NavigateParams p(MakeNavigateParams());
1135   ui_test_utils::NavigateToURL(&p);
1136   EXPECT_EQ(GetGoogleURL(),
1137             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
1138   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
1139   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1140
1141   {
1142     content::WindowedNotificationObserver observer(
1143         content::NOTIFICATION_LOAD_STOP,
1144         content::NotificationService::AllSources());
1145     chrome::ShowSettings(browser());
1146     observer.Wait();
1147   }
1148   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1149   EXPECT_EQ(GetSettingsURL(),
1150             ShortenUberURL(browser()->tab_strip_model()->
1151                 GetActiveWebContents()->GetURL()));
1152 }
1153
1154 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1155                        NavigateFromNTPToOptionsSingleton) {
1156   {
1157     content::WindowedNotificationObserver observer(
1158         content::NOTIFICATION_LOAD_STOP,
1159         content::NotificationService::AllSources());
1160     chrome::ShowSettings(browser());
1161     observer.Wait();
1162   }
1163   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1164
1165   chrome::NewTab(browser());
1166   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1167
1168   {
1169     content::WindowedNotificationObserver observer(
1170         content::NOTIFICATION_LOAD_STOP,
1171         content::NotificationService::AllSources());
1172     chrome::ShowSettings(browser());
1173     observer.Wait();
1174   }
1175   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1176   EXPECT_EQ(GetSettingsURL(),
1177             ShortenUberURL(browser()->tab_strip_model()->
1178                 GetActiveWebContents()->GetURL()));
1179 }
1180
1181 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1182                        NavigateFromNTPToOptionsPageInSameTab) {
1183   {
1184     content::WindowedNotificationObserver observer(
1185         content::NOTIFICATION_LOAD_STOP,
1186         content::NotificationService::AllSources());
1187     chrome::ShowClearBrowsingDataDialog(browser());
1188     observer.Wait();
1189   }
1190   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1191   EXPECT_EQ(GetClearBrowsingDataURL(),
1192             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
1193
1194   chrome::NewTab(browser());
1195   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1196
1197   {
1198     content::WindowedNotificationObserver observer(
1199         content::NOTIFICATION_LOAD_STOP,
1200         content::NotificationService::AllSources());
1201     chrome::ShowClearBrowsingDataDialog(browser());
1202     observer.Wait();
1203   }
1204   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1205   EXPECT_EQ(GetClearBrowsingDataURL(),
1206             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
1207 }
1208
1209 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1210                        NavigateFromOtherTabToSingletonOptions) {
1211   {
1212     content::WindowedNotificationObserver observer(
1213         content::NOTIFICATION_LOAD_STOP,
1214         content::NotificationService::AllSources());
1215     chrome::ShowSettings(browser());
1216     observer.Wait();
1217   }
1218   {
1219     content::WindowedNotificationObserver observer(
1220         content::NOTIFICATION_LOAD_STOP,
1221         content::NotificationService::AllSources());
1222     chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
1223                                   content::PAGE_TRANSITION_LINK);
1224     observer.Wait();
1225   }
1226
1227   // This load should simply cause a tab switch.
1228   chrome::ShowSettings(browser());
1229
1230   EXPECT_EQ(2, browser()->tab_strip_model()->count());
1231   EXPECT_EQ(GetSettingsURL(),
1232             ShortenUberURL(browser()->tab_strip_model()->
1233                 GetActiveWebContents()->GetURL()));
1234 }
1235
1236 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, CloseSingletonTab) {
1237   for (int i = 0; i < 2; ++i) {
1238     content::WindowedNotificationObserver observer(
1239         content::NOTIFICATION_LOAD_STOP,
1240         content::NotificationService::AllSources());
1241     chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
1242                                   content::PAGE_TRANSITION_TYPED);
1243     observer.Wait();
1244   }
1245
1246   browser()->tab_strip_model()->ActivateTabAt(0, true);
1247
1248   {
1249     content::WindowedNotificationObserver observer(
1250         content::NOTIFICATION_LOAD_STOP,
1251         content::NotificationService::AllSources());
1252     chrome::ShowSettings(browser());
1253     observer.Wait();
1254   }
1255
1256   EXPECT_TRUE(browser()->tab_strip_model()->CloseWebContentsAt(
1257       2, TabStripModel::CLOSE_USER_GESTURE));
1258   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
1259 }
1260
1261 // TODO(csilv): Update this for uber page. http://crbug.com/111579.
1262 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1263                        DISABLED_NavigateFromDefaultToHistoryInSameTab) {
1264   {
1265     content::WindowedNotificationObserver observer(
1266         content::NOTIFICATION_LOAD_STOP,
1267         content::NotificationService::AllSources());
1268     chrome::ShowHistory(browser());
1269     observer.Wait();
1270   }
1271   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1272   EXPECT_EQ(GURL(chrome::kChromeUIHistoryFrameURL),
1273             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
1274 }
1275
1276 // TODO(linux_aura) http://crbug.com/163931
1277 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_AURA)
1278 #define MAYBE_NavigateFromDefaultToBookmarksInSameTab DISABLED_NavigateFromDefaultToBookmarksInSameTab
1279 #else
1280 #define MAYBE_NavigateFromDefaultToBookmarksInSameTab NavigateFromDefaultToBookmarksInSameTab
1281 #endif
1282 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1283                        MAYBE_NavigateFromDefaultToBookmarksInSameTab) {
1284   {
1285     content::WindowedNotificationObserver observer(
1286         content::NOTIFICATION_LOAD_STOP,
1287         content::NotificationService::AllSources());
1288     chrome::ShowBookmarkManager(browser());
1289     observer.Wait();
1290   }
1291   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1292   EXPECT_TRUE(StartsWithASCII(
1293       browser()->tab_strip_model()->GetActiveWebContents()->GetURL().spec(),
1294       chrome::kChromeUIBookmarksURL,
1295       true));
1296 }
1297
1298 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1299                        NavigateFromDefaultToDownloadsInSameTab) {
1300   {
1301     content::WindowedNotificationObserver observer(
1302         content::NOTIFICATION_LOAD_STOP,
1303         content::NotificationService::AllSources());
1304     chrome::ShowDownloads(browser());
1305     observer.Wait();
1306   }
1307   EXPECT_EQ(1, browser()->tab_strip_model()->count());
1308   EXPECT_EQ(GURL(chrome::kChromeUIDownloadsURL),
1309             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
1310 }
1311
1312 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1313                        NavigateWithoutBrowser) {
1314   // First navigate using the profile of the existing browser window, and
1315   // check that the window is reused.
1316   chrome::NavigateParams params(browser()->profile(), GetGoogleURL(),
1317                                 content::PAGE_TRANSITION_LINK);
1318   ui_test_utils::NavigateToURL(&params);
1319   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
1320
1321   // Now navigate using the incognito profile and check that a new window
1322   // is created.
1323   chrome::NavigateParams params_incognito(
1324       browser()->profile()->GetOffTheRecordProfile(),
1325       GetGoogleURL(), content::PAGE_TRANSITION_LINK);
1326   ui_test_utils::NavigateToURL(&params_incognito);
1327   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
1328 }
1329
1330 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, ViewSourceIsntSingleton) {
1331   const std::string viewsource_ntp_url =
1332       std::string(content::kViewSourceScheme) + ":" +
1333       chrome::kChromeUIVersionURL;
1334
1335   chrome::NavigateParams viewsource_params(browser(),
1336                                            GURL(viewsource_ntp_url),
1337                                            content::PAGE_TRANSITION_LINK);
1338   ui_test_utils::NavigateToURL(&viewsource_params);
1339
1340   chrome::NavigateParams singleton_params(browser(),
1341                                           GURL(chrome::kChromeUIVersionURL),
1342                                           content::PAGE_TRANSITION_LINK);
1343   singleton_params.disposition = SINGLETON_TAB;
1344   EXPECT_EQ(-1, chrome::GetIndexOfSingletonTab(&singleton_params));
1345 }
1346
1347 // This test verifies that browser initiated navigations can send requests
1348 // using POST.
1349 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1350                        SendBrowserInitiatedRequestUsingPOST) {
1351   // Uses a test sever to verify POST request.
1352   ASSERT_TRUE(test_server()->Start());
1353
1354   // Open a browser initiated POST request in new foreground tab.
1355   base::string16 expected_title(base::ASCIIToUTF16(kExpectedTitle));
1356   std::string post_data = kExpectedTitle;
1357   base::string16 title;
1358   ASSERT_TRUE(OpenPOSTURLInNewForegroundTabAndGetTitle(
1359       test_server()->GetURL(kEchoTitleCommand), post_data, true, &title));
1360   EXPECT_EQ(expected_title, title);
1361 }
1362
1363 // This test verifies that renderer initiated navigations can NOT send requests
1364 // using POST.
1365 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
1366                        SendRendererInitiatedRequestUsingPOST) {
1367   // Uses a test sever to verify POST request.
1368   ASSERT_TRUE(test_server()->Start());
1369
1370   // Open a renderer initiated POST request in new foreground tab.
1371   base::string16 expected_title(base::ASCIIToUTF16(kExpectedTitle));
1372   std::string post_data = kExpectedTitle;
1373   base::string16 title;
1374   ASSERT_TRUE(OpenPOSTURLInNewForegroundTabAndGetTitle(
1375       test_server()->GetURL(kEchoTitleCommand), post_data, false, &title));
1376   EXPECT_NE(expected_title, title);
1377 }
1378
1379 }  // namespace