chrome/browser/sessions/session_service_unittest.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/bind.h"
   6 #include "base/bind_helpers.h"
   7 #include "base/file_util.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/memory/scoped_vector.h"
  11 #include "base/path_service.h"
  12 #include "base/stl_util.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "base/time/time.h"
  16 #include "chrome/browser/chrome_notification_types.h"
  17 #include "chrome/browser/defaults.h"
  18 #include "chrome/browser/sessions/session_backend.h"
  19 #include "chrome/browser/sessions/session_service.h"
  20 #include "chrome/browser/sessions/session_service_test_helper.h"
  21 #include "chrome/browser/sessions/session_types.h"
  22 #include "chrome/common/chrome_paths.h"
  23 #include "chrome/common/url_constants.h"
  24 #include "chrome/test/base/browser_with_test_window_test.h"
  25 #include "chrome/test/base/testing_profile.h"
  26 #include "components/sessions/serialized_navigation_entry_test_helper.h"
  27 #include "content/public/browser/navigation_entry.h"
  28 #include "content/public/browser/notification_observer.h"
  29 #include "content/public/browser/notification_registrar.h"
  30 #include "content/public/browser/notification_service.h"
  31 #include "content/public/common/page_state.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 using content::NavigationEntry;
  35 using sessions::SerializedNavigationEntry;
  36 using sessions::SerializedNavigationEntryTestHelper;
  37
  38 class SessionServiceTest : public BrowserWithTestWindowTest,
  39                            public content::NotificationObserver {
  40  public:
  41   SessionServiceTest() : window_bounds(0, 1, 2, 3), sync_save_count_(0) {}
  42
  43  protected:
  44   virtual void SetUp() {
  45     BrowserWithTestWindowTest::SetUp();
  46     std::string b = base::Int64ToString(base::Time::Now().ToInternalValue());
  47
  48     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  49     path_ = temp_dir_.path().Append(FILE_PATH_LITERAL("SessionTestDirs"));
  50     ASSERT_TRUE(base::CreateDirectory(path_));
  51     path_ = path_.AppendASCII(b);
  52
  53     SessionService* session_service = new SessionService(path_);
  54     helper_.SetService(session_service);
  55
  56     service()->SetWindowType(
  57         window_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
  58     service()->SetWindowBounds(window_id,
  59                                window_bounds,
  60                                ui::SHOW_STATE_NORMAL);
  61   }
  62
  63   // Upon notification, increment the sync_save_count variable
  64   virtual void Observe(int type,
  65                        const content::NotificationSource& source,
  66                        const content::NotificationDetails& details) OVERRIDE {
  67     ASSERT_EQ(type, chrome::NOTIFICATION_SESSION_SERVICE_SAVED);
  68     sync_save_count_++;
  69   }
  70
  71   virtual void TearDown() {
  72     helper_.SetService(NULL);
  73     BrowserWithTestWindowTest::TearDown();
  74   }
  75
  76   void UpdateNavigation(
  77       const SessionID& window_id,
  78       const SessionID& tab_id,
  79       const SerializedNavigationEntry& navigation,
  80       bool select) {
  81     service()->UpdateTabNavigation(window_id, tab_id, navigation);
  82     if (select) {
  83       service()->SetSelectedNavigationIndex(
  84           window_id, tab_id, navigation.index());
  85     }
  86   }
  87
  88   void ReadWindows(std::vector<SessionWindow*>* windows,
  89                    SessionID::id_type* active_window_id) {
  90     // Forces closing the file.
  91     helper_.SetService(NULL);
  92
  93     SessionService* session_service = new SessionService(path_);
  94     helper_.SetService(session_service);
  95
  96     SessionID::id_type* non_null_active_window_id = active_window_id;
  97     SessionID::id_type dummy_active_window_id = 0;
  98     if (!non_null_active_window_id)
  99       non_null_active_window_id = &dummy_active_window_id;
 100     helper_.ReadWindows(windows, non_null_active_window_id);
 101   }
 102
 103   // Configures the session service with one window with one tab and a single
 104   // navigation. If |pinned_state| is true or |write_always| is true, the
 105   // pinned state of the tab is updated. The session service is then recreated
 106   // and the pinned state of the read back tab is returned.
 107   bool CreateAndWriteSessionWithOneTab(bool pinned_state, bool write_always) {
 108     SessionID tab_id;
 109     SerializedNavigationEntry nav1 =
 110         SerializedNavigationEntryTestHelper::CreateNavigation(
 111             "http://google.com", "abc");
 112
 113     helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 114     UpdateNavigation(window_id, tab_id, nav1, true);
 115
 116     if (pinned_state || write_always)
 117       helper_.service()->SetPinnedState(window_id, tab_id, pinned_state);
 118
 119     ScopedVector<SessionWindow> windows;
 120     ReadWindows(&(windows.get()), NULL);
 121
 122     EXPECT_EQ(1U, windows.size());
 123     if (HasFatalFailure())
 124       return false;
 125     EXPECT_EQ(1U, windows[0]->tabs.size());
 126     if (HasFatalFailure())
 127       return false;
 128
 129     SessionTab* tab = windows[0]->tabs[0];
 130     helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 131
 132     return tab->pinned;
 133   }
 134
 135   void CreateAndWriteSessionWithTwoWindows(
 136       const SessionID& window2_id,
 137       const SessionID& tab1_id,
 138       const SessionID& tab2_id,
 139       SerializedNavigationEntry* nav1,
 140       SerializedNavigationEntry* nav2) {
 141     *nav1 = SerializedNavigationEntryTestHelper::CreateNavigation(
 142         "http://google.com", "abc");
 143     *nav2 = SerializedNavigationEntryTestHelper::CreateNavigation(
 144         "http://google2.com", "abcd");
 145
 146     helper_.PrepareTabInWindow(window_id, tab1_id, 0, true);
 147     UpdateNavigation(window_id, tab1_id, *nav1, true);
 148
 149     const gfx::Rect window2_bounds(3, 4, 5, 6);
 150     service()->SetWindowType(
 151         window2_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
 152     service()->SetWindowBounds(window2_id,
 153                                window2_bounds,
 154                                ui::SHOW_STATE_MAXIMIZED);
 155     helper_.PrepareTabInWindow(window2_id, tab2_id, 0, true);
 156     UpdateNavigation(window2_id, tab2_id, *nav2, true);
 157   }
 158
 159   SessionService* service() { return helper_.service(); }
 160
 161   SessionBackend* backend() { return helper_.backend(); }
 162
 163   const gfx::Rect window_bounds;
 164
 165   SessionID window_id;
 166
 167   int sync_save_count_;
 168
 169   // Path used in testing.
 170   base::ScopedTempDir temp_dir_;
 171   base::FilePath path_;
 172
 173   SessionServiceTestHelper helper_;
 174 };
 175
 176 TEST_F(SessionServiceTest, Basic) {
 177   SessionID tab_id;
 178   ASSERT_NE(window_id.id(), tab_id.id());
 179
 180   SerializedNavigationEntry nav1 =
 181       SerializedNavigationEntryTestHelper::CreateNavigation(
 182           "http://google.com", "abc");
 183   SerializedNavigationEntryTestHelper::SetOriginalRequestURL(
 184       GURL("http://original.request.com"), &nav1);
 185
 186   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 187   UpdateNavigation(window_id, tab_id, nav1, true);
 188
 189   ScopedVector<SessionWindow> windows;
 190   ReadWindows(&(windows.get()), NULL);
 191
 192   ASSERT_EQ(1U, windows.size());
 193   ASSERT_TRUE(window_bounds == windows[0]->bounds);
 194   ASSERT_EQ(0, windows[0]->selected_tab_index);
 195   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
 196   ASSERT_EQ(1U, windows[0]->tabs.size());
 197   ASSERT_EQ(Browser::TYPE_TABBED, windows[0]->type);
 198
 199   SessionTab* tab = windows[0]->tabs[0];
 200   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 201
 202   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 203 }
 204
 205 // Make sure we persist post entries.
 206 TEST_F(SessionServiceTest, PersistPostData) {
 207   SessionID tab_id;
 208   ASSERT_NE(window_id.id(), tab_id.id());
 209
 210   SerializedNavigationEntry nav1 =
 211       SerializedNavigationEntryTestHelper::CreateNavigation(
 212           "http://google.com", "abc");
 213   SerializedNavigationEntryTestHelper::SetHasPostData(true, &nav1);
 214
 215   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 216   UpdateNavigation(window_id, tab_id, nav1, true);
 217
 218   ScopedVector<SessionWindow> windows;
 219   ReadWindows(&(windows.get()), NULL);
 220
 221   helper_.AssertSingleWindowWithSingleTab(windows.get(), 1);
 222 }
 223
 224 TEST_F(SessionServiceTest, ClosingTabStaysClosed) {
 225   SessionID tab_id;
 226   SessionID tab2_id;
 227   ASSERT_NE(tab_id.id(), tab2_id.id());
 228
 229   SerializedNavigationEntry nav1 =
 230       SerializedNavigationEntryTestHelper::CreateNavigation(
 231           "http://google.com", "abc");
 232   SerializedNavigationEntry nav2 =
 233       SerializedNavigationEntryTestHelper::CreateNavigation(
 234           "http://google2.com", "abcd");
 235
 236   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 237   UpdateNavigation(window_id, tab_id, nav1, true);
 238
 239   helper_.PrepareTabInWindow(window_id, tab2_id, 1, false);
 240   UpdateNavigation(window_id, tab2_id, nav2, true);
 241   service()->TabClosed(window_id, tab2_id, false);
 242
 243   ScopedVector<SessionWindow> windows;
 244   ReadWindows(&(windows.get()), NULL);
 245
 246   ASSERT_EQ(1U, windows.size());
 247   ASSERT_EQ(0, windows[0]->selected_tab_index);
 248   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
 249   ASSERT_EQ(1U, windows[0]->tabs.size());
 250
 251   SessionTab* tab = windows[0]->tabs[0];
 252   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 253
 254   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 255 }
 256
 257 TEST_F(SessionServiceTest, Pruning) {
 258   SessionID tab_id;
 259
 260   SerializedNavigationEntry nav1 =
 261       SerializedNavigationEntryTestHelper::CreateNavigation(
 262           "http://google.com", "abc");
 263   SerializedNavigationEntry nav2 =
 264       SerializedNavigationEntryTestHelper::CreateNavigation(
 265           "http://google2.com", "abcd");
 266
 267   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 268   for (int i = 0; i < 6; ++i) {
 269     SerializedNavigationEntry* nav = (i % 2) == 0 ? &nav1 : &nav2;
 270     nav->set_index(i);
 271     UpdateNavigation(window_id, tab_id, *nav, true);
 272   }
 273   service()->TabNavigationPathPrunedFromBack(window_id, tab_id, 3);
 274
 275   ScopedVector<SessionWindow> windows;
 276   ReadWindows(&(windows.get()), NULL);
 277
 278   ASSERT_EQ(1U, windows.size());
 279   ASSERT_EQ(0, windows[0]->selected_tab_index);
 280   ASSERT_EQ(1U, windows[0]->tabs.size());
 281
 282   SessionTab* tab = windows[0]->tabs[0];
 283   // We left the selected index at 5, then pruned. When rereading the
 284   // index should get reset to last valid navigation, which is 2.
 285   helper_.AssertTabEquals(window_id, tab_id, 0, 2, 3, *tab);
 286
 287   ASSERT_EQ(3u, tab->navigations.size());
 288   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 289   helper_.AssertNavigationEquals(nav2, tab->navigations[1]);
 290   helper_.AssertNavigationEquals(nav1, tab->navigations[2]);
 291 }
 292
 293 TEST_F(SessionServiceTest, TwoWindows) {
 294   SessionID window2_id;
 295   SessionID tab1_id;
 296   SessionID tab2_id;
 297   SerializedNavigationEntry nav1;
 298   SerializedNavigationEntry nav2;
 299
 300   CreateAndWriteSessionWithTwoWindows(
 301       window2_id, tab1_id, tab2_id, &nav1, &nav2);
 302
 303   ScopedVector<SessionWindow> windows;
 304   ReadWindows(&(windows.get()), NULL);
 305
 306   ASSERT_EQ(2U, windows.size());
 307   ASSERT_EQ(0, windows[0]->selected_tab_index);
 308   ASSERT_EQ(0, windows[1]->selected_tab_index);
 309   ASSERT_EQ(1U, windows[0]->tabs.size());
 310   ASSERT_EQ(1U, windows[1]->tabs.size());
 311
 312   SessionTab* rt1;
 313   SessionTab* rt2;
 314   if (windows[0]->window_id.id() == window_id.id()) {
 315     ASSERT_EQ(window2_id.id(), windows[1]->window_id.id());
 316     ASSERT_EQ(ui::SHOW_STATE_NORMAL, windows[0]->show_state);
 317     ASSERT_EQ(ui::SHOW_STATE_MAXIMIZED, windows[1]->show_state);
 318     rt1 = windows[0]->tabs[0];
 319     rt2 = windows[1]->tabs[0];
 320   } else {
 321     ASSERT_EQ(window2_id.id(), windows[0]->window_id.id());
 322     ASSERT_EQ(window_id.id(), windows[1]->window_id.id());
 323     ASSERT_EQ(ui::SHOW_STATE_MAXIMIZED, windows[0]->show_state);
 324     ASSERT_EQ(ui::SHOW_STATE_NORMAL, windows[1]->show_state);
 325     rt1 = windows[1]->tabs[0];
 326     rt2 = windows[0]->tabs[0];
 327   }
 328   SessionTab* tab = rt1;
 329   helper_.AssertTabEquals(window_id, tab1_id, 0, 0, 1, *tab);
 330   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 331
 332   tab = rt2;
 333   helper_.AssertTabEquals(window2_id, tab2_id, 0, 0, 1, *tab);
 334   helper_.AssertNavigationEquals(nav2, tab->navigations[0]);
 335 }
 336
 337 TEST_F(SessionServiceTest, WindowWithNoTabsGetsPruned) {
 338   SessionID window2_id;
 339   SessionID tab1_id;
 340   SessionID tab2_id;
 341
 342   SerializedNavigationEntry nav1 =
 343       SerializedNavigationEntryTestHelper::CreateNavigation(
 344           "http://google.com", "abc");
 345
 346   helper_.PrepareTabInWindow(window_id, tab1_id, 0, true);
 347   UpdateNavigation(window_id, tab1_id, nav1, true);
 348
 349   const gfx::Rect window2_bounds(3, 4, 5, 6);
 350   service()->SetWindowType(
 351       window2_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
 352   service()->SetWindowBounds(window2_id,
 353                              window2_bounds,
 354                              ui::SHOW_STATE_NORMAL);
 355   helper_.PrepareTabInWindow(window2_id, tab2_id, 0, true);
 356
 357   ScopedVector<SessionWindow> windows;
 358   ReadWindows(&(windows.get()), NULL);
 359
 360   ASSERT_EQ(1U, windows.size());
 361   ASSERT_EQ(0, windows[0]->selected_tab_index);
 362   ASSERT_EQ(1U, windows[0]->tabs.size());
 363   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
 364
 365   SessionTab* tab = windows[0]->tabs[0];
 366   helper_.AssertTabEquals(window_id, tab1_id, 0, 0, 1, *tab);
 367   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 368 }
 369
 370 TEST_F(SessionServiceTest, ClosingWindowDoesntCloseTabs) {
 371   SessionID tab_id;
 372   SessionID tab2_id;
 373   ASSERT_NE(tab_id.id(), tab2_id.id());
 374
 375   SerializedNavigationEntry nav1 =
 376       SerializedNavigationEntryTestHelper::CreateNavigation(
 377           "http://google.com", "abc");
 378   SerializedNavigationEntry nav2 =
 379       SerializedNavigationEntryTestHelper::CreateNavigation(
 380           "http://google2.com", "abcd");
 381
 382   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 383   UpdateNavigation(window_id, tab_id, nav1, true);
 384
 385   helper_.PrepareTabInWindow(window_id, tab2_id, 1, false);
 386   UpdateNavigation(window_id, tab2_id, nav2, true);
 387
 388   service()->WindowClosing(window_id);
 389
 390   ScopedVector<SessionWindow> windows;
 391   ReadWindows(&(windows.get()), NULL);
 392
 393   ASSERT_EQ(1U, windows.size());
 394   ASSERT_EQ(0, windows[0]->selected_tab_index);
 395   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
 396   ASSERT_EQ(2U, windows[0]->tabs.size());
 397
 398   SessionTab* tab = windows[0]->tabs[0];
 399   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 400   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 401
 402   tab = windows[0]->tabs[1];
 403   helper_.AssertTabEquals(window_id, tab2_id, 1, 0, 1, *tab);
 404   helper_.AssertNavigationEquals(nav2, tab->navigations[0]);
 405 }
 406
 407 TEST_F(SessionServiceTest, WindowCloseCommittedAfterNavigate) {
 408   SessionID window2_id;
 409   SessionID tab_id;
 410   SessionID tab2_id;
 411   ASSERT_NE(window2_id.id(), window_id.id());
 412
 413   service()->SetWindowType(
 414       window2_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
 415   service()->SetWindowBounds(window2_id,
 416                              window_bounds,
 417                              ui::SHOW_STATE_NORMAL);
 418
 419   SerializedNavigationEntry nav1 =
 420       SerializedNavigationEntryTestHelper::CreateNavigation(
 421           "http://google.com", "abc");
 422   SerializedNavigationEntry nav2 =
 423       SerializedNavigationEntryTestHelper::CreateNavigation(
 424           "http://google2.com", "abcd");
 425
 426   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 427   UpdateNavigation(window_id, tab_id, nav1, true);
 428
 429   helper_.PrepareTabInWindow(window2_id, tab2_id, 0, false);
 430   UpdateNavigation(window2_id, tab2_id, nav2, true);
 431
 432   service()->WindowClosing(window2_id);
 433   service()->TabClosed(window2_id, tab2_id, false);
 434   service()->WindowClosed(window2_id);
 435
 436   ScopedVector<SessionWindow> windows;
 437   ReadWindows(&(windows.get()), NULL);
 438
 439   ASSERT_EQ(1U, windows.size());
 440   ASSERT_EQ(0, windows[0]->selected_tab_index);
 441   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
 442   ASSERT_EQ(1U, windows[0]->tabs.size());
 443
 444   SessionTab* tab = windows[0]->tabs[0];
 445   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 446   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 447 }
 448
 449 // Makes sure we don't track popups.
 450 TEST_F(SessionServiceTest, IgnorePopups) {
 451   if (browser_defaults::kRestorePopups)
 452     return;  // This test is only applicable if popups aren't restored.
 453
 454   SessionID window2_id;
 455   SessionID tab_id;
 456   SessionID tab2_id;
 457   ASSERT_NE(window2_id.id(), window_id.id());
 458
 459   service()->SetWindowType(
 460       window2_id, Browser::TYPE_POPUP, SessionService::TYPE_NORMAL);
 461   service()->SetWindowBounds(window2_id,
 462                              window_bounds,
 463                              ui::SHOW_STATE_NORMAL);
 464
 465   SerializedNavigationEntry nav1 =
 466       SerializedNavigationEntryTestHelper::CreateNavigation(
 467           "http://google.com", "abc");
 468   SerializedNavigationEntry nav2 =
 469       SerializedNavigationEntryTestHelper::CreateNavigation(
 470           "http://google2.com", "abcd");
 471
 472   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 473   UpdateNavigation(window_id, tab_id, nav1, true);
 474
 475   helper_.PrepareTabInWindow(window2_id, tab2_id, 0, false);
 476   UpdateNavigation(window2_id, tab2_id, nav2, true);
 477
 478   ScopedVector<SessionWindow> windows;
 479   ReadWindows(&(windows.get()), NULL);
 480
 481   ASSERT_EQ(1U, windows.size());
 482   ASSERT_EQ(0, windows[0]->selected_tab_index);
 483   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
 484   ASSERT_EQ(1U, windows[0]->tabs.size());
 485
 486   SessionTab* tab = windows[0]->tabs[0];
 487   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 488   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 489 }
 490
 491 // Makes sure we track popups.
 492 TEST_F(SessionServiceTest, RestorePopup) {
 493   if (!browser_defaults::kRestorePopups)
 494     return;  // This test is only applicable if popups are restored.
 495
 496   SessionID window2_id;
 497   SessionID tab_id;
 498   SessionID tab2_id;
 499   ASSERT_NE(window2_id.id(), window_id.id());
 500
 501   service()->SetWindowType(
 502       window2_id, Browser::TYPE_POPUP, SessionService::TYPE_NORMAL);
 503   service()->SetWindowBounds(window2_id,
 504                              window_bounds,
 505                              ui::SHOW_STATE_NORMAL);
 506
 507   SerializedNavigationEntry nav1 =
 508       SerializedNavigationEntryTestHelper::CreateNavigation(
 509           "http://google.com", "abc");
 510   SerializedNavigationEntry nav2 =
 511       SerializedNavigationEntryTestHelper::CreateNavigation(
 512           "http://google2.com", "abcd");
 513
 514   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 515   UpdateNavigation(window_id, tab_id, nav1, true);
 516
 517   helper_.PrepareTabInWindow(window2_id, tab2_id, 0, false);
 518   UpdateNavigation(window2_id, tab2_id, nav2, true);
 519
 520   ScopedVector<SessionWindow> windows;
 521   ReadWindows(&(windows.get()), NULL);
 522
 523   ASSERT_EQ(2U, windows.size());
 524   int tabbed_index = windows[0]->type == Browser::TYPE_TABBED ?
 525       0 : 1;
 526   int popup_index = tabbed_index == 0 ? 1 : 0;
 527   ASSERT_EQ(0, windows[tabbed_index]->selected_tab_index);
 528   ASSERT_EQ(window_id.id(), windows[tabbed_index]->window_id.id());
 529   ASSERT_EQ(1U, windows[tabbed_index]->tabs.size());
 530
 531   SessionTab* tab = windows[tabbed_index]->tabs[0];
 532   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 533   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 534
 535   ASSERT_EQ(0, windows[popup_index]->selected_tab_index);
 536   ASSERT_EQ(window2_id.id(), windows[popup_index]->window_id.id());
 537   ASSERT_EQ(1U, windows[popup_index]->tabs.size());
 538
 539   tab = windows[popup_index]->tabs[0];
 540   helper_.AssertTabEquals(window2_id, tab2_id, 0, 0, 1, *tab);
 541   helper_.AssertNavigationEquals(nav2, tab->navigations[0]);
 542 }
 543
 544 #if defined (OS_CHROMEOS)
 545 // Makes sure we track apps. Only applicable on chromeos.
 546 TEST_F(SessionServiceTest, RestoreApp) {
 547   SessionID window2_id;
 548   SessionID tab_id;
 549   SessionID tab2_id;
 550   ASSERT_NE(window2_id.id(), window_id.id());
 551
 552   service()->SetWindowType(
 553       window2_id, Browser::TYPE_POPUP, SessionService::TYPE_APP);
 554   service()->SetWindowBounds(window2_id,
 555                              window_bounds,
 556                              ui::SHOW_STATE_NORMAL);
 557   service()->SetWindowAppName(window2_id, "TestApp");
 558
 559   SerializedNavigationEntry nav1 =
 560       SerializedNavigationEntryTestHelper::CreateNavigation(
 561           "http://google.com", "abc");
 562   SerializedNavigationEntry nav2 =
 563       SerializedNavigationEntryTestHelper::CreateNavigation(
 564           "http://google2.com", "abcd");
 565
 566   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 567   UpdateNavigation(window_id, tab_id, nav1, true);
 568
 569   helper_.PrepareTabInWindow(window2_id, tab2_id, 0, false);
 570   UpdateNavigation(window2_id, tab2_id, nav2, true);
 571
 572   ScopedVector<SessionWindow> windows;
 573   ReadWindows(&(windows.get()), NULL);
 574
 575   ASSERT_EQ(2U, windows.size());
 576   int tabbed_index = windows[0]->type == Browser::TYPE_TABBED ?
 577       0 : 1;
 578   int app_index = tabbed_index == 0 ? 1 : 0;
 579   ASSERT_EQ(0, windows[tabbed_index]->selected_tab_index);
 580   ASSERT_EQ(window_id.id(), windows[tabbed_index]->window_id.id());
 581   ASSERT_EQ(1U, windows[tabbed_index]->tabs.size());
 582
 583   SessionTab* tab = windows[tabbed_index]->tabs[0];
 584   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 585   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 586
 587   ASSERT_EQ(0, windows[app_index]->selected_tab_index);
 588   ASSERT_EQ(window2_id.id(), windows[app_index]->window_id.id());
 589   ASSERT_EQ(1U, windows[app_index]->tabs.size());
 590   ASSERT_TRUE(windows[app_index]->type == Browser::TYPE_POPUP);
 591   ASSERT_EQ("TestApp", windows[app_index]->app_name);
 592
 593   tab = windows[app_index]->tabs[0];
 594   helper_.AssertTabEquals(window2_id, tab2_id, 0, 0, 1, *tab);
 595   helper_.AssertNavigationEquals(nav2, tab->navigations[0]);
 596 }
 597 #endif  // defined (OS_CHROMEOS)
 598
 599 // Tests pruning from the front.
 600 TEST_F(SessionServiceTest, PruneFromFront) {
 601   const std::string base_url("http://google.com/");
 602   SessionID tab_id;
 603
 604   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 605
 606   // Add 5 navigations, with the 4th selected.
 607   for (int i = 0; i < 5; ++i) {
 608     SerializedNavigationEntry nav =
 609         SerializedNavigationEntryTestHelper::CreateNavigation(
 610             base_url + base::IntToString(i), "a");
 611     nav.set_index(i);
 612     UpdateNavigation(window_id, tab_id, nav, (i == 3));
 613   }
 614
 615   // Prune the first two navigations from the front.
 616   helper_.service()->TabNavigationPathPrunedFromFront(window_id, tab_id, 2);
 617
 618   // Read back in.
 619   ScopedVector<SessionWindow> windows;
 620   ReadWindows(&(windows.get()), NULL);
 621
 622   ASSERT_EQ(1U, windows.size());
 623   ASSERT_EQ(0, windows[0]->selected_tab_index);
 624   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
 625   ASSERT_EQ(1U, windows[0]->tabs.size());
 626
 627   // There shouldn't be an app id.
 628   EXPECT_TRUE(windows[0]->tabs[0]->extension_app_id.empty());
 629
 630   // We should be left with three navigations, the 2nd selected.
 631   SessionTab* tab = windows[0]->tabs[0];
 632   ASSERT_EQ(1, tab->current_navigation_index);
 633   EXPECT_EQ(3U, tab->navigations.size());
 634   EXPECT_TRUE(GURL(base_url + base::IntToString(2)) ==
 635               tab->navigations[0].virtual_url());
 636   EXPECT_TRUE(GURL(base_url + base::IntToString(3)) ==
 637               tab->navigations[1].virtual_url());
 638   EXPECT_TRUE(GURL(base_url + base::IntToString(4)) ==
 639               tab->navigations[2].virtual_url());
 640 }
 641
 642 // Prunes from front so that we have no entries.
 643 TEST_F(SessionServiceTest, PruneToEmpty) {
 644   const std::string base_url("http://google.com/");
 645   SessionID tab_id;
 646
 647   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 648
 649   // Add 5 navigations, with the 4th selected.
 650   for (int i = 0; i < 5; ++i) {
 651     SerializedNavigationEntry nav =
 652         SerializedNavigationEntryTestHelper::CreateNavigation(
 653             base_url + base::IntToString(i), "a");
 654     nav.set_index(i);
 655     UpdateNavigation(window_id, tab_id, nav, (i == 3));
 656   }
 657
 658   // Prune the first two navigations from the front.
 659   helper_.service()->TabNavigationPathPrunedFromFront(window_id, tab_id, 5);
 660
 661   // Read back in.
 662   ScopedVector<SessionWindow> windows;
 663   ReadWindows(&(windows.get()), NULL);
 664
 665   ASSERT_EQ(0U, windows.size());
 666 }
 667
 668 // Don't set the pinned state and make sure the pinned value is false.
 669 TEST_F(SessionServiceTest, PinnedDefaultsToFalse) {
 670   EXPECT_FALSE(CreateAndWriteSessionWithOneTab(false, false));
 671 }
 672
 673 // Explicitly set the pinned state to false and make sure we get back false.
 674 TEST_F(SessionServiceTest, PinnedFalseWhenSetToFalse) {
 675   EXPECT_FALSE(CreateAndWriteSessionWithOneTab(false, true));
 676 }
 677
 678 // Explicitly set the pinned state to true and make sure we get back true.
 679 TEST_F(SessionServiceTest, PinnedTrue) {
 680   EXPECT_TRUE(CreateAndWriteSessionWithOneTab(true, true));
 681 }
 682
 683 // Make sure application extension ids are persisted.
 684 TEST_F(SessionServiceTest, PersistApplicationExtensionID) {
 685   SessionID tab_id;
 686   ASSERT_NE(window_id.id(), tab_id.id());
 687   std::string app_id("foo");
 688
 689   SerializedNavigationEntry nav1 =
 690       SerializedNavigationEntryTestHelper::CreateNavigation(
 691           "http://google.com", "abc");
 692
 693   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 694   UpdateNavigation(window_id, tab_id, nav1, true);
 695   helper_.SetTabExtensionAppID(window_id, tab_id, app_id);
 696
 697   ScopedVector<SessionWindow> windows;
 698   ReadWindows(&(windows.get()), NULL);
 699
 700   helper_.AssertSingleWindowWithSingleTab(windows.get(), 1);
 701   EXPECT_TRUE(app_id == windows[0]->tabs[0]->extension_app_id);
 702 }
 703
 704 // Check that user agent overrides are persisted.
 705 TEST_F(SessionServiceTest, PersistUserAgentOverrides) {
 706   SessionID tab_id;
 707   ASSERT_NE(window_id.id(), tab_id.id());
 708   std::string user_agent_override = "Mozilla/5.0 (X11; Linux x86_64) "
 709       "AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.45 "
 710       "Safari/535.19";
 711
 712   SerializedNavigationEntry nav1 =
 713       SerializedNavigationEntryTestHelper::CreateNavigation(
 714           "http://google.com", "abc");
 715   SerializedNavigationEntryTestHelper::SetIsOverridingUserAgent(true, &nav1);
 716
 717   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 718   UpdateNavigation(window_id, tab_id, nav1, true);
 719   helper_.SetTabUserAgentOverride(window_id, tab_id, user_agent_override);
 720
 721   ScopedVector<SessionWindow> windows;
 722   ReadWindows(&(windows.get()), NULL);
 723   helper_.AssertSingleWindowWithSingleTab(windows.get(), 1);
 724
 725   SessionTab* tab = windows[0]->tabs[0];
 726   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 727   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 728   EXPECT_TRUE(user_agent_override == tab->user_agent_override);
 729 }
 730
 731 // Test that the notification for SESSION_SERVICE_SAVED is working properly.
 732 TEST_F(SessionServiceTest, SavedSessionNotification) {
 733   content::NotificationRegistrar registrar_;
 734   registrar_.Add(this, chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
 735                  content::NotificationService::AllSources());
 736   service()->Save();
 737   EXPECT_EQ(sync_save_count_, 1);
 738 }
 739
 740 // Makes sure a tab closed by a user gesture is not restored.
 741 TEST_F(SessionServiceTest, CloseTabUserGesture) {
 742   SessionID tab_id;
 743   ASSERT_NE(window_id.id(), tab_id.id());
 744
 745   SerializedNavigationEntry nav1 =
 746       SerializedNavigationEntryTestHelper::CreateNavigation(
 747           "http://google.com", "abc");
 748
 749   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 750   UpdateNavigation(window_id, tab_id, nav1, true);
 751   service()->TabClosed(window_id, tab_id, true);
 752
 753   ScopedVector<SessionWindow> windows;
 754   ReadWindows(&(windows.get()), NULL);
 755
 756   ASSERT_TRUE(windows.empty());
 757 }
 758
 759 // Verifies SetWindowBounds maps SHOW_STATE_DEFAULT to SHOW_STATE_NORMAL.
 760 TEST_F(SessionServiceTest, DontPersistDefault) {
 761   SessionID tab_id;
 762   ASSERT_NE(window_id.id(), tab_id.id());
 763   SerializedNavigationEntry nav1 =
 764       SerializedNavigationEntryTestHelper::CreateNavigation(
 765           "http://google.com", "abc");
 766   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 767   UpdateNavigation(window_id, tab_id, nav1, true);
 768   service()->SetWindowBounds(window_id,
 769                              window_bounds,
 770                              ui::SHOW_STATE_DEFAULT);
 771
 772   ScopedVector<SessionWindow> windows;
 773   ReadWindows(&(windows.get()), NULL);
 774   ASSERT_EQ(1U, windows.size());
 775   EXPECT_EQ(ui::SHOW_STATE_NORMAL, windows[0]->show_state);
 776 }
 777
 778 TEST_F(SessionServiceTest, KeepPostDataWithoutPasswords) {
 779   SessionID tab_id;
 780   ASSERT_NE(window_id.id(), tab_id.id());
 781
 782   // Create a page state representing a HTTP body without posted passwords.
 783   content::PageState page_state =
 784       content::PageState::CreateForTesting(GURL(), false, "data", NULL);
 785
 786   // Create a TabNavigation containing page_state and representing a POST
 787   // request.
 788   SerializedNavigationEntry nav1 =
 789       SerializedNavigationEntryTestHelper::CreateNavigation(
 790           "http://google.com", "title");
 791   SerializedNavigationEntryTestHelper::SetPageState(page_state, &nav1);
 792   SerializedNavigationEntryTestHelper::SetHasPostData(true, &nav1);
 793
 794   // Create a TabNavigation containing page_state and representing a normal
 795   // request.
 796   SerializedNavigationEntry nav2 =
 797       SerializedNavigationEntryTestHelper::CreateNavigation(
 798           "http://google.com/nopost", "title");
 799   SerializedNavigationEntryTestHelper::SetPageState(page_state, &nav2);
 800   nav2.set_index(1);
 801
 802   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 803   UpdateNavigation(window_id, tab_id, nav1, true);
 804   UpdateNavigation(window_id, tab_id, nav2, true);
 805
 806   ScopedVector<SessionWindow> windows;
 807   ReadWindows(&(windows.get()), NULL);
 808
 809   helper_.AssertSingleWindowWithSingleTab(windows.get(), 2);
 810
 811   // Expected: the page state of both navigations was saved and restored.
 812   ASSERT_EQ(2u, windows[0]->tabs[0]->navigations.size());
 813   helper_.AssertNavigationEquals(nav1, windows[0]->tabs[0]->navigations[0]);
 814   helper_.AssertNavigationEquals(nav2, windows[0]->tabs[0]->navigations[1]);
 815 }
 816
 817 TEST_F(SessionServiceTest, RemovePostDataWithPasswords) {
 818   SessionID tab_id;
 819   ASSERT_NE(window_id.id(), tab_id.id());
 820
 821   // Create a page state representing a HTTP body with posted passwords.
 822   content::PageState page_state =
 823       content::PageState::CreateForTesting(GURL(), true, "data", NULL);
 824
 825   // Create a TabNavigation containing page_state and representing a POST
 826   // request with passwords.
 827   SerializedNavigationEntry nav1 =
 828       SerializedNavigationEntryTestHelper::CreateNavigation(
 829           "http://google.com", "title");
 830   SerializedNavigationEntryTestHelper::SetPageState(page_state, &nav1);
 831   SerializedNavigationEntryTestHelper::SetHasPostData(true, &nav1);
 832   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 833   UpdateNavigation(window_id, tab_id, nav1, true);
 834
 835   ScopedVector<SessionWindow> windows;
 836   ReadWindows(&(windows.get()), NULL);
 837
 838   helper_.AssertSingleWindowWithSingleTab(windows.get(), 1);
 839
 840   // Expected: the HTTP body was removed from the page state of the POST
 841   // navigation with passwords.
 842   EXPECT_NE(page_state, windows[0]->tabs[0]->navigations[0].page_state());
 843 }
 844
 845 // This test is only applicable to chromeos.
 846 #if defined(OS_CHROMEOS)
 847 // Verifies migration of tab/window closed works.
 848 TEST_F(SessionServiceTest, CanOpenV1TabClosed) {
 849   base::FilePath v1_file_path;
 850   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &v1_file_path));
 851   // v1_session_file contains a tab closed command with the original id. The
 852   // file was generated from ClosingTabStaysClosed. If we successfully processed
 853   // the file we'll have one tab.
 854   v1_file_path =
 855       v1_file_path.AppendASCII("sessions").AppendASCII("v1_session_file");
 856   base::FilePath dest_file_path(path_);
 857   dest_file_path = dest_file_path.AppendASCII("Current Session");
 858
 859   // Forces closing the file.
 860   helper_.SetService(NULL);
 861
 862   ASSERT_TRUE(base::CopyFile(v1_file_path, dest_file_path));
 863
 864   SessionService* session_service = new SessionService(path_);
 865   helper_.SetService(session_service);
 866   ScopedVector<SessionWindow> windows;
 867   SessionID::id_type active_window_id = 0;
 868   helper_.ReadWindows(&(windows.get()), &active_window_id);
 869   ASSERT_EQ(1u, windows.size());
 870   EXPECT_EQ(1u, windows[0]->tabs.size());
 871 }
 872 #endif  // defined(OS_CHROMEOS)
 873
 874 TEST_F(SessionServiceTest, ReplacePendingNavigation) {
 875   const std::string base_url("http://google.com/");
 876   SessionID tab_id;
 877
 878   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 879
 880   // Add 5 navigations, some with the same index
 881   for (int i = 0; i < 5; ++i) {
 882     SerializedNavigationEntry nav =
 883         SerializedNavigationEntryTestHelper::CreateNavigation(
 884             base_url + base::IntToString(i), "a");
 885     nav.set_index(i / 2);
 886     UpdateNavigation(window_id, tab_id, nav, true);
 887   }
 888
 889   // Read back in.
 890   ScopedVector<SessionWindow> windows;
 891   ReadWindows(&(windows.get()), NULL);
 892
 893   // The ones with index 0, and 2 should have been replaced by 1 and 3.
 894   ASSERT_EQ(1U, windows.size());
 895   ASSERT_EQ(1U, windows[0]->tabs.size());
 896   EXPECT_EQ(3U, windows[0]->tabs[0]->navigations.size());
 897   EXPECT_EQ(GURL(base_url + base::IntToString(1)),
 898             windows[0]->tabs[0]->navigations[0].virtual_url());
 899   EXPECT_EQ(GURL(base_url + base::IntToString(3)),
 900             windows[0]->tabs[0]->navigations[1].virtual_url());
 901   EXPECT_EQ(GURL(base_url + base::IntToString(4)),
 902             windows[0]->tabs[0]->navigations[2].virtual_url());
 903 }
 904
 905 TEST_F(SessionServiceTest, ReplacePendingNavigationAndPrune) {
 906   const std::string base_url("http://google.com/");
 907   SessionID tab_id;
 908
 909   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
 910
 911   for (int i = 0; i < 5; ++i) {
 912     SerializedNavigationEntry nav =
 913         SerializedNavigationEntryTestHelper::CreateNavigation(
 914             base_url + base::IntToString(i), "a");
 915     nav.set_index(i);
 916     UpdateNavigation(window_id, tab_id, nav, true);
 917   }
 918
 919   // Prune all those navigations.
 920   helper_.service()->TabNavigationPathPrunedFromFront(window_id, tab_id, 5);
 921
 922   // Add another navigation to replace the last one.
 923   SerializedNavigationEntry nav =
 924       SerializedNavigationEntryTestHelper::CreateNavigation(
 925         base_url + base::IntToString(5), "a");
 926   nav.set_index(4);
 927   UpdateNavigation(window_id, tab_id, nav, true);
 928
 929   // Read back in.
 930   ScopedVector<SessionWindow> windows;
 931   ReadWindows(&(windows.get()), NULL);
 932
 933   // We should still have that last navigation at the end,
 934   // even though it replaced one that was set before the prune.
 935   ASSERT_EQ(1U, windows.size());
 936   ASSERT_EQ(1U, windows[0]->tabs.size());
 937   ASSERT_EQ(1U, windows[0]->tabs[0]->navigations.size());
 938   EXPECT_EQ(GURL(base_url + base::IntToString(5)),
 939             windows[0]->tabs[0]->navigations[0].virtual_url());
 940 }
 941
 942 TEST_F(SessionServiceTest, RestoreActivation1) {
 943   SessionID window2_id;
 944   SessionID tab1_id;
 945   SessionID tab2_id;
 946   SerializedNavigationEntry nav1;
 947   SerializedNavigationEntry nav2;
 948
 949   CreateAndWriteSessionWithTwoWindows(
 950       window2_id, tab1_id, tab2_id, &nav1, &nav2);
 951
 952   service()->ScheduleCommand(
 953       service()->CreateSetActiveWindowCommand(window2_id));
 954   service()->ScheduleCommand(
 955       service()->CreateSetActiveWindowCommand(window_id));
 956
 957   ScopedVector<SessionWindow> windows;
 958   SessionID::id_type active_window_id = 0;
 959   ReadWindows(&(windows.get()), &active_window_id);
 960   EXPECT_EQ(window_id.id(), active_window_id);
 961 }
 962
 963 // It's easier to have two separate tests with setup/teardown than to manualy
 964 // reset the state for the different flavors of the test.
 965 TEST_F(SessionServiceTest, RestoreActivation2) {
 966   SessionID window2_id;
 967   SessionID tab1_id;
 968   SessionID tab2_id;
 969   SerializedNavigationEntry nav1;
 970   SerializedNavigationEntry nav2;
 971
 972   CreateAndWriteSessionWithTwoWindows(
 973       window2_id, tab1_id, tab2_id, &nav1, &nav2);
 974
 975   service()->ScheduleCommand(
 976       service()->CreateSetActiveWindowCommand(window2_id));
 977   service()->ScheduleCommand(
 978       service()->CreateSetActiveWindowCommand(window_id));
 979   service()->ScheduleCommand(
 980       service()->CreateSetActiveWindowCommand(window2_id));
 981
 982   ScopedVector<SessionWindow> windows;
 983   SessionID::id_type active_window_id = 0;
 984   ReadWindows(&(windows.get()), &active_window_id);
 985   EXPECT_EQ(window2_id.id(), active_window_id);
 986 }
 987
 988 // Makes sure we don't track blacklisted URLs.
 989 TEST_F(SessionServiceTest, IgnoreBlacklistedUrls) {
 990   SessionID tab_id;
 991
 992   SerializedNavigationEntry nav1 =
 993       SerializedNavigationEntryTestHelper::CreateNavigation(
 994           "http://google.com", "abc");
 995   SerializedNavigationEntry nav2 =
 996       SerializedNavigationEntryTestHelper::CreateNavigation(
 997           chrome::kChromeUIQuitURL, "quit");
 998   SerializedNavigationEntry nav3 =
 999       SerializedNavigationEntryTestHelper::CreateNavigation(
1000           chrome::kChromeUIRestartURL, "restart");
1001
1002   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
1003   UpdateNavigation(window_id, tab_id, nav1, true);
1004   UpdateNavigation(window_id, tab_id, nav2, true);
1005   UpdateNavigation(window_id, tab_id, nav3, true);
1006
1007   ScopedVector<SessionWindow> windows;
1008   ReadWindows(&(windows.get()), NULL);
1009
1010   ASSERT_EQ(1U, windows.size());
1011   ASSERT_EQ(0, windows[0]->selected_tab_index);
1012   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
1013   ASSERT_EQ(1U, windows[0]->tabs.size());
1014
1015   SessionTab* tab = windows[0]->tabs[0];
1016   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
1017   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
1018 }