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