src/chrome/browser/sessions/session_service_test_helper.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 "chrome/browser/sessions/session_service_test_helper.h"
   6
   7 #include "base/memory/scoped_vector.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "chrome/browser/sessions/session_backend.h"
  10 #include "chrome/browser/sessions/session_service.h"
  11 #include "chrome/browser/sessions/session_types.h"
  12 #include "components/sessions/serialized_navigation_entry_test_helper.h"
  13 #include "components/sessions/session_id.h"
  14 #include "content/public/browser/browser_thread.h"
  15 #include "content/public/test/test_utils.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using base::Time;
  19
  20 SessionServiceTestHelper::SessionServiceTestHelper() {}
  21
  22 SessionServiceTestHelper::SessionServiceTestHelper(SessionService* service)
  23     : service_(service) {}
  24
  25 SessionServiceTestHelper::~SessionServiceTestHelper() {}
  26
  27 void SessionServiceTestHelper::PrepareTabInWindow(const SessionID& window_id,
  28                                                   const SessionID& tab_id,
  29                                                   int visual_index,
  30                                                   bool select) {
  31   service()->SetTabWindow(window_id, tab_id);
  32   service()->SetTabIndexInWindow(window_id, tab_id, visual_index);
  33   if (select)
  34     service()->SetSelectedTabInWindow(window_id, visual_index);
  35 }
  36
  37 void SessionServiceTestHelper::SetTabExtensionAppID(
  38     const SessionID& window_id,
  39     const SessionID& tab_id,
  40     const std::string& extension_app_id) {
  41   service()->SetTabExtensionAppID(window_id, tab_id, extension_app_id);
  42 }
  43
  44 void SessionServiceTestHelper::SetTabUserAgentOverride(
  45     const SessionID& window_id,
  46     const SessionID& tab_id,
  47     const std::string& user_agent_override) {
  48   service()->SetTabUserAgentOverride(window_id, tab_id, user_agent_override);
  49 }
  50
  51 void SessionServiceTestHelper::SetForceBrowserNotAliveWithNoWindows(
  52     bool force_browser_not_alive_with_no_windows) {
  53   service()->force_browser_not_alive_with_no_windows_ =
  54       force_browser_not_alive_with_no_windows;
  55 }
  56
  57 // Be sure and null out service to force closing the file.
  58 void SessionServiceTestHelper::ReadWindows(
  59     std::vector<SessionWindow*>* windows,
  60     SessionID::id_type* active_window_id) {
  61   Time last_time;
  62   ScopedVector<SessionCommand> read_commands;
  63   service()->GetBaseSessionServiceForTest()->ReadLastSessionCommandsForTest(
  64       &read_commands);
  65   RestoreSessionFromCommands(read_commands, windows, active_window_id);
  66   service()->RemoveUnusedRestoreWindows(windows);
  67 }
  68
  69 void SessionServiceTestHelper::AssertTabEquals(const SessionID& window_id,
  70                                                const SessionID& tab_id,
  71                                                int visual_index,
  72                                                int nav_index,
  73                                                size_t nav_count,
  74                                                const SessionTab& session_tab) {
  75   EXPECT_EQ(window_id.id(), session_tab.window_id.id());
  76   EXPECT_EQ(tab_id.id(), session_tab.tab_id.id());
  77   AssertTabEquals(visual_index, nav_index, nav_count, session_tab);
  78 }
  79
  80 void SessionServiceTestHelper::AssertTabEquals(
  81     int visual_index,
  82     int nav_index,
  83     size_t nav_count,
  84     const SessionTab& session_tab) {
  85   EXPECT_EQ(visual_index, session_tab.tab_visual_index);
  86   EXPECT_EQ(nav_index, session_tab.current_navigation_index);
  87   ASSERT_EQ(nav_count, session_tab.navigations.size());
  88 }
  89
  90 // TODO(sky): nuke this and change to call directly into
  91 // SerializedNavigationEntryTestHelper.
  92 void SessionServiceTestHelper::AssertNavigationEquals(
  93     const sessions::SerializedNavigationEntry& expected,
  94     const sessions::SerializedNavigationEntry& actual) {
  95   sessions::SerializedNavigationEntryTestHelper::ExpectNavigationEquals(
  96       expected, actual);
  97 }
  98
  99 void SessionServiceTestHelper::AssertSingleWindowWithSingleTab(
 100     const std::vector<SessionWindow*>& windows,
 101     size_t nav_count) {
 102   ASSERT_EQ(1U, windows.size());
 103   EXPECT_EQ(1U, windows[0]->tabs.size());
 104   EXPECT_EQ(nav_count, windows[0]->tabs[0]->navigations.size());
 105 }
 106
 107 void SessionServiceTestHelper::SetService(SessionService* service) {
 108   service_.reset(service);
 109   // Execute IO tasks posted by the SessionService.
 110   content::RunAllBlockingPoolTasksUntilIdle();
 111 }
 112
 113 void SessionServiceTestHelper::RunTaskOnBackendThread(
 114     const tracked_objects::Location& from_here,
 115     const base::Closure& task) {
 116   service_->GetBaseSessionServiceForTest()->RunTaskOnBackendThread(from_here,
 117                                                                    task);
 118 }