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(¶m); 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(¶ms); 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 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1050 NavigateToCrashedSingletonTab) { 1051 GURL singleton_url(GetContentSettingsURL()); 1052 WebContents* web_contents = chrome::AddSelectedTabWithURL( 1053 browser(), singleton_url, content::PAGE_TRANSITION_LINK); 1054 1055 // We should have one browser with 2 tabs, the 2nd selected. 1056 EXPECT_EQ(1u, chrome::GetTotalBrowserCount()); 1057 EXPECT_EQ(2, browser()->tab_strip_model()->count()); 1058 EXPECT_EQ(1, browser()->tab_strip_model()->active_index()); 1059 1060 // Kill the singleton tab. 1061 web_contents->SetIsCrashed(base::TERMINATION_STATUS_PROCESS_CRASHED, -1); 1062 EXPECT_TRUE(web_contents->IsCrashed()); 1063 1064 chrome::NavigateParams p(MakeNavigateParams()); 1065 p.disposition = SINGLETON_TAB; 1066 p.url = singleton_url; 1067 p.window_action = chrome::NavigateParams::SHOW_WINDOW; 1068 p.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE; 1069 ui_test_utils::NavigateToURL(&p); 1070 1071 // The tab should not be sad anymore. 1072 EXPECT_FALSE(web_contents->IsCrashed()); 1073 } 1074 1075 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1076 NavigateFromDefaultToOptionsInSameTab) { 1077 { 1078 content::WindowedNotificationObserver observer( 1079 content::NOTIFICATION_LOAD_STOP, 1080 content::NotificationService::AllSources()); 1081 chrome::ShowSettings(browser()); 1082 observer.Wait(); 1083 } 1084 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1085 EXPECT_EQ(GetSettingsURL(), 1086 ShortenUberURL(browser()->tab_strip_model()-> 1087 GetActiveWebContents()->GetURL())); 1088 } 1089 1090 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1091 NavigateFromBlankToOptionsInSameTab) { 1092 chrome::NavigateParams p(MakeNavigateParams()); 1093 p.url = GURL(url::kAboutBlankURL); 1094 ui_test_utils::NavigateToURL(&p); 1095 1096 { 1097 content::WindowedNotificationObserver observer( 1098 content::NOTIFICATION_LOAD_STOP, 1099 content::NotificationService::AllSources()); 1100 chrome::ShowSettings(browser()); 1101 observer.Wait(); 1102 } 1103 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1104 EXPECT_EQ(GetSettingsURL(), 1105 ShortenUberURL(browser()->tab_strip_model()-> 1106 GetActiveWebContents()->GetURL())); 1107 } 1108 1109 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1110 NavigateFromNTPToOptionsInSameTab) { 1111 chrome::NavigateParams p(MakeNavigateParams()); 1112 p.url = GURL(chrome::kChromeUINewTabURL); 1113 ui_test_utils::NavigateToURL(&p); 1114 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1115 EXPECT_EQ(GURL(chrome::kChromeUINewTabURL), 1116 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 1117 1118 { 1119 content::WindowedNotificationObserver observer( 1120 content::NOTIFICATION_LOAD_STOP, 1121 content::NotificationService::AllSources()); 1122 chrome::ShowSettings(browser()); 1123 observer.Wait(); 1124 } 1125 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1126 EXPECT_EQ(GetSettingsURL(), 1127 ShortenUberURL(browser()->tab_strip_model()-> 1128 GetActiveWebContents()->GetURL())); 1129 } 1130 1131 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1132 NavigateFromPageToOptionsInNewTab) { 1133 chrome::NavigateParams p(MakeNavigateParams()); 1134 ui_test_utils::NavigateToURL(&p); 1135 EXPECT_EQ(GetGoogleURL(), 1136 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 1137 EXPECT_EQ(1u, chrome::GetTotalBrowserCount()); 1138 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1139 1140 { 1141 content::WindowedNotificationObserver observer( 1142 content::NOTIFICATION_LOAD_STOP, 1143 content::NotificationService::AllSources()); 1144 chrome::ShowSettings(browser()); 1145 observer.Wait(); 1146 } 1147 EXPECT_EQ(2, browser()->tab_strip_model()->count()); 1148 EXPECT_EQ(GetSettingsURL(), 1149 ShortenUberURL(browser()->tab_strip_model()-> 1150 GetActiveWebContents()->GetURL())); 1151 } 1152 1153 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1154 NavigateFromNTPToOptionsSingleton) { 1155 { 1156 content::WindowedNotificationObserver observer( 1157 content::NOTIFICATION_LOAD_STOP, 1158 content::NotificationService::AllSources()); 1159 chrome::ShowSettings(browser()); 1160 observer.Wait(); 1161 } 1162 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1163 1164 chrome::NewTab(browser()); 1165 EXPECT_EQ(2, browser()->tab_strip_model()->count()); 1166 1167 { 1168 content::WindowedNotificationObserver observer( 1169 content::NOTIFICATION_LOAD_STOP, 1170 content::NotificationService::AllSources()); 1171 chrome::ShowSettings(browser()); 1172 observer.Wait(); 1173 } 1174 EXPECT_EQ(2, browser()->tab_strip_model()->count()); 1175 EXPECT_EQ(GetSettingsURL(), 1176 ShortenUberURL(browser()->tab_strip_model()-> 1177 GetActiveWebContents()->GetURL())); 1178 } 1179 1180 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1181 NavigateFromNTPToOptionsPageInSameTab) { 1182 { 1183 content::WindowedNotificationObserver observer( 1184 content::NOTIFICATION_LOAD_STOP, 1185 content::NotificationService::AllSources()); 1186 chrome::ShowClearBrowsingDataDialog(browser()); 1187 observer.Wait(); 1188 } 1189 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1190 EXPECT_EQ(GetClearBrowsingDataURL(), 1191 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 1192 1193 chrome::NewTab(browser()); 1194 EXPECT_EQ(2, browser()->tab_strip_model()->count()); 1195 1196 { 1197 content::WindowedNotificationObserver observer( 1198 content::NOTIFICATION_LOAD_STOP, 1199 content::NotificationService::AllSources()); 1200 chrome::ShowClearBrowsingDataDialog(browser()); 1201 observer.Wait(); 1202 } 1203 EXPECT_EQ(2, browser()->tab_strip_model()->count()); 1204 EXPECT_EQ(GetClearBrowsingDataURL(), 1205 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 1206 } 1207 1208 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1209 NavigateFromOtherTabToSingletonOptions) { 1210 { 1211 content::WindowedNotificationObserver observer( 1212 content::NOTIFICATION_LOAD_STOP, 1213 content::NotificationService::AllSources()); 1214 chrome::ShowSettings(browser()); 1215 observer.Wait(); 1216 } 1217 { 1218 content::WindowedNotificationObserver observer( 1219 content::NOTIFICATION_LOAD_STOP, 1220 content::NotificationService::AllSources()); 1221 chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(), 1222 content::PAGE_TRANSITION_LINK); 1223 observer.Wait(); 1224 } 1225 1226 // This load should simply cause a tab switch. 1227 chrome::ShowSettings(browser()); 1228 1229 EXPECT_EQ(2, browser()->tab_strip_model()->count()); 1230 EXPECT_EQ(GetSettingsURL(), 1231 ShortenUberURL(browser()->tab_strip_model()-> 1232 GetActiveWebContents()->GetURL())); 1233 } 1234 1235 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, CloseSingletonTab) { 1236 for (int i = 0; i < 2; ++i) { 1237 content::WindowedNotificationObserver observer( 1238 content::NOTIFICATION_LOAD_STOP, 1239 content::NotificationService::AllSources()); 1240 chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(), 1241 content::PAGE_TRANSITION_TYPED); 1242 observer.Wait(); 1243 } 1244 1245 browser()->tab_strip_model()->ActivateTabAt(0, true); 1246 1247 { 1248 content::WindowedNotificationObserver observer( 1249 content::NOTIFICATION_LOAD_STOP, 1250 content::NotificationService::AllSources()); 1251 chrome::ShowSettings(browser()); 1252 observer.Wait(); 1253 } 1254 1255 EXPECT_TRUE(browser()->tab_strip_model()->CloseWebContentsAt( 1256 2, TabStripModel::CLOSE_USER_GESTURE)); 1257 EXPECT_EQ(0, browser()->tab_strip_model()->active_index()); 1258 } 1259 1260 // TODO(csilv): Update this for uber page. http://crbug.com/111579. 1261 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1262 DISABLED_NavigateFromDefaultToHistoryInSameTab) { 1263 { 1264 content::WindowedNotificationObserver observer( 1265 content::NOTIFICATION_LOAD_STOP, 1266 content::NotificationService::AllSources()); 1267 chrome::ShowHistory(browser()); 1268 observer.Wait(); 1269 } 1270 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1271 EXPECT_EQ(GURL(chrome::kChromeUIHistoryFrameURL), 1272 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 1273 } 1274 1275 // TODO(linux_aura) http://crbug.com/163931 1276 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_AURA) 1277 #define MAYBE_NavigateFromDefaultToBookmarksInSameTab DISABLED_NavigateFromDefaultToBookmarksInSameTab 1278 #else 1279 #define MAYBE_NavigateFromDefaultToBookmarksInSameTab NavigateFromDefaultToBookmarksInSameTab 1280 #endif 1281 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1282 MAYBE_NavigateFromDefaultToBookmarksInSameTab) { 1283 { 1284 content::WindowedNotificationObserver observer( 1285 content::NOTIFICATION_LOAD_STOP, 1286 content::NotificationService::AllSources()); 1287 chrome::ShowBookmarkManager(browser()); 1288 observer.Wait(); 1289 } 1290 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1291 EXPECT_TRUE(StartsWithASCII( 1292 browser()->tab_strip_model()->GetActiveWebContents()->GetURL().spec(), 1293 chrome::kChromeUIBookmarksURL, 1294 true)); 1295 } 1296 1297 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1298 NavigateFromDefaultToDownloadsInSameTab) { 1299 { 1300 content::WindowedNotificationObserver observer( 1301 content::NOTIFICATION_LOAD_STOP, 1302 content::NotificationService::AllSources()); 1303 chrome::ShowDownloads(browser()); 1304 observer.Wait(); 1305 } 1306 EXPECT_EQ(1, browser()->tab_strip_model()->count()); 1307 EXPECT_EQ(GURL(chrome::kChromeUIDownloadsURL), 1308 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 1309 } 1310 1311 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1312 NavigateWithoutBrowser) { 1313 // First navigate using the profile of the existing browser window, and 1314 // check that the window is reused. 1315 chrome::NavigateParams params(browser()->profile(), GetGoogleURL(), 1316 content::PAGE_TRANSITION_LINK); 1317 ui_test_utils::NavigateToURL(¶ms); 1318 EXPECT_EQ(1u, chrome::GetTotalBrowserCount()); 1319 1320 // Now navigate using the incognito profile and check that a new window 1321 // is created. 1322 chrome::NavigateParams params_incognito( 1323 browser()->profile()->GetOffTheRecordProfile(), 1324 GetGoogleURL(), content::PAGE_TRANSITION_LINK); 1325 ui_test_utils::NavigateToURL(¶ms_incognito); 1326 EXPECT_EQ(2u, chrome::GetTotalBrowserCount()); 1327 } 1328 1329 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, ViewSourceIsntSingleton) { 1330 const std::string viewsource_ntp_url = 1331 std::string(content::kViewSourceScheme) + ":" + 1332 chrome::kChromeUIVersionURL; 1333 1334 chrome::NavigateParams viewsource_params(browser(), 1335 GURL(viewsource_ntp_url), 1336 content::PAGE_TRANSITION_LINK); 1337 ui_test_utils::NavigateToURL(&viewsource_params); 1338 1339 chrome::NavigateParams singleton_params(browser(), 1340 GURL(chrome::kChromeUIVersionURL), 1341 content::PAGE_TRANSITION_LINK); 1342 singleton_params.disposition = SINGLETON_TAB; 1343 EXPECT_EQ(-1, chrome::GetIndexOfSingletonTab(&singleton_params)); 1344 } 1345 1346 // This test verifies that browser initiated navigations can send requests 1347 // using POST. 1348 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1349 SendBrowserInitiatedRequestUsingPOST) { 1350 // Uses a test sever to verify POST request. 1351 ASSERT_TRUE(test_server()->Start()); 1352 1353 // Open a browser initiated POST request in new foreground tab. 1354 base::string16 expected_title(base::ASCIIToUTF16(kExpectedTitle)); 1355 std::string post_data = kExpectedTitle; 1356 base::string16 title; 1357 ASSERT_TRUE(OpenPOSTURLInNewForegroundTabAndGetTitle( 1358 test_server()->GetURL(kEchoTitleCommand), post_data, true, &title)); 1359 EXPECT_EQ(expected_title, title); 1360 } 1361 1362 // This test verifies that renderer initiated navigations can NOT send requests 1363 // using POST. 1364 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, 1365 SendRendererInitiatedRequestUsingPOST) { 1366 // Uses a test sever to verify POST request. 1367 ASSERT_TRUE(test_server()->Start()); 1368 1369 // Open a renderer initiated POST request in new foreground tab. 1370 base::string16 expected_title(base::ASCIIToUTF16(kExpectedTitle)); 1371 std::string post_data = kExpectedTitle; 1372 base::string16 title; 1373 ASSERT_TRUE(OpenPOSTURLInNewForegroundTabAndGetTitle( 1374 test_server()->GetURL(kEchoTitleCommand), post_data, false, &title)); 1375 EXPECT_NE(expected_title, title); 1376 } 1377 1378 } // namespace 1379
