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