Refactoring of SessionService to get componentized.

chrome/browser/sessions/session_service_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 43 matching lines @@
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
     ASSERT_TRUE(profile_manager_->SetUp());
 
     std::string b = base::Int64ToString(base::Time::Now().ToInternalValue());
     TestingProfile* profile = profile_manager_->CreateTestingProfile(b);
     SessionService* session_service = new SessionService(profile);
     path_ = profile->GetPath();
 
     helper_.SetService(session_service);
 
-    service()->SetWindowType(
-        window_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
+    service()->SetWindowType(window_id,
+                             Browser::TYPE_TABBED,
+                             SessionService::TYPE_NORMAL);
     service()->SetWindowBounds(window_id,
                                window_bounds,
                                ui::SHOW_STATE_NORMAL);
   }
 
   // Upon notification, increment the sync_save_count variable
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override {
     ASSERT_EQ(type, chrome::NOTIFICATION_SESSION_SERVICE_SAVED);
@@ skipping 72 matching lines @@
       SerializedNavigationEntry* nav2) {
     *nav1 = SerializedNavigationEntryTestHelper::CreateNavigation(
         "http://google.com", "abc");
     *nav2 = SerializedNavigationEntryTestHelper::CreateNavigation(
         "http://google2.com", "abcd");
 
     helper_.PrepareTabInWindow(window_id, tab1_id, 0, true);
     UpdateNavigation(window_id, tab1_id, *nav1, true);
 
     const gfx::Rect window2_bounds(3, 4, 5, 6);
-    service()->SetWindowType(
-        window2_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
+    service()->SetWindowType(window2_id,
+                             Browser::TYPE_TABBED,
+                             SessionService::TYPE_NORMAL);
     service()->SetWindowBounds(window2_id,
                                window2_bounds,
                                ui::SHOW_STATE_MAXIMIZED);
     helper_.PrepareTabInWindow(window2_id, tab2_id, 0, true);
     UpdateNavigation(window2_id, tab2_id, *nav2, true);
   }
 
   SessionService* service() { return helper_.service(); }
 
   const gfx::Rect window_bounds;
@@ skipping 24 matching lines @@
   UpdateNavigation(window_id, tab_id, nav1, true);
 
   ScopedVector<SessionWindow> windows;
   ReadWindows(&(windows.get()), NULL);
 
   ASSERT_EQ(1U, windows.size());
   ASSERT_TRUE(window_bounds == windows[0]->bounds);
   ASSERT_EQ(0, windows[0]->selected_tab_index);
   ASSERT_EQ(window_id.id(), windows[0]->window_id.id());
   ASSERT_EQ(1U, windows[0]->tabs.size());
-  ASSERT_EQ(Browser::TYPE_TABBED, windows[0]->type);
+  ASSERT_EQ(SessionWindow::TYPE_TABBED, windows[0]->type);
 
   SessionTab* tab = windows[0]->tabs[0];
   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
 
   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 }
 
 // Make sure we persist post entries.
 TEST_F(SessionServiceTest, PersistPostData) {
   SessionID tab_id;
@@ skipping 132 matching lines @@
   SessionID tab2_id;
 
   SerializedNavigationEntry nav1 =
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://google.com", "abc");
 
   helper_.PrepareTabInWindow(window_id, tab1_id, 0, true);
   UpdateNavigation(window_id, tab1_id, nav1, true);
 
   const gfx::Rect window2_bounds(3, 4, 5, 6);
-  service()->SetWindowType(
-      window2_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
+  service()->SetWindowType(window2_id,
+                           Browser::TYPE_TABBED,
+                           SessionService::TYPE_NORMAL);
   service()->SetWindowBounds(window2_id,
                              window2_bounds,
                              ui::SHOW_STATE_NORMAL);
   helper_.PrepareTabInWindow(window2_id, tab2_id, 0, true);
 
   ScopedVector<SessionWindow> windows;
   ReadWindows(&(windows.get()), NULL);
 
   ASSERT_EQ(1U, windows.size());
   ASSERT_EQ(0, windows[0]->selected_tab_index);
@@ skipping 73 matching lines @@
   ASSERT_EQ(1U, windows[0]->tabs.size());
   ASSERT_EQ(1U, windows[1]->tabs.size());
 }
 
 TEST_F(SessionServiceTest, WindowCloseCommittedAfterNavigate) {
   SessionID window2_id;
   SessionID tab_id;
   SessionID tab2_id;
   ASSERT_NE(window2_id.id(), window_id.id());
 
-  service()->SetWindowType(
-      window2_id, Browser::TYPE_TABBED, SessionService::TYPE_NORMAL);
+  service()->SetWindowType(window2_id,
+                           Browser::TYPE_TABBED,
+                           SessionService::TYPE_NORMAL);
   service()->SetWindowBounds(window2_id,
                              window_bounds,
                              ui::SHOW_STATE_NORMAL);
 
   SerializedNavigationEntry nav1 =
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://google.com", "abc");
   SerializedNavigationEntry nav2 =
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://google2.com", "abcd");
@@ skipping 21 matching lines @@
   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 }
 
 // Makes sure we don't track popups.
 TEST_F(SessionServiceTest, IgnorePopups) {
   SessionID window2_id;
   SessionID tab_id;
   SessionID tab2_id;
   ASSERT_NE(window2_id.id(), window_id.id());
 
-  service()->SetWindowType(
-      window2_id, Browser::TYPE_POPUP, SessionService::TYPE_NORMAL);
+  service()->SetWindowType(window2_id,
+                           Browser::TYPE_POPUP,
+                           SessionService::TYPE_NORMAL);
   service()->SetWindowBounds(window2_id,
                              window_bounds,
                              ui::SHOW_STATE_NORMAL);
 
   SerializedNavigationEntry nav1 =
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://google.com", "abc");
   SerializedNavigationEntry nav2 =
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://google2.com", "abcd");
@@ skipping 18 matching lines @@
 }
 
 #if defined (OS_CHROMEOS)
 // Makes sure we track apps. Only applicable on chromeos.
 TEST_F(SessionServiceTest, RestoreApp) {
   SessionID window2_id;
   SessionID tab_id;
   SessionID tab2_id;
   ASSERT_NE(window2_id.id(), window_id.id());
 
-  service()->SetWindowType(
-      window2_id, Browser::TYPE_POPUP, SessionService::TYPE_APP);
+  service()->SetWindowType(window2_id,
+                           Browser::TYPE_POPUP,
+                           SessionService::TYPE_APP);
   service()->SetWindowBounds(window2_id,
                              window_bounds,
                              ui::SHOW_STATE_NORMAL);
   service()->SetWindowAppName(window2_id, "TestApp");
 
   SerializedNavigationEntry nav1 =
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://google.com", "abc");
   SerializedNavigationEntry nav2 =
       SerializedNavigationEntryTestHelper::CreateNavigation(
           "http://google2.com", "abcd");
 
   helper_.PrepareTabInWindow(window_id, tab_id, 0, true);
   UpdateNavigation(window_id, tab_id, nav1, true);
 
   helper_.PrepareTabInWindow(window2_id, tab2_id, 0, false);
   UpdateNavigation(window2_id, tab2_id, nav2, true);
 
   ScopedVector<SessionWindow> windows;
   ReadWindows(&(windows.get()), NULL);
 
   ASSERT_EQ(2U, windows.size());
-  int tabbed_index = windows[0]->type == Browser::TYPE_TABBED ?
+  int tabbed_index = windows[0]->type == SessionWindow::TYPE_TABBED ?
       0 : 1;
   int app_index = tabbed_index == 0 ? 1 : 0;
   ASSERT_EQ(0, windows[tabbed_index]->selected_tab_index);
   ASSERT_EQ(window_id.id(), windows[tabbed_index]->window_id.id());
   ASSERT_EQ(1U, windows[tabbed_index]->tabs.size());
 
   SessionTab* tab = windows[tabbed_index]->tabs[0];
   helper_.AssertTabEquals(window_id, tab_id, 0, 0, 1, *tab);
   helper_.AssertNavigationEquals(nav1, tab->navigations[0]);
 
   ASSERT_EQ(0, windows[app_index]->selected_tab_index);
   ASSERT_EQ(window2_id.id(), windows[app_index]->window_id.id());
   ASSERT_EQ(1U, windows[app_index]->tabs.size());
-  ASSERT_TRUE(windows[app_index]->type == Browser::TYPE_POPUP);
+  ASSERT_TRUE(windows[app_index]->type == SessionWindow::TYPE_POPUP);
   ASSERT_EQ("TestApp", windows[app_index]->app_name);
 
   tab = windows[app_index]->tabs[0];
   helper_.AssertTabEquals(window2_id, tab2_id, 0, 0, 1, *tab);
   helper_.AssertNavigationEquals(nav2, tab->navigations[0]);
 }
 #endif  // defined (OS_CHROMEOS)
 
 // Tests pruning from the front.
 TEST_F(SessionServiceTest, PruneFromFront) {
@@ skipping 316 matching lines @@
 TEST_F(SessionServiceTest, RestoreActivation1) {
   SessionID window2_id;
   SessionID tab1_id;
   SessionID tab2_id;
   SerializedNavigationEntry nav1;
   SerializedNavigationEntry nav2;
 
   CreateAndWriteSessionWithTwoWindows(
       window2_id, tab1_id, tab2_id, &nav1, &nav2);
 
-  service()->ScheduleCommand(
-      service()->CreateSetActiveWindowCommand(window2_id));
-  service()->ScheduleCommand(
-      service()->CreateSetActiveWindowCommand(window_id));
+  service()->ScheduleCommand(CreateSetActiveWindowCommand(window2_id));
+  service()->ScheduleCommand(CreateSetActiveWindowCommand(window_id));
 
   ScopedVector<SessionWindow> windows;
   SessionID::id_type active_window_id = 0;
   ReadWindows(&(windows.get()), &active_window_id);
   EXPECT_EQ(window_id.id(), active_window_id);
 }
 
 // It's easier to have two separate tests with setup/teardown than to manualy
 // reset the state for the different flavors of the test.
 TEST_F(SessionServiceTest, RestoreActivation2) {
   SessionID window2_id;
   SessionID tab1_id;
   SessionID tab2_id;
   SerializedNavigationEntry nav1;
   SerializedNavigationEntry nav2;
 
   CreateAndWriteSessionWithTwoWindows(
       window2_id, tab1_id, tab2_id, &nav1, &nav2);
 
-  service()->ScheduleCommand(
-      service()->CreateSetActiveWindowCommand(window2_id));
-  service()->ScheduleCommand(
-      service()->CreateSetActiveWindowCommand(window_id));
-  service()->ScheduleCommand(
-      service()->CreateSetActiveWindowCommand(window2_id));
+  service()->ScheduleCommand(CreateSetActiveWindowCommand(window2_id));
+  service()->ScheduleCommand(CreateSetActiveWindowCommand(window_id));
+  service()->ScheduleCommand(CreateSetActiveWindowCommand(window2_id));
 
   ScopedVector<SessionWindow> windows;
   SessionID::id_type active_window_id = 0;
   ReadWindows(&(windows.get()), &active_window_id);
   EXPECT_EQ(window2_id.id(), active_window_id);
 }
 
 // Makes sure we don't track blacklisted URLs.
 TEST_F(SessionServiceTest, IgnoreBlacklistedUrls) {
   SessionID tab_id;
@@ skipping 67 matching lines @@
                             &cancelable_task_tracker);
   helper_.RunTaskOnBackendThread(
       FROM_HERE,
       base::Bind(&PostBackToThread,
                  base::Unretained(base::MessageLoop::current()),
                  base::Unretained(&run_loop)));
   delete helper_.ReleaseService();
   event.Signal();
   run_loop.Run();
 }