1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/basictypes.h" 6 #include "base/command_line.h" 7 #include "base/files/file_path.h" 8 #include "base/run_loop.h" 9 #include "base/strings/utf_string_conversions.h" 10 #include "base/test/test_timeouts.h" 11 #include "chrome/app/chrome_command_ids.h" 12 #include "chrome/browser/chrome_notification_types.h" 13 #include "chrome/browser/sessions/tab_restore_service.h" 14 #include "chrome/browser/sessions/tab_restore_service_factory.h" 15 #include "chrome/browser/sessions/tab_restore_service_observer.h" 16 #include "chrome/browser/ui/browser.h" 17 #include "chrome/browser/ui/browser_commands.h" 18 #include "chrome/browser/ui/browser_list.h" 19 #include "chrome/browser/ui/browser_tabstrip.h" 20 #include "chrome/browser/ui/find_bar/find_notification_details.h" 21 #include "chrome/browser/ui/tabs/tab_strip_model.h" 22 #include "chrome/common/chrome_paths.h" 23 #include "chrome/common/url_constants.h" 24 #include "chrome/test/base/in_process_browser_test.h" 25 #include "chrome/test/base/ui_test_utils.h" 26 #include "content/public/browser/navigation_controller.h" 27 #include "content/public/browser/notification_service.h" 28 #include "content/public/browser/notification_source.h" 29 #include "content/public/browser/notification_types.h" 30 #include "content/public/browser/page_navigator.h" 31 #include "content/public/browser/render_view_host.h" 32 #include "content/public/browser/web_contents.h" 33 #include "content/public/test/browser_test_utils.h" 34 #include "net/base/net_util.h" 35 #include "net/test/embedded_test_server/embedded_test_server.h" 36 #include "third_party/WebKit/public/web/WebFindOptions.h" 37 #include "url/gurl.h" 38 39 // Class used to run a message loop waiting for the TabRestoreService to finish 40 // loading. Does nothing if the TabRestoreService was already loaded. 41 class WaitForLoadObserver : public TabRestoreServiceObserver { 42 public: 43 explicit WaitForLoadObserver(Browser* browser) 44 : tab_restore_service_( 45 TabRestoreServiceFactory::GetForProfile(browser->profile())), 46 do_wait_(!tab_restore_service_->IsLoaded()) { 47 if (do_wait_) 48 tab_restore_service_->AddObserver(this); 49 } 50 51 virtual ~WaitForLoadObserver() { 52 if (do_wait_) 53 tab_restore_service_->RemoveObserver(this); 54 } 55 56 void Wait() { 57 if (do_wait_) 58 run_loop_.Run(); 59 } 60 61 private: 62 // Overridden from TabRestoreServiceObserver: 63 virtual void TabRestoreServiceChanged(TabRestoreService* service) OVERRIDE {} 64 virtual void TabRestoreServiceDestroyed(TabRestoreService* service) OVERRIDE { 65 } 66 virtual void TabRestoreServiceLoaded(TabRestoreService* service) OVERRIDE { 67 DCHECK(do_wait_); 68 run_loop_.Quit(); 69 } 70 71 TabRestoreService* tab_restore_service_; 72 const bool do_wait_; 73 base::RunLoop run_loop_; 74 75 DISALLOW_COPY_AND_ASSIGN(WaitForLoadObserver); 76 }; 77 78 class TabRestoreTest : public InProcessBrowserTest { 79 public: 80 TabRestoreTest() : active_browser_list_(NULL) { 81 url1_ = ui_test_utils::GetTestUrl( 82 base::FilePath().AppendASCII("session_history"), 83 base::FilePath().AppendASCII("bot1.html")); 84 url2_ = ui_test_utils::GetTestUrl( 85 base::FilePath().AppendASCII("session_history"), 86 base::FilePath().AppendASCII("bot2.html")); 87 } 88 89 protected: 90 virtual void SetUpOnMainThread() OVERRIDE { 91 active_browser_list_ = BrowserList::GetInstance(chrome::GetActiveDesktop()); 92 InProcessBrowserTest::SetUpOnMainThread(); 93 } 94 95 Browser* GetBrowser(int index) { 96 CHECK(static_cast<int>(active_browser_list_->size()) > index); 97 return active_browser_list_->get(index); 98 } 99 100 // Adds tabs to the given browser, all navigated to url1_. Returns 101 // the final number of tabs. 102 int AddSomeTabs(Browser* browser, int how_many) { 103 int starting_tab_count = browser->tab_strip_model()->count(); 104 105 for (int i = 0; i < how_many; ++i) { 106 ui_test_utils::NavigateToURLWithDisposition( 107 browser, url1_, NEW_FOREGROUND_TAB, 108 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 109 } 110 int tab_count = browser->tab_strip_model()->count(); 111 EXPECT_EQ(starting_tab_count + how_many, tab_count); 112 return tab_count; 113 } 114 115 void CloseTab(int index) { 116 content::WebContentsDestroyedWatcher destroyed_watcher( 117 browser()->tab_strip_model()->GetWebContentsAt(index)); 118 browser()->tab_strip_model()->CloseWebContentsAt( 119 index, TabStripModel::CLOSE_CREATE_HISTORICAL_TAB); 120 destroyed_watcher.Wait(); 121 } 122 123 // Uses the undo-close-tab accelerator to undo a close-tab or close-window 124 // operation. The newly restored tab is expected to appear in the 125 // window at index |expected_window_index|, at the |expected_tabstrip_index|, 126 // and to be active. If |expected_window_index| is equal to the number of 127 // current windows, the restored tab is expected to be created in a new 128 // window (since the index is 0-based). 129 void RestoreTab(int expected_window_index, int expected_tabstrip_index) { 130 int window_count = static_cast<int>(active_browser_list_->size()); 131 ASSERT_GT(window_count, 0); 132 133 bool expect_new_window = (expected_window_index == window_count); 134 135 Browser* browser; 136 if (expect_new_window) { 137 browser = active_browser_list_->get(0); 138 } else { 139 browser = GetBrowser(expected_window_index); 140 } 141 int tab_count = browser->tab_strip_model()->count(); 142 ASSERT_GT(tab_count, 0); 143 144 // Restore the tab. 145 content::WindowedNotificationObserver tab_added_observer( 146 chrome::NOTIFICATION_TAB_PARENTED, 147 content::NotificationService::AllSources()); 148 content::WindowedNotificationObserver tab_loaded_observer( 149 content::NOTIFICATION_LOAD_STOP, 150 content::NotificationService::AllSources()); 151 { 152 WaitForLoadObserver waiter(browser); 153 chrome::RestoreTab(browser); 154 waiter.Wait(); 155 } 156 tab_added_observer.Wait(); 157 tab_loaded_observer.Wait(); 158 159 if (expect_new_window) { 160 int new_window_count = static_cast<int>(active_browser_list_->size()); 161 EXPECT_EQ(++window_count, new_window_count); 162 browser = GetBrowser(expected_window_index); 163 } else { 164 EXPECT_EQ(++tab_count, browser->tab_strip_model()->count()); 165 } 166 167 // Get a handle to the restored tab. 168 ASSERT_GT(browser->tab_strip_model()->count(), expected_tabstrip_index); 169 170 // Ensure that the tab and window are active. 171 EXPECT_EQ(expected_tabstrip_index, 172 browser->tab_strip_model()->active_index()); 173 } 174 175 void GoBack(Browser* browser) { 176 content::WindowedNotificationObserver observer( 177 content::NOTIFICATION_LOAD_STOP, 178 content::NotificationService::AllSources()); 179 chrome::GoBack(browser, CURRENT_TAB); 180 observer.Wait(); 181 } 182 183 void EnsureTabFinishedRestoring(content::WebContents* tab) { 184 content::NavigationController* controller = &tab->GetController(); 185 if (!controller->NeedsReload() && !controller->GetPendingEntry() && 186 !controller->GetWebContents()->IsLoading()) 187 return; 188 189 content::WindowedNotificationObserver observer( 190 content::NOTIFICATION_LOAD_STOP, 191 content::Source<content::NavigationController>(controller)); 192 observer.Wait(); 193 } 194 195 GURL url1_; 196 GURL url2_; 197 198 const BrowserList* active_browser_list_; 199 200 private: 201 DISALLOW_COPY_AND_ASSIGN(TabRestoreTest); 202 }; 203 204 // Close the end tab in the current window, then restore it. The tab should be 205 // in its original position, and active. 206 IN_PROC_BROWSER_TEST_F(TabRestoreTest, Basic) { 207 int starting_tab_count = browser()->tab_strip_model()->count(); 208 int tab_count = AddSomeTabs(browser(), 1); 209 210 int closed_tab_index = tab_count - 1; 211 CloseTab(closed_tab_index); 212 EXPECT_EQ(starting_tab_count, browser()->tab_strip_model()->count()); 213 214 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, closed_tab_index)); 215 216 // And make sure everything looks right. 217 EXPECT_EQ(starting_tab_count + 1, browser()->tab_strip_model()->count()); 218 EXPECT_EQ(closed_tab_index, browser()->tab_strip_model()->active_index()); 219 EXPECT_EQ(url1_, 220 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 221 } 222 223 // Close a tab not at the end of the current window, then restore it. The tab 224 // should be in its original position, and active. 225 IN_PROC_BROWSER_TEST_F(TabRestoreTest, MiddleTab) { 226 int starting_tab_count = browser()->tab_strip_model()->count(); 227 AddSomeTabs(browser(), 3); 228 229 // Close one in the middle 230 int closed_tab_index = starting_tab_count + 1; 231 CloseTab(closed_tab_index); 232 EXPECT_EQ(starting_tab_count + 2, browser()->tab_strip_model()->count()); 233 234 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, closed_tab_index)); 235 236 // And make sure everything looks right. 237 EXPECT_EQ(starting_tab_count + 3, browser()->tab_strip_model()->count()); 238 EXPECT_EQ(closed_tab_index, browser()->tab_strip_model()->active_index()); 239 EXPECT_EQ(url1_, 240 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 241 } 242 243 // Close a tab, switch windows, then restore the tab. The tab should be in its 244 // original window and position, and active. 245 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreToDifferentWindow) { 246 int starting_tab_count = browser()->tab_strip_model()->count(); 247 AddSomeTabs(browser(), 3); 248 249 // Close one in the middle 250 int closed_tab_index = starting_tab_count + 1; 251 CloseTab(closed_tab_index); 252 EXPECT_EQ(starting_tab_count + 2, browser()->tab_strip_model()->count()); 253 254 // Create a new browser. 255 ui_test_utils::NavigateToURLWithDisposition( 256 browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW, 257 ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER); 258 EXPECT_EQ(2u, active_browser_list_->size()); 259 260 // Restore tab into original browser. 261 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, closed_tab_index)); 262 263 // And make sure everything looks right. 264 EXPECT_EQ(starting_tab_count + 3, browser()->tab_strip_model()->count()); 265 EXPECT_EQ(closed_tab_index, browser()->tab_strip_model()->active_index()); 266 EXPECT_EQ(url1_, 267 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 268 } 269 270 // Close a tab, open a new window, close the first window, then restore the 271 // tab. It should be in a new window. 272 // If this becomes flaky, use http://crbug.com/14774 273 IN_PROC_BROWSER_TEST_F(TabRestoreTest, DISABLED_BasicRestoreFromClosedWindow) { 274 // Navigate to url1 then url2. 275 ui_test_utils::NavigateToURL(browser(), url1_); 276 ui_test_utils::NavigateToURL(browser(), url2_); 277 278 // Create a new browser. 279 ui_test_utils::NavigateToURLWithDisposition( 280 browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW, 281 ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER); 282 EXPECT_EQ(2u, active_browser_list_->size()); 283 284 // Close the final tab in the first browser. 285 content::WindowedNotificationObserver window_observer( 286 chrome::NOTIFICATION_BROWSER_CLOSED, 287 content::NotificationService::AllSources()); 288 CloseTab(0); 289 window_observer.Wait(); 290 291 ASSERT_NO_FATAL_FAILURE(RestoreTab(1, 0)); 292 293 // Tab should be in a new window. 294 Browser* browser = GetBrowser(1); 295 content::WebContents* web_contents = 296 browser->tab_strip_model()->GetActiveWebContents(); 297 // And make sure the URLs match. 298 EXPECT_EQ(url2_, web_contents->GetURL()); 299 GoBack(browser); 300 EXPECT_EQ(url1_, web_contents->GetURL()); 301 } 302 303 #if defined(OS_WIN) 304 // Flakily times out: http://crbug.com/171503 305 #define MAYBE_DontLoadRestoredTab DISABLED_DontLoadRestoredTab 306 #else 307 #define MAYBE_DontLoadRestoredTab DontLoadRestoredTab 308 #endif 309 310 // Restore a tab then make sure it doesn't restore again. 311 IN_PROC_BROWSER_TEST_F(TabRestoreTest, MAYBE_DontLoadRestoredTab) { 312 // Add two tabs 313 int starting_tab_count = browser()->tab_strip_model()->count(); 314 AddSomeTabs(browser(), 2); 315 ASSERT_EQ(browser()->tab_strip_model()->count(), starting_tab_count + 2); 316 317 // Close one of them. 318 CloseTab(0); 319 ASSERT_EQ(browser()->tab_strip_model()->count(), starting_tab_count + 1); 320 321 // Restore it. 322 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, 0)); 323 ASSERT_EQ(browser()->tab_strip_model()->count(), starting_tab_count + 2); 324 325 // Make sure that there's nothing else to restore. 326 ASSERT_EQ(chrome::GetRestoreTabType(browser()), 327 TabStripModelDelegate::RESTORE_NONE); 328 } 329 330 // Open a window with multiple tabs, close a tab, then close the window. 331 // Restore both and make sure the tab goes back into the window. 332 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreWindowAndTab) { 333 int starting_tab_count = browser()->tab_strip_model()->count(); 334 AddSomeTabs(browser(), 3); 335 336 // Close one in the middle 337 int closed_tab_index = starting_tab_count + 1; 338 CloseTab(closed_tab_index); 339 EXPECT_EQ(starting_tab_count + 2, browser()->tab_strip_model()->count()); 340 341 // Create a new browser. 342 ui_test_utils::NavigateToURLWithDisposition( 343 browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW, 344 ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER); 345 EXPECT_EQ(2u, active_browser_list_->size()); 346 347 // Close the first browser. 348 content::WindowedNotificationObserver observer( 349 chrome::NOTIFICATION_BROWSER_CLOSED, 350 content::NotificationService::AllSources()); 351 chrome::CloseWindow(browser()); 352 observer.Wait(); 353 EXPECT_EQ(1u, active_browser_list_->size()); 354 355 // Restore the first window. The expected_tabstrip_index (second argument) 356 // indicates the expected active tab. 357 ASSERT_NO_FATAL_FAILURE(RestoreTab(1, starting_tab_count + 1)); 358 Browser* browser = GetBrowser(1); 359 EXPECT_EQ(starting_tab_count + 2, browser->tab_strip_model()->count()); 360 361 // Restore the closed tab. 362 ASSERT_NO_FATAL_FAILURE(RestoreTab(1, closed_tab_index)); 363 EXPECT_EQ(starting_tab_count + 3, browser->tab_strip_model()->count()); 364 EXPECT_EQ(url1_, 365 browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 366 } 367 368 // Open a window with two tabs, close both (closing the window), then restore 369 // both. Make sure both restored tabs are in the same window. 370 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreIntoSameWindow) { 371 ui_test_utils::NavigateToURLWithDisposition( 372 browser(), url1_, NEW_FOREGROUND_TAB, 373 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 374 // Navigate the rightmost one to url2_ for easier identification. 375 ui_test_utils::NavigateToURLWithDisposition( 376 browser(), url2_, NEW_FOREGROUND_TAB, 377 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 378 379 // Create a new browser. 380 ui_test_utils::NavigateToURLWithDisposition( 381 browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW, 382 ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER); 383 EXPECT_EQ(2u, active_browser_list_->size()); 384 385 // Close all but one tab in the first browser, left to right. 386 while (browser()->tab_strip_model()->count() > 1) 387 CloseTab(0); 388 389 // Close the last tab, closing the browser. 390 content::WindowedNotificationObserver observer( 391 chrome::NOTIFICATION_BROWSER_CLOSED, 392 content::NotificationService::AllSources()); 393 CloseTab(0); 394 observer.Wait(); 395 EXPECT_EQ(1u, active_browser_list_->size()); 396 397 // Restore the last-closed tab into a new window. 398 ASSERT_NO_FATAL_FAILURE(RestoreTab(1, 0)); 399 Browser* browser = GetBrowser(1); 400 EXPECT_EQ(1, browser->tab_strip_model()->count()); 401 EXPECT_EQ(url2_, 402 browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 403 404 // Restore the next-to-last-closed tab into the same window. 405 ASSERT_NO_FATAL_FAILURE(RestoreTab(1, 0)); 406 EXPECT_EQ(2, browser->tab_strip_model()->count()); 407 EXPECT_EQ(url1_, 408 browser->tab_strip_model()->GetActiveWebContents()->GetURL()); 409 } 410 411 // Tests that a duplicate history entry is not created when we restore a page 412 // to an existing SiteInstance. (Bug 1230446) 413 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreWithExistingSiteInstance) { 414 ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady()); 415 416 GURL http_url1(embedded_test_server()->GetURL("/title1.html")); 417 GURL http_url2(embedded_test_server()->GetURL("/title2.html")); 418 int tab_count = browser()->tab_strip_model()->count(); 419 420 // Add a tab 421 ui_test_utils::NavigateToURLWithDisposition( 422 browser(), http_url1, NEW_FOREGROUND_TAB, 423 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 424 EXPECT_EQ(++tab_count, browser()->tab_strip_model()->count()); 425 426 // Navigate to another same-site URL. 427 content::WebContents* tab = 428 browser()->tab_strip_model()->GetWebContentsAt(tab_count - 1); 429 content::WindowedNotificationObserver observer( 430 content::NOTIFICATION_LOAD_STOP, 431 content::NotificationService::AllSources()); 432 static_cast<content::WebContentsDelegate*>(browser())->OpenURLFromTab( 433 tab, 434 content::OpenURLParams(http_url2, content::Referrer(), CURRENT_TAB, 435 ui::PAGE_TRANSITION_TYPED, false)); 436 observer.Wait(); 437 438 // Close the tab. 439 CloseTab(1); 440 441 // Create a new tab to the original site. Assuming process-per-site is 442 // enabled, this will ensure that the SiteInstance used by the restored tab 443 // will already exist when the restore happens. 444 ui_test_utils::NavigateToURLWithDisposition( 445 browser(), http_url2, NEW_FOREGROUND_TAB, 446 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 447 448 // Restore the closed tab. 449 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, tab_count - 1)); 450 451 // And make sure the URLs match. 452 EXPECT_EQ(http_url2, 453 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 454 GoBack(browser()); 455 EXPECT_EQ(http_url1, 456 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 457 } 458 459 // See crbug.com/248574 460 #if defined(OS_WIN) 461 #define MAYBE_RestoreCrossSiteWithExistingSiteInstance DISABLED_RestoreCrossSiteWithExistingSiteInstance 462 #else 463 #define MAYBE_RestoreCrossSiteWithExistingSiteInstance RestoreCrossSiteWithExistingSiteInstance 464 #endif 465 466 // Tests that the SiteInstances used for entries in a restored tab's history 467 // are given appropriate max page IDs, even if the renderer for the entry 468 // already exists. (Bug 1204135) 469 IN_PROC_BROWSER_TEST_F(TabRestoreTest, 470 MAYBE_RestoreCrossSiteWithExistingSiteInstance) { 471 ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady()); 472 473 GURL http_url1(embedded_test_server()->GetURL("/title1.html")); 474 GURL http_url2(embedded_test_server()->GetURL("/title2.html")); 475 476 int tab_count = browser()->tab_strip_model()->count(); 477 478 // Add a tab 479 ui_test_utils::NavigateToURLWithDisposition( 480 browser(), http_url1, NEW_FOREGROUND_TAB, 481 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 482 EXPECT_EQ(++tab_count, browser()->tab_strip_model()->count()); 483 484 // Navigate to more URLs, then a cross-site URL. 485 ui_test_utils::NavigateToURLWithDisposition( 486 browser(), http_url2, CURRENT_TAB, 487 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 488 ui_test_utils::NavigateToURLWithDisposition( 489 browser(), http_url1, CURRENT_TAB, 490 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 491 ui_test_utils::NavigateToURLWithDisposition( 492 browser(), url1_, CURRENT_TAB, 493 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 494 495 // Close the tab. 496 CloseTab(1); 497 498 // Create a new tab to the original site. Assuming process-per-site is 499 // enabled, this will ensure that the SiteInstance will already exist when 500 // the user clicks Back in the restored tab. 501 ui_test_utils::NavigateToURLWithDisposition( 502 browser(), http_url2, NEW_FOREGROUND_TAB, 503 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 504 505 // Restore the closed tab. 506 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, tab_count - 1)); 507 508 // And make sure the URLs match. 509 EXPECT_EQ(url1_, 510 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 511 GoBack(browser()); 512 EXPECT_EQ(http_url1, 513 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 514 515 // Navigating to a new URL should clear the forward list, because the max 516 // page ID of the renderer should have been updated when we restored the tab. 517 ui_test_utils::NavigateToURLWithDisposition( 518 browser(), http_url2, CURRENT_TAB, 519 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 520 EXPECT_FALSE(chrome::CanGoForward(browser())); 521 EXPECT_EQ(http_url2, 522 browser()->tab_strip_model()->GetActiveWebContents()->GetURL()); 523 } 524 525 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreWindow) { 526 // Create a new window. 527 size_t window_count = active_browser_list_->size(); 528 ui_test_utils::NavigateToURLWithDisposition( 529 browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW, 530 ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER); 531 EXPECT_EQ(++window_count, active_browser_list_->size()); 532 533 // Create two more tabs, one with url1, the other url2. 534 int initial_tab_count = browser()->tab_strip_model()->count(); 535 ui_test_utils::NavigateToURLWithDisposition( 536 browser(), url1_, NEW_FOREGROUND_TAB, 537 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 538 ui_test_utils::NavigateToURLWithDisposition( 539 browser(), url2_, NEW_FOREGROUND_TAB, 540 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 541 542 // Close the window. 543 content::WindowedNotificationObserver close_window_observer( 544 chrome::NOTIFICATION_BROWSER_CLOSED, 545 content::NotificationService::AllSources()); 546 chrome::CloseWindow(browser()); 547 close_window_observer.Wait(); 548 EXPECT_EQ(window_count - 1, active_browser_list_->size()); 549 550 // Restore the window. 551 content::WindowedNotificationObserver open_window_observer( 552 chrome::NOTIFICATION_BROWSER_OPENED, 553 content::NotificationService::AllSources()); 554 content::WindowedNotificationObserver load_stop_observer( 555 content::NOTIFICATION_LOAD_STOP, 556 content::NotificationService::AllSources()); 557 chrome::RestoreTab(active_browser_list_->get(0)); 558 open_window_observer.Wait(); 559 EXPECT_EQ(window_count, active_browser_list_->size()); 560 561 Browser* browser = GetBrowser(1); 562 EXPECT_EQ(initial_tab_count + 2, browser->tab_strip_model()->count()); 563 load_stop_observer.Wait(); 564 565 content::WebContents* restored_tab = 566 browser->tab_strip_model()->GetWebContentsAt(initial_tab_count); 567 EnsureTabFinishedRestoring(restored_tab); 568 EXPECT_EQ(url1_, restored_tab->GetURL()); 569 570 restored_tab = 571 browser->tab_strip_model()->GetWebContentsAt(initial_tab_count + 1); 572 EnsureTabFinishedRestoring(restored_tab); 573 EXPECT_EQ(url2_, restored_tab->GetURL()); 574 } 575 576 // Restore tab with special URL chrome://credits/ and make sure the page loads 577 // properly after restore. See http://crbug.com/31905. 578 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreTabWithSpecialURL) { 579 // Navigate new tab to a special URL. 580 ui_test_utils::NavigateToURLWithDisposition( 581 browser(), GURL(chrome::kChromeUICreditsURL), NEW_FOREGROUND_TAB, 582 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 583 584 // Close the tab. 585 CloseTab(1); 586 587 // Restore the closed tab. 588 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, 1)); 589 content::WebContents* tab = browser()->tab_strip_model()->GetWebContentsAt(1); 590 EnsureTabFinishedRestoring(tab); 591 592 // See if content is as expected. 593 EXPECT_GT( 594 ui_test_utils::FindInPage(tab, base::ASCIIToUTF16("webkit"), true, false, 595 NULL, NULL), 596 0); 597 } 598 599 // Restore tab with special URL in its navigation history, go back to that 600 // entry and see that it loads properly. See http://crbug.com/31905 601 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreTabWithSpecialURLOnBack) { 602 ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady()); 603 604 const GURL http_url(embedded_test_server()->GetURL("/title1.html")); 605 606 // Navigate new tab to a special URL. 607 ui_test_utils::NavigateToURLWithDisposition( 608 browser(), GURL(chrome::kChromeUICreditsURL), NEW_FOREGROUND_TAB, 609 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 610 611 // Then navigate to a normal URL. 612 ui_test_utils::NavigateToURL(browser(), http_url); 613 614 // Close the tab. 615 CloseTab(1); 616 617 // Restore the closed tab. 618 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, 1)); 619 content::WebContents* tab = browser()->tab_strip_model()->GetWebContentsAt(1); 620 EnsureTabFinishedRestoring(tab); 621 ASSERT_EQ(http_url, tab->GetURL()); 622 623 // Go back, and see if content is as expected. 624 GoBack(browser()); 625 EXPECT_GT( 626 ui_test_utils::FindInPage(tab, base::ASCIIToUTF16("webkit"), true, false, 627 NULL, NULL), 628 0); 629 } 630 631 IN_PROC_BROWSER_TEST_F(TabRestoreTest, PRE_RestoreOnStartup) { 632 // This results in a new tab at the end with url1. 633 AddSomeTabs(browser(), 1); 634 635 while (browser()->tab_strip_model()->count()) 636 CloseTab(0); 637 } 638 639 // Verifies restoring a tab works on startup. 640 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreOnStartup) { 641 ASSERT_NO_FATAL_FAILURE(RestoreTab(0, 1)); 642 EXPECT_EQ(url1_, 643 browser()->tab_strip_model()->GetWebContentsAt(1)->GetURL()); 644 } 645
