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