src/chrome/browser/sessions/tab_restore_browsertest.cc

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