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 31using content::WebContents; 32 33namespace { 34 35const char kExpectedTitle[] = "PASSED!"; 36const char kEchoTitleCommand[] = "echotitle"; 37 38GURL GetGoogleURL() { 39 return GURL("http://www.google.com/"); 40} 41 42GURL GetSettingsURL() { 43 return GURL(chrome::kChromeUISettingsURL); 44} 45 46GURL GetContentSettingsURL() { 47 return GetSettingsURL().Resolve(chrome::kContentSettingsExceptionsSubPage); 48} 49 50GURL 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. 58GURL 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 70chrome::NavigateParams BrowserNavigatorTest::MakeNavigateParams() const { 71 return MakeNavigateParams(browser()); 72} 73 74chrome::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 82bool 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 110Browser* 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 118Browser* 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 127WebContents* 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 138void 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 151void 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 173void 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 199void 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 205void 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 220namespace { 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. 226IN_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. 237IN_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 277IN_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 327IN_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. 350IN_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. 365IN_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. 382IN_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. 410IN_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. 446IN_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. 471IN_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. 493IN_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. 520IN_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. 544IN_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. 575IN_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. 582IN_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. 602IN_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. 619IN_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. 637IN_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. 660IN_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. 681IN_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. 687IN_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. 693IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_IgnoreAction) { 694 RunSuppressTest(IGNORE_ACTION); 695} 696 697// This tests adding a foreground tab with a predefined WebContents. 698IN_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. 717IN_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. 755IN_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. 779IN_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. 810IN_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. 844IN_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). 878IN_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. 911IN_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. 943IN_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 973IN_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. 980IN_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). 992IN_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 1003IN_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 1027IN_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. 1034IN_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. 1043IN_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. 1049IN_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 1075IN_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 1090IN_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 1109IN_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 1131IN_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 1153IN_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 1180IN_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 1208IN_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 1235IN_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. 1261IN_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 1281IN_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 1297IN_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 1311IN_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 1329IN_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. 1348IN_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. 1364IN_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