chrome/browser/sessions/session_restore_browsertest.cc

   1 // Copyright 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 <vector>
   6
   7 #include "base/command_line.h"
   8 #include "base/files/file_path.h"
   9 #include "base/memory/memory_pressure_listener.h"
  10 #include "base/process/launch.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/time/time.h"
  13 #include "chrome/browser/browser_process.h"
  14 #include "chrome/browser/chrome_notification_types.h"
  15 #include "chrome/browser/defaults.h"
  16 #include "chrome/browser/first_run/first_run.h"
  17 #include "chrome/browser/profiles/profile.h"
  18 #include "chrome/browser/profiles/profile_manager.h"
  19 #include "chrome/browser/sessions/session_restore.h"
  20 #include "chrome/browser/sessions/session_restore_test_helper.h"
  21 #include "chrome/browser/sessions/session_service.h"
  22 #include "chrome/browser/sessions/session_service_factory.h"
  23 #include "chrome/browser/sessions/session_service_test_helper.h"
  24 #include "chrome/browser/sessions/tab_restore_service.h"
  25 #include "chrome/browser/sessions/tab_restore_service_factory.h"
  26 #include "chrome/browser/ui/browser.h"
  27 #include "chrome/browser/ui/browser_commands.h"
  28 #include "chrome/browser/ui/browser_list.h"
  29 #include "chrome/browser/ui/browser_tabstrip.h"
  30 #include "chrome/browser/ui/browser_window.h"
  31 #include "chrome/browser/ui/host_desktop.h"
  32 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  33 #include "chrome/common/chrome_switches.h"
  34 #include "chrome/common/url_constants.h"
  35 #include "chrome/test/base/in_process_browser_test.h"
  36 #include "chrome/test/base/test_switches.h"
  37 #include "chrome/test/base/ui_test_utils.h"
  38 #include "components/sessions/serialized_navigation_entry_test_helper.h"
  39 #include "components/sessions/session_types.h"
  40 #include "content/public/browser/navigation_controller.h"
  41 #include "content/public/browser/navigation_entry.h"
  42 #include "content/public/browser/notification_service.h"
  43 #include "content/public/browser/notification_types.h"
  44 #include "content/public/browser/render_process_host.h"
  45 #include "content/public/browser/render_view_host.h"
  46 #include "content/public/browser/web_contents.h"
  47 #include "content/public/common/bindings_policy.h"
  48 #include "content/public/test/browser_test_utils.h"
  49 #include "content/public/test/test_navigation_observer.h"
  50 #include "sync/protocol/session_specifics.pb.h"
  51 #include "ui/base/page_transition_types.h"
  52
  53 using sessions::SerializedNavigationEntry;
  54 using sessions::SerializedNavigationEntryTestHelper;
  55
  56 #if defined(OS_MACOSX)
  57 #include "base/mac/scoped_nsautorelease_pool.h"
  58 #endif
  59
  60 #if defined(USE_AURA)
  61 #include "ui/aura/window.h"
  62 #endif
  63
  64 class SessionRestoreTest : public InProcessBrowserTest {
  65  public:
  66   SessionRestoreTest() : active_browser_list_(NULL) {}
  67
  68  protected:
  69 #if defined(OS_CHROMEOS)
  70   void SetUpCommandLine(base::CommandLine* command_line) override {
  71     // TODO(nkostylev): Investigate if we can remove this switch.
  72     command_line->AppendSwitch(switches::kCreateBrowserOnStartupForTests);
  73     InProcessBrowserTest::SetUpCommandLine(command_line);
  74   }
  75 #endif
  76
  77   void SetUpOnMainThread() override {
  78     active_browser_list_ = BrowserList::GetInstance(chrome::GetActiveDesktop());
  79
  80     SessionStartupPref pref(SessionStartupPref::LAST);
  81     SessionStartupPref::SetStartupPref(browser()->profile(), pref);
  82 #if defined(OS_CHROMEOS)
  83     const testing::TestInfo* const test_info =
  84         testing::UnitTest::GetInstance()->current_test_info();
  85     if (strcmp(test_info->name(), "NoSessionRestoreNewWindowChromeOS") != 0) {
  86       // Undo the effect of kBrowserAliveWithNoWindows in defaults.cc so that we
  87       // can get these test to work without quitting.
  88       SessionServiceTestHelper helper(
  89           SessionServiceFactory::GetForProfile(browser()->profile()));
  90       helper.SetForceBrowserNotAliveWithNoWindows(true);
  91       helper.ReleaseService();
  92     }
  93 #endif
  94
  95     InProcessBrowserTest::SetUpOnMainThread();
  96   }
  97
  98   bool SetUpUserDataDirectory() override {
  99     url1_ = ui_test_utils::GetTestUrl(
 100         base::FilePath().AppendASCII("session_history"),
 101         base::FilePath().AppendASCII("bot1.html"));
 102     url2_ = ui_test_utils::GetTestUrl(
 103         base::FilePath().AppendASCII("session_history"),
 104         base::FilePath().AppendASCII("bot2.html"));
 105     url3_ = ui_test_utils::GetTestUrl(
 106         base::FilePath().AppendASCII("session_history"),
 107         base::FilePath().AppendASCII("bot3.html"));
 108
 109     return InProcessBrowserTest::SetUpUserDataDirectory();
 110   }
 111
 112   void CloseBrowserSynchronously(Browser* browser) {
 113     content::WindowedNotificationObserver observer(
 114         chrome::NOTIFICATION_BROWSER_CLOSED,
 115         content::NotificationService::AllSources());
 116     browser->window()->Close();
 117 #if defined(OS_MACOSX)
 118     // BrowserWindowController depends on the auto release pool being recycled
 119     // in the message loop to delete itself, which frees the Browser object
 120     // which fires this event.
 121     AutoreleasePool()->Recycle();
 122 #endif
 123     observer.Wait();
 124   }
 125
 126   Browser* QuitBrowserAndRestore(Browser* browser, int expected_tab_count) {
 127     return QuitBrowserAndRestoreWithURL(
 128         browser, expected_tab_count, GURL(), true);
 129   }
 130
 131   Browser* QuitBrowserAndRestoreWithURL(Browser* browser,
 132                                         int expected_tab_count,
 133                                         const GURL& url,
 134                                         bool no_memory_pressure) {
 135     Profile* profile = browser->profile();
 136
 137     // Close the browser.
 138     g_browser_process->AddRefModule();
 139     CloseBrowserSynchronously(browser);
 140
 141     // Create a new window, which should trigger session restore.
 142     ui_test_utils::BrowserAddedObserver window_observer;
 143     SessionRestoreTestHelper restore_observer;
 144     if (url.is_empty()) {
 145       chrome::NewEmptyWindow(profile, chrome::HOST_DESKTOP_TYPE_NATIVE);
 146     } else {
 147       chrome::NavigateParams params(profile,
 148                                     url,
 149                                     ui::PAGE_TRANSITION_LINK);
 150       chrome::Navigate(&params);
 151     }
 152     Browser* new_browser = window_observer.WaitForSingleNewBrowser();
 153     // Stop loading anything more if we are running out of space.
 154     if (!no_memory_pressure) {
 155       base::MemoryPressureListener::NotifyMemoryPressure(
 156           base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
 157     }
 158     restore_observer.Wait();
 159
 160     if (no_memory_pressure)
 161       WaitForTabsToLoad(new_browser);
 162
 163     g_browser_process->ReleaseModule();
 164
 165     return new_browser;
 166   }
 167
 168   void GoBack(Browser* browser) {
 169     content::TestNavigationObserver observer(
 170         browser->tab_strip_model()->GetActiveWebContents());
 171     chrome::GoBack(browser, CURRENT_TAB);
 172     observer.Wait();
 173   }
 174
 175   void GoForward(Browser* browser) {
 176     content::TestNavigationObserver observer(
 177         browser->tab_strip_model()->GetActiveWebContents());
 178     chrome::GoForward(browser, CURRENT_TAB);
 179     observer.Wait();
 180   }
 181
 182   void AssertOneWindowWithOneTab(Browser* browser) {
 183     ASSERT_EQ(1u, active_browser_list_->size());
 184     ASSERT_EQ(1, browser->tab_strip_model()->count());
 185   }
 186
 187   int RenderProcessHostCount() {
 188     content::RenderProcessHost::iterator hosts =
 189         content::RenderProcessHost::AllHostsIterator();
 190     int count = 0;
 191     while (!hosts.IsAtEnd()) {
 192       if (hosts.GetCurrentValue()->HasConnection())
 193         count++;
 194       hosts.Advance();
 195     }
 196     return count;
 197   }
 198
 199   void WaitForTabsToLoad(Browser* browser) {
 200     for (int i = 0; i < browser->tab_strip_model()->count(); ++i) {
 201       content::WebContents* contents =
 202           browser->tab_strip_model()->GetWebContentsAt(i);
 203       contents->GetController().LoadIfNecessary();
 204       content::WaitForLoadStop(contents);
 205     }
 206   }
 207
 208   GURL url1_;
 209   GURL url2_;
 210   GURL url3_;
 211
 212   const BrowserList* active_browser_list_;
 213 };
 214
 215 // Verifies that restored tabs have a root window. This is important
 216 // otherwise the wrong information is communicated to the renderer.
 217 // (http://crbug.com/342672).
 218 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoredTabsShouldHaveWindow) {
 219   // Create tabs.
 220   ui_test_utils::NavigateToURLWithDisposition(
 221       browser(),
 222       GURL(url::kAboutBlankURL),
 223       NEW_FOREGROUND_TAB,
 224       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 225   ui_test_utils::NavigateToURLWithDisposition(
 226       browser(),
 227       GURL(url::kAboutBlankURL),
 228       NEW_BACKGROUND_TAB,
 229       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 230
 231   // Restart and session restore the tabs.
 232   Browser* restored = QuitBrowserAndRestore(browser(), 3);
 233   TabStripModel* tab_strip_model = restored->tab_strip_model();
 234   const int tabs = tab_strip_model->count();
 235   ASSERT_EQ(3, tabs);
 236
 237   // Check the restored tabs have a window to get screen info from.
 238   // On Aura it should also have a root window.
 239   for (int i = 0; i < tabs; ++i) {
 240     content::WebContents* contents = tab_strip_model->GetWebContentsAt(i);
 241     EXPECT_TRUE(contents->GetTopLevelNativeWindow());
 242 #if defined(USE_AURA)
 243     EXPECT_TRUE(contents->GetNativeView()->GetRootWindow());
 244 #endif
 245   }
 246 }
 247
 248 // Verify that restored tabs have correct disposition. Only one tab should
 249 // have "visible" visibility state, the rest should not.
 250 // (http://crbug.com/155365 http://crbug.com/118269)
 251 IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 252     RestoredTabsHaveCorrectVisibilityState) {
 253   // Create tabs.
 254   GURL test_page(ui_test_utils::GetTestUrl(base::FilePath(),
 255       base::FilePath(FILE_PATH_LITERAL("tab-restore-visibilty.html"))));
 256   ui_test_utils::NavigateToURLWithDisposition(
 257       browser(), test_page, NEW_FOREGROUND_TAB,
 258       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 259   ui_test_utils::NavigateToURLWithDisposition(
 260       browser(), test_page, NEW_BACKGROUND_TAB,
 261       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 262
 263   // Restart and session restore the tabs.
 264   content::DOMMessageQueue message_queue;
 265   Browser* restored = QuitBrowserAndRestore(browser(), 3);
 266   for (int i = 0; i < 2; ++i) {
 267     std::string message;
 268     EXPECT_TRUE(message_queue.WaitForMessage(&message));
 269     EXPECT_EQ("\"READY\"", message);
 270   }
 271
 272   // There should be 3 restored tabs in the new browser.
 273   TabStripModel* tab_strip_model = restored->tab_strip_model();
 274   const int tabs = tab_strip_model->count();
 275   ASSERT_EQ(3, tabs);
 276
 277   // The middle tab only should have visible disposition.
 278   for (int i = 0; i < tabs; ++i) {
 279     content::WebContents* contents = tab_strip_model->GetWebContentsAt(i);
 280     std::string document_visibility_state;
 281     const char kGetStateJS[] = "window.domAutomationController.send("
 282         "window.document.visibilityState);";
 283     EXPECT_TRUE(content::ExecuteScriptAndExtractString(
 284         contents, kGetStateJS, &document_visibility_state));
 285     if (i == 1) {
 286       EXPECT_EQ("visible", document_visibility_state);
 287     } else {
 288       EXPECT_EQ("hidden", document_visibility_state);
 289     }
 290   }
 291 }
 292
 293 #if defined(OS_CHROMEOS)
 294 // Verify that session restore does not occur when a user opens a browser window
 295 // when no other browser windows are open on ChromeOS.
 296 // TODO(pkotwicz): Add test which doesn't open incognito browser once
 297 // disable-zero-browsers-open-for-tests is removed.
 298 // (http://crbug.com/119175)
 299 // TODO(pkotwicz): Mac should have the behavior outlined by this test. It should
 300 // not do session restore if an incognito window is already open.
 301 // (http://crbug.com/120927)
 302 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, NoSessionRestoreNewWindowChromeOS) {
 303   GURL url(ui_test_utils::GetTestUrl(
 304       base::FilePath(base::FilePath::kCurrentDirectory),
 305       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 306
 307   // Add a single tab.
 308   ui_test_utils::NavigateToURL(browser(), url);
 309
 310   Browser* incognito_browser = CreateIncognitoBrowser();
 311   chrome::AddTabAt(incognito_browser, GURL(), -1, true);
 312   incognito_browser->window()->Show();
 313
 314   // Close the normal browser. After this we only have the incognito window
 315   // open.
 316   CloseBrowserSynchronously(browser());
 317
 318   // Create a new window, which should open NTP.
 319   ui_test_utils::BrowserAddedObserver browser_added_observer;
 320   chrome::NewWindow(incognito_browser);
 321   Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser();
 322
 323   ASSERT_TRUE(new_browser);
 324   EXPECT_EQ(1, new_browser->tab_strip_model()->count());
 325   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
 326             new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 327 }
 328
 329 // Test that maximized applications get restored maximized.
 330 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, MaximizedApps) {
 331   const char* app_name = "TestApp";
 332   Browser* app_browser = CreateBrowserForApp(app_name, browser()->profile());
 333   app_browser->window()->Maximize();
 334   app_browser->window()->Show();
 335   EXPECT_TRUE(app_browser->window()->IsMaximized());
 336   EXPECT_TRUE(app_browser->is_app());
 337   EXPECT_TRUE(app_browser->is_type_popup());
 338
 339   // Close the normal browser. After this we only have the app_browser window.
 340   CloseBrowserSynchronously(browser());
 341
 342   // Create a new window, which should open NTP.
 343   ui_test_utils::BrowserAddedObserver browser_added_observer;
 344   chrome::NewWindow(app_browser);
 345   Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser();
 346
 347   ASSERT_TRUE(new_browser);
 348   EXPECT_TRUE(app_browser->window()->IsMaximized());
 349   EXPECT_TRUE(app_browser->is_app());
 350   EXPECT_TRUE(app_browser->is_type_popup());
 351 }
 352 #endif  // OS_CHROMEOS
 353
 354 #if !defined(OS_CHROMEOS)
 355 // This test does not apply to ChromeOS as it does not do session restore when
 356 // a new window is opened.
 357
 358 #if defined(OS_LINUX) && defined(TOOLKIT_VIEWS)
 359 // Crashes on Linux Views: http://crbug.com/39476
 360 #define MAYBE_RestoreOnNewWindowWithNoTabbedBrowsers \
 361         DISABLED_RestoreOnNewWindowWithNoTabbedBrowsers
 362 #else
 363 #define MAYBE_RestoreOnNewWindowWithNoTabbedBrowsers \
 364         RestoreOnNewWindowWithNoTabbedBrowsers
 365 #endif
 366
 367 // Makes sure when session restore is triggered in the same process we don't end
 368 // up with an extra tab.
 369 IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 370                        MAYBE_RestoreOnNewWindowWithNoTabbedBrowsers) {
 371   const base::FilePath::CharType* kTitle1File =
 372       FILE_PATH_LITERAL("title1.html");
 373   GURL url(ui_test_utils::GetTestUrl(base::FilePath(
 374       base::FilePath::kCurrentDirectory), base::FilePath(kTitle1File)));
 375   ui_test_utils::NavigateToURL(browser(), url);
 376
 377   // Turn on session restore.
 378   SessionStartupPref::SetStartupPref(
 379       browser()->profile(),
 380       SessionStartupPref(SessionStartupPref::LAST));
 381
 382   // Create a new popup.
 383   Profile* profile = browser()->profile();
 384   Browser* popup =
 385       new Browser(Browser::CreateParams(Browser::TYPE_POPUP, profile,
 386                                         browser()->host_desktop_type()));
 387   popup->window()->Show();
 388
 389   // Close the browser.
 390   CloseBrowserSynchronously(browser());
 391
 392   // Create a new window, which should trigger session restore.
 393   ui_test_utils::BrowserAddedObserver observer;
 394   chrome::NewWindow(popup);
 395   Browser* new_browser = observer.WaitForSingleNewBrowser();
 396
 397   ASSERT_TRUE(new_browser != NULL);
 398
 399   // The browser should only have one tab.
 400   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 401
 402   // And the first url should be url.
 403   EXPECT_EQ(url, new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 404 }
 405 #endif  // !OS_CHROMEOS
 406
 407 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreIndividualTabFromWindow) {
 408   GURL url1(ui_test_utils::GetTestUrl(
 409       base::FilePath(base::FilePath::kCurrentDirectory),
 410       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 411   // Any page that will yield a 200 status code will work here.
 412   GURL url2("chrome://version");
 413   GURL url3(ui_test_utils::GetTestUrl(
 414       base::FilePath(base::FilePath::kCurrentDirectory),
 415       base::FilePath(FILE_PATH_LITERAL("title3.html"))));
 416
 417   // Add and navigate three tabs.
 418   ui_test_utils::NavigateToURL(browser(), url1);
 419   {
 420     content::WindowedNotificationObserver observer(
 421         content::NOTIFICATION_LOAD_STOP,
 422         content::NotificationService::AllSources());
 423     chrome::AddSelectedTabWithURL(browser(), url2,
 424                                   ui::PAGE_TRANSITION_LINK);
 425     observer.Wait();
 426   }
 427   {
 428     content::WindowedNotificationObserver observer(
 429         content::NOTIFICATION_LOAD_STOP,
 430         content::NotificationService::AllSources());
 431     chrome::AddSelectedTabWithURL(browser(), url3,
 432                                   ui::PAGE_TRANSITION_LINK);
 433     observer.Wait();
 434   }
 435
 436   TabRestoreService* service =
 437       TabRestoreServiceFactory::GetForProfile(browser()->profile());
 438   service->ClearEntries();
 439
 440   chrome::HostDesktopType host_desktop_type = browser()->host_desktop_type();
 441
 442   browser()->window()->Close();
 443
 444   // Expect a window with three tabs.
 445   ASSERT_EQ(1U, service->entries().size());
 446   ASSERT_EQ(TabRestoreService::WINDOW, service->entries().front()->type);
 447   const TabRestoreService::Window* window =
 448       static_cast<TabRestoreService::Window*>(service->entries().front());
 449   EXPECT_EQ(3U, window->tabs.size());
 450
 451   // Find the SessionID for entry2. Since the session service was destroyed,
 452   // there is no guarantee that the SessionID for the tab has remained the same.
 453   base::Time timestamp;
 454   int http_status_code = 0;
 455   for (std::vector<TabRestoreService::Tab>::const_iterator it =
 456            window->tabs.begin(); it != window->tabs.end(); ++it) {
 457     const TabRestoreService::Tab& tab = *it;
 458     // If this tab held url2, then restore this single tab.
 459     if (tab.navigations[0].virtual_url() == url2) {
 460       timestamp = tab.navigations[0].timestamp();
 461       http_status_code = tab.navigations[0].http_status_code();
 462       std::vector<content::WebContents*> content =
 463           service->RestoreEntryById(NULL, tab.id, host_desktop_type, UNKNOWN);
 464       ASSERT_EQ(1U, content.size());
 465       ASSERT_TRUE(content[0]);
 466       EXPECT_EQ(url2, content[0]->GetURL());
 467       break;
 468     }
 469   }
 470   EXPECT_FALSE(timestamp.is_null());
 471   EXPECT_EQ(200, http_status_code);
 472
 473   // Make sure that the restored tab is removed from the service.
 474   ASSERT_EQ(1U, service->entries().size());
 475   ASSERT_EQ(TabRestoreService::WINDOW, service->entries().front()->type);
 476   window = static_cast<TabRestoreService::Window*>(service->entries().front());
 477   EXPECT_EQ(2U, window->tabs.size());
 478
 479   // Make sure that the restored tab was restored with the correct
 480   // timestamp and status code.
 481   const content::WebContents* contents =
 482       browser()->tab_strip_model()->GetActiveWebContents();
 483   ASSERT_TRUE(contents);
 484   const content::NavigationEntry* entry =
 485       contents->GetController().GetActiveEntry();
 486   ASSERT_TRUE(entry);
 487   EXPECT_EQ(timestamp, entry->GetTimestamp());
 488   EXPECT_EQ(http_status_code, entry->GetHttpStatusCode());
 489 }
 490
 491 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, WindowWithOneTab) {
 492   GURL url(ui_test_utils::GetTestUrl(
 493       base::FilePath(base::FilePath::kCurrentDirectory),
 494       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 495
 496   // Add a single tab.
 497   ui_test_utils::NavigateToURL(browser(), url);
 498
 499   TabRestoreService* service =
 500       TabRestoreServiceFactory::GetForProfile(browser()->profile());
 501   service->ClearEntries();
 502   EXPECT_EQ(0U, service->entries().size());
 503
 504   chrome::HostDesktopType host_desktop_type = browser()->host_desktop_type();
 505
 506   // Close the window.
 507   browser()->window()->Close();
 508
 509   // Expect the window to be converted to a tab by the TRS.
 510   EXPECT_EQ(1U, service->entries().size());
 511   ASSERT_EQ(TabRestoreService::TAB, service->entries().front()->type);
 512   const TabRestoreService::Tab* tab =
 513       static_cast<TabRestoreService::Tab*>(service->entries().front());
 514
 515   // Restore the tab.
 516   std::vector<content::WebContents*> content =
 517       service->RestoreEntryById(NULL, tab->id, host_desktop_type, UNKNOWN);
 518   ASSERT_EQ(1U, content.size());
 519   ASSERT_TRUE(content[0]);
 520   EXPECT_EQ(url, content[0]->GetURL());
 521
 522   // Make sure the restore was successful.
 523   EXPECT_EQ(0U, service->entries().size());
 524 }
 525
 526 #if !defined(OS_CHROMEOS)
 527 // This test does not apply to ChromeOS as ChromeOS does not do session
 528 // restore when a new window is open.
 529
 530 // Verifies we remember the last browser window when closing the last
 531 // non-incognito window while an incognito window is open.
 532 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, IncognitotoNonIncognito) {
 533   GURL url(ui_test_utils::GetTestUrl(
 534       base::FilePath(base::FilePath::kCurrentDirectory),
 535       base::FilePath(FILE_PATH_LITERAL("title1.html"))));
 536
 537   // Add a single tab.
 538   ui_test_utils::NavigateToURL(browser(), url);
 539
 540   // Create a new incognito window.
 541   Browser* incognito_browser = CreateIncognitoBrowser();
 542   chrome::AddTabAt(incognito_browser, GURL(), -1, true);
 543   incognito_browser->window()->Show();
 544
 545   // Close the normal browser. After this we only have the incognito window
 546   // open.
 547   CloseBrowserSynchronously(browser());
 548
 549   // Create a new window, which should trigger session restore.
 550   ui_test_utils::BrowserAddedObserver browser_added_observer;
 551   chrome::NewWindow(incognito_browser);
 552   Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser();
 553
 554   // The first tab should have 'url' as its url.
 555   ASSERT_TRUE(new_browser);
 556   EXPECT_EQ(url, new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 557 }
 558 #endif  // !OS_CHROMEOS
 559
 560 namespace {
 561
 562 // Verifies that the given NavigationController has exactly two
 563 // entries that correspond to the given URLs and that all but the last
 564 // entry have null timestamps.
 565 void VerifyNavigationEntries(
 566     const content::NavigationController& controller,
 567     GURL url1, GURL url2) {
 568   ASSERT_EQ(2, controller.GetEntryCount());
 569   EXPECT_EQ(1, controller.GetCurrentEntryIndex());
 570   EXPECT_EQ(url1, controller.GetEntryAtIndex(0)->GetURL());
 571   EXPECT_EQ(url2, controller.GetEntryAtIndex(1)->GetURL());
 572   EXPECT_TRUE(controller.GetEntryAtIndex(0)->GetTimestamp().is_null());
 573   EXPECT_FALSE(controller.GetEntryAtIndex(1)->GetTimestamp().is_null());
 574 }
 575
 576 }  // namespace
 577
 578 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignTab) {
 579   GURL url1("http://google.com");
 580   GURL url2("http://google2.com");
 581   SerializedNavigationEntry nav1 =
 582       SerializedNavigationEntryTestHelper::CreateNavigation(url1.spec(), "one");
 583   SerializedNavigationEntry nav2 =
 584       SerializedNavigationEntryTestHelper::CreateNavigation(url2.spec(), "two");
 585
 586   // Set up the restore data.
 587   sync_pb::SessionTab sync_data;
 588   sync_data.set_tab_visual_index(0);
 589   sync_data.set_current_navigation_index(1);
 590   sync_data.set_pinned(false);
 591   sync_data.add_navigation()->CopyFrom(nav1.ToSyncData());
 592   sync_data.add_navigation()->CopyFrom(nav2.ToSyncData());
 593
 594   sessions::SessionTab tab;
 595   tab.SetFromSyncData(sync_data, base::Time::Now());
 596   EXPECT_EQ(2U, tab.navigations.size());
 597   for (size_t i = 0; i < tab.navigations.size(); ++i)
 598     EXPECT_TRUE(tab.navigations[i].timestamp().is_null());
 599
 600   ASSERT_EQ(1, browser()->tab_strip_model()->count());
 601
 602   // Restore in the current tab.
 603   content::WebContents* tab_content = NULL;
 604   {
 605     content::WindowedNotificationObserver observer(
 606         content::NOTIFICATION_LOAD_STOP,
 607         content::NotificationService::AllSources());
 608     tab_content = SessionRestore::RestoreForeignSessionTab(
 609         browser()->tab_strip_model()->GetActiveWebContents(), tab, CURRENT_TAB);
 610     observer.Wait();
 611   }
 612   ASSERT_EQ(1, browser()->tab_strip_model()->count());
 613   content::WebContents* web_contents =
 614       browser()->tab_strip_model()->GetWebContentsAt(0);
 615   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
 616   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
 617   ASSERT_TRUE(tab_content);
 618   ASSERT_EQ(url2, tab_content->GetURL());
 619
 620   // Restore in a new tab.
 621   tab_content = NULL;
 622   {
 623     content::WindowedNotificationObserver observer(
 624         content::NOTIFICATION_LOAD_STOP,
 625         content::NotificationService::AllSources());
 626     tab_content = SessionRestore::RestoreForeignSessionTab(
 627         browser()->tab_strip_model()->GetActiveWebContents(),
 628         tab, NEW_BACKGROUND_TAB);
 629     observer.Wait();
 630   }
 631   ASSERT_EQ(2, browser()->tab_strip_model()->count());
 632   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
 633   web_contents = browser()->tab_strip_model()->GetWebContentsAt(1);
 634   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
 635   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
 636   ASSERT_TRUE(tab_content);
 637   ASSERT_EQ(url2, tab_content->GetURL());
 638
 639   // Restore in a new window.
 640   Browser* new_browser = NULL;
 641   tab_content = NULL;
 642   {
 643     ui_test_utils::BrowserAddedObserver browser_observer;
 644     content::WindowedNotificationObserver observer(
 645         content::NOTIFICATION_LOAD_STOP,
 646         content::NotificationService::AllSources());
 647     tab_content = SessionRestore::RestoreForeignSessionTab(
 648         browser()->tab_strip_model()->GetActiveWebContents(), tab, NEW_WINDOW);
 649     new_browser = browser_observer.WaitForSingleNewBrowser();
 650     observer.Wait();
 651   }
 652
 653   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 654   web_contents = new_browser->tab_strip_model()->GetWebContentsAt(0);
 655   VerifyNavigationEntries(web_contents->GetController(), url1, url2);
 656   ASSERT_TRUE(web_contents->GetUserAgentOverride().empty());
 657   ASSERT_TRUE(tab_content);
 658   ASSERT_EQ(url2, tab_content->GetURL());
 659 }
 660
 661 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignSession) {
 662   Profile* profile = browser()->profile();
 663
 664   GURL url1("http://google.com");
 665   GURL url2("http://google2.com");
 666   SerializedNavigationEntry nav1 =
 667       SerializedNavigationEntryTestHelper::CreateNavigation(url1.spec(), "one");
 668   SerializedNavigationEntry nav2 =
 669       SerializedNavigationEntryTestHelper::CreateNavigation(url2.spec(), "two");
 670   SerializedNavigationEntryTestHelper::SetIsOverridingUserAgent(true, &nav2);
 671
 672   // Set up the restore data -- one window with two tabs.
 673   std::vector<const sessions::SessionWindow*> session;
 674   sessions::SessionWindow window;
 675   sessions::SessionTab tab1;
 676   {
 677     sync_pb::SessionTab sync_data;
 678     sync_data.set_tab_visual_index(0);
 679     sync_data.set_current_navigation_index(0);
 680     sync_data.set_pinned(true);
 681     sync_data.add_navigation()->CopyFrom(nav1.ToSyncData());
 682     tab1.SetFromSyncData(sync_data, base::Time::Now());
 683   }
 684   window.tabs.push_back(&tab1);
 685
 686   sessions::SessionTab tab2;
 687   {
 688     sync_pb::SessionTab sync_data;
 689     sync_data.set_tab_visual_index(1);
 690     sync_data.set_current_navigation_index(0);
 691     sync_data.set_pinned(false);
 692     sync_data.add_navigation()->CopyFrom(nav2.ToSyncData());
 693     tab2.SetFromSyncData(sync_data, base::Time::Now());
 694   }
 695   window.tabs.push_back(&tab2);
 696
 697   // Leave tab3 empty. Should have no effect on restored session, but simulates
 698   // partially complete foreign session data.
 699   sessions::SessionTab tab3;
 700   window.tabs.push_back(&tab3);
 701
 702   session.push_back(static_cast<const sessions::SessionWindow*>(&window));
 703   ui_test_utils::BrowserAddedObserver window_observer;
 704   std::vector<Browser*> browsers =
 705       SessionRestore::RestoreForeignSessionWindows(
 706           profile, browser()->host_desktop_type(), session.begin(),
 707           session.end());
 708   Browser* new_browser = window_observer.WaitForSingleNewBrowser();
 709   ASSERT_TRUE(new_browser);
 710   ASSERT_EQ(2u, active_browser_list_->size());
 711   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
 712
 713   ASSERT_EQ(1u, browsers.size());
 714   ASSERT_TRUE(browsers[0]);
 715   ASSERT_EQ(2, browsers[0]->tab_strip_model()->count());
 716
 717   content::WebContents* web_contents_1 =
 718       new_browser->tab_strip_model()->GetWebContentsAt(0);
 719   content::WebContents* web_contents_2 =
 720       new_browser->tab_strip_model()->GetWebContentsAt(1);
 721   ASSERT_EQ(url1, web_contents_1->GetURL());
 722   ASSERT_EQ(url2, web_contents_2->GetURL());
 723
 724   // Check user agent override state.
 725   ASSERT_TRUE(web_contents_1->GetUserAgentOverride().empty());
 726   ASSERT_TRUE(web_contents_2->GetUserAgentOverride().empty());
 727
 728   content::NavigationEntry* entry =
 729       web_contents_1->GetController().GetActiveEntry();
 730   ASSERT_TRUE(entry);
 731   ASSERT_FALSE(entry->GetIsOverridingUserAgent());
 732
 733   entry = web_contents_2->GetController().GetActiveEntry();
 734   ASSERT_TRUE(entry);
 735   ASSERT_FALSE(entry->GetIsOverridingUserAgent());
 736
 737   // The SessionWindow destructor deletes the tabs, so we have to clear them
 738   // here to avoid a crash.
 739   window.tabs.clear();
 740 }
 741
 742 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, Basic) {
 743   ui_test_utils::NavigateToURL(browser(), url1_);
 744   ui_test_utils::NavigateToURL(browser(), url2_);
 745
 746   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 747   ASSERT_EQ(1u, active_browser_list_->size());
 748   ASSERT_EQ(url2_,
 749             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 750   GoBack(new_browser);
 751   ASSERT_EQ(url1_,
 752             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 753 }
 754
 755 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, NoMemoryPressureLoadsAllTabs) {
 756   // Add several tabs to the browser. Restart the browser and check that all
 757   // tabs got loaded properly.
 758   ui_test_utils::NavigateToURLWithDisposition(
 759       browser(),
 760       GURL(url::kAboutBlankURL),
 761       NEW_FOREGROUND_TAB,
 762       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 763   ui_test_utils::NavigateToURLWithDisposition(
 764       browser(),
 765       GURL(url::kAboutBlankURL),
 766       NEW_FOREGROUND_TAB,
 767       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 768   Browser* restored =
 769       QuitBrowserAndRestoreWithURL(browser(), 1, GURL(), true);
 770   TabStripModel* tab_strip_model = restored->tab_strip_model();
 771
 772   ASSERT_EQ(1u, active_browser_list_->size());
 773
 774   ASSERT_EQ(3, tab_strip_model->count());
 775   // All render widgets should be initialized by now.
 776   ASSERT_TRUE(
 777       tab_strip_model->GetWebContentsAt(0)->GetRenderWidgetHostView() &&
 778       tab_strip_model->GetWebContentsAt(1)->GetRenderWidgetHostView() &&
 779       tab_strip_model->GetWebContentsAt(2)->GetRenderWidgetHostView());
 780 }
 781
 782 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, MemoryPressureLoadsNotAllTabs) {
 783   // Add several tabs to the browser. Restart the browser and check that all
 784   // tabs got loaded properly.
 785   ui_test_utils::NavigateToURLWithDisposition(
 786       browser(),
 787       GURL(url::kAboutBlankURL),
 788       NEW_FOREGROUND_TAB,
 789       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 790   ui_test_utils::NavigateToURLWithDisposition(
 791       browser(),
 792       GURL(url::kAboutBlankURL),
 793       NEW_FOREGROUND_TAB,
 794       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 795   // Restore the brwoser, but instead of directly waiting, we issue a critical
 796   // memory pressure event and finish then the loading.
 797   Browser* restored =
 798       QuitBrowserAndRestoreWithURL(browser(), 1, GURL(), false);
 799
 800   TabStripModel* tab_strip_model = restored->tab_strip_model();
 801
 802   ASSERT_EQ(1u, active_browser_list_->size());
 803
 804   ASSERT_EQ(3, tab_strip_model->count());
 805   // At least one of the render widgets should not be initialized yet.
 806   ASSERT_FALSE(
 807       tab_strip_model->GetWebContentsAt(0)->GetRenderWidgetHostView() &&
 808       tab_strip_model->GetWebContentsAt(1)->GetRenderWidgetHostView() &&
 809       tab_strip_model->GetWebContentsAt(2)->GetRenderWidgetHostView());
 810 }
 811
 812 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWebUI) {
 813   const GURL webui_url("chrome://omnibox");
 814   ui_test_utils::NavigateToURL(browser(), webui_url);
 815   const content::WebContents* old_tab =
 816       browser()->tab_strip_model()->GetActiveWebContents();
 817   EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI,
 818             old_tab->GetRenderViewHost()->GetEnabledBindings());
 819
 820   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 821   ASSERT_EQ(1u, active_browser_list_->size());
 822   const content::WebContents* new_tab =
 823       new_browser->tab_strip_model()->GetActiveWebContents();
 824   EXPECT_EQ(webui_url, new_tab->GetURL());
 825   EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI,
 826             new_tab->GetRenderViewHost()->GetEnabledBindings());
 827 }
 828
 829 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWebUISettings) {
 830   const GURL webui_url("chrome://settings");
 831   ui_test_utils::NavigateToURL(browser(), webui_url);
 832   const content::WebContents* old_tab =
 833       browser()->tab_strip_model()->GetActiveWebContents();
 834   EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI,
 835             old_tab->GetRenderViewHost()->GetEnabledBindings());
 836
 837   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 838   ASSERT_EQ(1u, active_browser_list_->size());
 839   const content::WebContents* new_tab =
 840       new_browser->tab_strip_model()->GetActiveWebContents();
 841   EXPECT_EQ(webui_url, new_tab->GetURL());
 842   EXPECT_EQ(content::BINDINGS_POLICY_WEB_UI,
 843             new_tab->GetRenderViewHost()->GetEnabledBindings());
 844 }
 845
 846 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoresForwardAndBackwardNavs) {
 847   ui_test_utils::NavigateToURL(browser(), url1_);
 848   ui_test_utils::NavigateToURL(browser(), url2_);
 849   ui_test_utils::NavigateToURL(browser(), url3_);
 850
 851   GoBack(browser());
 852   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 853   ASSERT_EQ(1u, active_browser_list_->size());
 854   ASSERT_EQ(url2_,
 855             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 856   GoForward(new_browser);
 857   ASSERT_EQ(url3_,
 858             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 859   GoBack(new_browser);
 860   ASSERT_EQ(url2_,
 861             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 862
 863   // Test renderer-initiated back/forward as well.
 864   GURL go_back_url("javascript:history.back();");
 865   ui_test_utils::NavigateToURL(new_browser, go_back_url);
 866   ASSERT_EQ(url1_,
 867             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 868 }
 869
 870 // Tests that the SiteInstances used for entries in a restored tab's history
 871 // are given appropriate max page IDs, so that going back to a restored
 872 // cross-site page and then forward again works.  (Bug 1204135)
 873 // This test fails. See http://crbug.com/237497.
 874 IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 875                        DISABLED_RestoresCrossSiteForwardAndBackwardNavs) {
 876   ASSERT_TRUE(test_server()->Start());
 877
 878   GURL cross_site_url(test_server()->GetURL("files/title2.html"));
 879
 880   // Visit URLs on different sites.
 881   ui_test_utils::NavigateToURL(browser(), url1_);
 882   ui_test_utils::NavigateToURL(browser(), cross_site_url);
 883   ui_test_utils::NavigateToURL(browser(), url2_);
 884
 885   GoBack(browser());
 886   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 887   ASSERT_EQ(1u, active_browser_list_->size());
 888   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 889
 890   // Check that back and forward work as expected.
 891   ASSERT_EQ(cross_site_url,
 892             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 893
 894   GoBack(new_browser);
 895   ASSERT_EQ(url1_,
 896             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 897
 898   GoForward(new_browser);
 899   ASSERT_EQ(cross_site_url,
 900             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 901
 902   // Test renderer-initiated back/forward as well.
 903   GURL go_forward_url("javascript:history.forward();");
 904   ui_test_utils::NavigateToURL(new_browser, go_forward_url);
 905   ASSERT_EQ(url2_,
 906             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 907 }
 908
 909 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, TwoTabsSecondSelected) {
 910   ui_test_utils::NavigateToURL(browser(), url1_);
 911
 912   ui_test_utils::NavigateToURLWithDisposition(
 913       browser(), url2_, NEW_FOREGROUND_TAB,
 914       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 915
 916   Browser* new_browser = QuitBrowserAndRestore(browser(), 2);
 917
 918   ASSERT_EQ(1u, active_browser_list_->size());
 919   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
 920   ASSERT_EQ(1, new_browser->tab_strip_model()->active_index());
 921   ASSERT_EQ(url2_,
 922             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 923
 924   ASSERT_EQ(url1_,
 925             new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 926 }
 927
 928 // Creates two tabs, closes one, quits and makes sure only one tab is restored.
 929 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ClosedTabStaysClosed) {
 930   ui_test_utils::NavigateToURL(browser(), url1_);
 931
 932   ui_test_utils::NavigateToURLWithDisposition(
 933       browser(), url2_, NEW_FOREGROUND_TAB,
 934       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 935   chrome::CloseTab(browser());
 936
 937   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 938
 939   AssertOneWindowWithOneTab(new_browser);
 940   ASSERT_EQ(url1_,
 941             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 942 }
 943
 944 // Ensures active tab properly restored when tabs before it closed.
 945 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ActiveIndexUpdatedAtClose) {
 946   ui_test_utils::NavigateToURL(browser(), url1_);
 947   ui_test_utils::NavigateToURLWithDisposition(
 948       browser(), url2_, NEW_FOREGROUND_TAB,
 949       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 950   ui_test_utils::NavigateToURLWithDisposition(
 951       browser(), url3_, NEW_BACKGROUND_TAB,
 952       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 953
 954   browser()->tab_strip_model()->CloseWebContentsAt(
 955       0,
 956       TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
 957
 958   Browser* new_browser = QuitBrowserAndRestore(browser(), 2);
 959
 960   ASSERT_EQ(url2_,
 961             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 962   ASSERT_EQ(new_browser->tab_strip_model()->active_index(), 0);
 963 }
 964
 965 // Ensures active tab properly restored when tabs are inserted before it .
 966 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ActiveIndexUpdatedAtInsert) {
 967   ui_test_utils::NavigateToURL(browser(), url1_);
 968   ui_test_utils::NavigateToURLWithDisposition(
 969       browser(), url2_, NEW_BACKGROUND_TAB,
 970       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 971
 972   chrome::NavigateParams navigate_params(browser(), url3_,
 973                                          ui::PAGE_TRANSITION_TYPED);
 974   navigate_params.tabstrip_index = 0;
 975   navigate_params.disposition = NEW_BACKGROUND_TAB;
 976   ui_test_utils::NavigateToURL(&navigate_params);
 977
 978   Browser* new_browser = QuitBrowserAndRestore(browser(), 3);
 979
 980   ASSERT_EQ(url1_,
 981             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 982   ASSERT_EQ(new_browser->tab_strip_model()->active_index(), 1);
 983 }
 984
 985 #if !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
 986 // This test doesn't apply to the Mac version; see GetCommandLineForRelaunch
 987 // for details. It was disabled for a long time so might never have worked on
 988 // ChromeOS.
 989
 990 // Launches an app window, closes tabbed browser, launches and makes sure
 991 // we restore the tabbed browser url.
 992 // If this test flakes, use http://crbug.com/29110
 993 IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 994                        RestoreAfterClosingTabbedBrowserWithAppAndLaunching) {
 995 #if defined(OS_WIN) && defined(USE_ASH)
 996   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
 997   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
 998           switches::kAshBrowserTests))
 999     return;
1000 #endif
1001
1002   ui_test_utils::NavigateToURL(browser(), url1_);
1003
1004   // Launch an app.
1005   base::CommandLine app_launch_arguments = GetCommandLineForRelaunch();
1006   app_launch_arguments.AppendSwitchASCII(switches::kApp, url2_.spec());
1007
1008   ui_test_utils::BrowserAddedObserver window_observer;
1009
1010   base::LaunchProcess(app_launch_arguments, base::LaunchOptionsForTest());
1011
1012   Browser* app_window = window_observer.WaitForSingleNewBrowser();
1013   ASSERT_EQ(2u, active_browser_list_->size());
1014
1015   // Close the first window. The only window left is the App window.
1016   CloseBrowserSynchronously(browser());
1017
1018   // Restore the session, which should bring back the first window with url1_.
1019   Browser* new_browser = QuitBrowserAndRestore(app_window, 1);
1020
1021   AssertOneWindowWithOneTab(new_browser);
1022
1023   ASSERT_EQ(url1_,
1024             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1025 }
1026
1027 #endif  // !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
1028
1029 // Creates two windows, closes one, restores, make sure only one window open.
1030 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, TwoWindowsCloseOneRestoreOnlyOne) {
1031   ui_test_utils::NavigateToURL(browser(), url1_);
1032
1033   // Open a second window.
1034   ui_test_utils::NavigateToURLWithDisposition(
1035       browser(),
1036       GURL(url::kAboutBlankURL),
1037       NEW_WINDOW,
1038       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
1039
1040   ASSERT_EQ(2u, active_browser_list_->size());
1041
1042   // Close it.
1043   Browser* new_window = active_browser_list_->get(1);
1044   CloseBrowserSynchronously(new_window);
1045
1046   // Restart and make sure we have only one window with one tab and the url
1047   // is url1_.
1048   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1049
1050   AssertOneWindowWithOneTab(new_browser);
1051
1052   ASSERT_EQ(url1_,
1053             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1054 }
1055
1056 // Make sure after a restore the number of processes matches that of the number
1057 // of processes running before the restore. This creates a new tab so that
1058 // we should have two new tabs running.  (This test will pass in both
1059 // process-per-site and process-per-site-instance, because we treat the new tab
1060 // as a special case in process-per-site-instance so that it only ever uses one
1061 // process.)
1062 //
1063 // Flaky: http://code.google.com/p/chromium/issues/detail?id=52022
1064 // Unfortunately, the fix at http://codereview.chromium.org/6546078
1065 // breaks NTP background image refreshing, so ThemeSource had to revert to
1066 // replacing the existing data source.
1067 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ShareProcessesOnRestore) {
1068   // Create two new tabs.
1069   ui_test_utils::NavigateToURLWithDisposition(
1070       browser(),
1071       GURL(url::kAboutBlankURL),
1072       NEW_FOREGROUND_TAB,
1073       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1074   ui_test_utils::NavigateToURLWithDisposition(
1075       browser(),
1076       GURL(url::kAboutBlankURL),
1077       NEW_FOREGROUND_TAB,
1078       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1079
1080   int expected_process_count = RenderProcessHostCount();
1081
1082   // Restart.
1083   Browser* new_browser = QuitBrowserAndRestore(browser(), 3);
1084
1085   ASSERT_EQ(3, new_browser->tab_strip_model()->count());
1086
1087   ASSERT_EQ(expected_process_count, RenderProcessHostCount());
1088 }
1089
1090 // Test that changing the user agent override will persist it to disk.
1091 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, PersistAndRestoreUserAgentOverride) {
1092   // Create a tab with an overridden user agent.
1093   ui_test_utils::NavigateToURL(browser(), url1_);
1094   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
1095   browser()->tab_strip_model()->GetWebContentsAt(0)->
1096       SetUserAgentOverride("override");
1097
1098   // Create a tab without an overridden user agent.
1099   ui_test_utils::NavigateToURLWithDisposition(
1100       browser(), url2_, NEW_FOREGROUND_TAB,
1101       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1102   ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
1103
1104   // Kill the original browser then open a new one to trigger a restore.
1105   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1106   ASSERT_EQ(1u, active_browser_list_->size());
1107   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1108   ASSERT_EQ(1, new_browser->tab_strip_model()->active_index());
1109
1110   // Confirm that the user agent overrides are properly set.
1111   EXPECT_EQ("override",
1112             new_browser->tab_strip_model()->GetWebContentsAt(0)->
1113                 GetUserAgentOverride());
1114   EXPECT_EQ("",
1115             new_browser->tab_strip_model()->GetWebContentsAt(1)->
1116                 GetUserAgentOverride());
1117 }
1118
1119 // Regression test for crbug.com/125958. When restoring a pinned selected tab in
1120 // a setting where there are existing tabs, the selected index computation was
1121 // wrong, leading to the wrong tab getting selected, DCHECKs firing, and the
1122 // pinned tab not getting loaded.
1123 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestorePinnedSelectedTab) {
1124   // Create a pinned tab.
1125   ui_test_utils::NavigateToURL(browser(), url1_);
1126   browser()->tab_strip_model()->SetTabPinned(0, true);
1127   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
1128   // Create a nonpinned tab.
1129   ui_test_utils::NavigateToURLWithDisposition(
1130       browser(), url2_, NEW_FOREGROUND_TAB,
1131       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1132   ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
1133   // Select the pinned tab.
1134   browser()->tab_strip_model()->ActivateTabAt(0, true);
1135   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
1136   Profile* profile = browser()->profile();
1137
1138   // This will also initiate a session restore, but we're not interested in it.
1139   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1140   ASSERT_EQ(1u, active_browser_list_->size());
1141   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1142   ASSERT_EQ(0, new_browser->tab_strip_model()->active_index());
1143   // Close the pinned tab.
1144   chrome::CloseTab(new_browser);
1145   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
1146   ASSERT_EQ(0, new_browser->tab_strip_model()->active_index());
1147   // Use the existing tab to navigate away, so that we can verify it was really
1148   // clobbered.
1149   ui_test_utils::NavigateToURL(new_browser, url3_);
1150
1151   // Restore the session again, clobbering the existing tab.
1152   SessionRestore::RestoreSession(
1153       profile, new_browser,
1154       new_browser->host_desktop_type(),
1155       SessionRestore::CLOBBER_CURRENT_TAB | SessionRestore::SYNCHRONOUS,
1156       std::vector<GURL>());
1157
1158   // The pinned tab is the selected tab.
1159   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1160   EXPECT_EQ(0, new_browser->tab_strip_model()->active_index());
1161   EXPECT_EQ(url1_,
1162             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1163   EXPECT_EQ(url2_,
1164             new_browser->tab_strip_model()->GetWebContentsAt(1)->GetURL());
1165 }
1166
1167 // Regression test for crbug.com/240156. When restoring tabs with a navigation,
1168 // the navigation should take active tab focus.
1169 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreWithNavigateSelectedTab) {
1170   // Create 2 tabs.
1171   ui_test_utils::NavigateToURL(browser(), url1_);
1172   ui_test_utils::NavigateToURLWithDisposition(
1173       browser(), url2_, NEW_FOREGROUND_TAB,
1174       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1175
1176   // Restore the session by calling chrome::Navigate().
1177   Browser* new_browser =
1178       QuitBrowserAndRestoreWithURL(browser(), 3, url3_, true);
1179   ASSERT_EQ(1u, active_browser_list_->size());
1180   ASSERT_EQ(3, new_browser->tab_strip_model()->count());
1181   // Navigated url should be the active tab.
1182   ASSERT_EQ(url3_,
1183             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1184 }
1185
1186 // Do a clobber restore from the new tab page. This test follows the code path
1187 // of a crash followed by the user clicking restore from the new tab page.
1188 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ClobberRestoreTest) {
1189   // Create 2 tabs.
1190   ui_test_utils::NavigateToURL(browser(), url1_);
1191   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
1192   ui_test_utils::NavigateToURLWithDisposition(
1193       browser(), url2_, NEW_FOREGROUND_TAB,
1194       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
1195   ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
1196   Profile* profile = browser()->profile();
1197
1198   // This will also initiate a session restore, but we're not interested in it.
1199   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1200   ASSERT_EQ(1u, active_browser_list_->size());
1201   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1202   ASSERT_EQ(1, new_browser->tab_strip_model()->active_index());
1203   // Close the first tab.
1204   chrome::CloseTab(new_browser);
1205   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
1206   ASSERT_EQ(0, new_browser->tab_strip_model()->active_index());
1207   // Use the existing tab to navigate to the NTP.
1208   ui_test_utils::NavigateToURL(new_browser, GURL(chrome::kChromeUINewTabURL));
1209
1210   // Restore the session again, clobbering the existing tab.
1211   SessionRestore::RestoreSession(
1212       profile, new_browser,
1213       new_browser->host_desktop_type(),
1214       SessionRestore::CLOBBER_CURRENT_TAB | SessionRestore::SYNCHRONOUS,
1215       std::vector<GURL>());
1216
1217   // 2 tabs should have been restored, with the existing tab clobbered, giving
1218   // us a total of 2 tabs.
1219   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
1220   EXPECT_EQ(1, new_browser->tab_strip_model()->active_index());
1221   EXPECT_EQ(url1_,
1222             new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
1223   EXPECT_EQ(url2_,
1224             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1225 }
1226
1227 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, SessionStorage) {
1228   ui_test_utils::NavigateToURL(browser(), url1_);
1229   content::NavigationController* controller =
1230       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
1231   ASSERT_TRUE(controller->GetDefaultSessionStorageNamespace());
1232   std::string session_storage_persistent_id =
1233       controller->GetDefaultSessionStorageNamespace()->persistent_id();
1234   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1235   ASSERT_EQ(1u, active_browser_list_->size());
1236   ASSERT_EQ(url1_,
1237             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
1238   content::NavigationController* new_controller =
1239       &new_browser->tab_strip_model()->GetActiveWebContents()->GetController();
1240   ASSERT_TRUE(new_controller->GetDefaultSessionStorageNamespace());
1241   std::string restored_session_storage_persistent_id =
1242       new_controller->GetDefaultSessionStorageNamespace()->persistent_id();
1243   EXPECT_EQ(session_storage_persistent_id,
1244             restored_session_storage_persistent_id);
1245 }
1246
1247 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, SessionStorageAfterTabReplace) {
1248   // Simulate what prerendering does: create a new WebContents with the same
1249   // SessionStorageNamespace as an existing tab, then replace the tab with it.
1250   {
1251     content::NavigationController* controller =
1252         &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
1253     ASSERT_TRUE(controller->GetDefaultSessionStorageNamespace());
1254
1255     content::SessionStorageNamespaceMap session_storage_namespace_map;
1256     session_storage_namespace_map[std::string()] =
1257         controller->GetDefaultSessionStorageNamespace();
1258     scoped_ptr<content::WebContents> web_contents(
1259         content::WebContents::CreateWithSessionStorage(
1260             content::WebContents::CreateParams(browser()->profile()),
1261             session_storage_namespace_map));
1262
1263     TabStripModel* tab_strip_model = browser()->tab_strip_model();
1264     scoped_ptr<content::WebContents> old_web_contents(
1265         tab_strip_model->ReplaceWebContentsAt(
1266             tab_strip_model->active_index(), web_contents.release()));
1267     // Navigate with the new tab.
1268     ui_test_utils::NavigateToURL(browser(), url2_);
1269     // old_web_contents goes out of scope.
1270   }
1271
1272   // Check that the sessionStorage data is going to be persisted.
1273   content::NavigationController* controller =
1274       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
1275   EXPECT_TRUE(
1276       controller->GetDefaultSessionStorageNamespace()->should_persist());
1277
1278   // Quit and restore. Check that no extra tabs were created.
1279   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
1280   ASSERT_EQ(1u, active_browser_list_->size());
1281   EXPECT_EQ(1, new_browser->tab_strip_model()->count());
1282 }