src/chrome/browser/sync/sessions/session_data_type_controller_unittest.cc

   1 // Copyright 2014 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/callback.h"
   7 #include "base/memory/weak_ptr.h"
   8 #include "base/run_loop.h"
   9 #include "chrome/browser/chrome_notification_types.h"
  10 #include "chrome/browser/sync/glue/synced_window_delegate.h"
  11 #include "chrome/browser/sync/profile_sync_components_factory_mock.h"
  12 #include "chrome/browser/sync/sessions/session_data_type_controller.h"
  13 #include "chrome/browser/sync/sessions/synced_window_delegates_getter.h"
  14 #include "chrome/test/base/testing_profile.h"
  15 #include "components/sync_driver/local_device_info_provider_mock.h"
  16 #include "content/public/browser/notification_service.h"
  17 #include "content/public/test/test_browser_thread_bundle.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using sync_driver::LocalDeviceInfoProviderMock;
  21
  22 namespace browser_sync {
  23
  24 namespace {
  25
  26 class MockSyncedWindowDelegate : public SyncedWindowDelegate {
  27  public:
  28   explicit MockSyncedWindowDelegate(Profile* profile)
  29     : is_restore_in_progress_(false),
  30       profile_(profile) {}
  31   ~MockSyncedWindowDelegate() override {}
  32
  33   bool HasWindow() const override { return false; }
  34   SessionID::id_type GetSessionId() const override { return 0; }
  35   int GetTabCount() const override { return 0; }
  36   int GetActiveIndex() const override { return 0; }
  37   bool IsApp() const override { return false; }
  38   bool IsTypeTabbed() const override { return false; }
  39   bool IsTypePopup() const override { return false; }
  40   bool IsTabPinned(const SyncedTabDelegate* tab) const override {
  41     return false;
  42   }
  43   SyncedTabDelegate* GetTabAt(int index) const override { return NULL; }
  44   SessionID::id_type GetTabIdAt(int index) const override { return 0; }
  45
  46   bool IsSessionRestoreInProgress() const override {
  47     return is_restore_in_progress_;
  48   }
  49
  50   void SetSessionRestoreInProgress(bool is_restore_in_progress) {
  51     is_restore_in_progress_ = is_restore_in_progress;
  52
  53     if (!is_restore_in_progress_) {
  54       content::NotificationService::current()->Notify(
  55           chrome::NOTIFICATION_SESSION_RESTORE_COMPLETE,
  56           content::Source<Profile>(profile_),
  57           content::NotificationService::NoDetails());
  58     }
  59   }
  60
  61  private:
  62   bool is_restore_in_progress_;
  63   Profile* profile_;
  64 };
  65
  66 class MockSyncedWindowDelegatesGetter : public SyncedWindowDelegatesGetter {
  67  public:
  68   const std::set<SyncedWindowDelegate*> GetSyncedWindowDelegates() override {
  69     return delegates_;
  70   }
  71
  72   void Add(SyncedWindowDelegate* delegate) {
  73     delegates_.insert(delegate);
  74   }
  75
  76  private:
  77   std::set<SyncedWindowDelegate*> delegates_;
  78 };
  79
  80 class SessionDataTypeControllerTest
  81     : public testing::Test {
  82  public:
  83   SessionDataTypeControllerTest()
  84       : load_finished_(false),
  85         thread_bundle_(content::TestBrowserThreadBundle::DEFAULT),
  86         weak_ptr_factory_(this),
  87         last_type_(syncer::UNSPECIFIED) {}
  88   ~SessionDataTypeControllerTest() override {}
  89
  90   void SetUp() override {
  91     synced_window_delegate_.reset(new MockSyncedWindowDelegate(&profile_));
  92     synced_window_getter_.reset(new MockSyncedWindowDelegatesGetter());
  93     synced_window_getter_->Add(synced_window_delegate_.get());
  94
  95     local_device_.reset(new LocalDeviceInfoProviderMock(
  96         "cache_guid",
  97         "Wayne Gretzky's Hacking Box",
  98         "Chromium 10k",
  99         "Chrome 10k",
 100         sync_pb::SyncEnums_DeviceType_TYPE_LINUX,
 101         "device_id"));
 102
 103     controller_ = new SessionDataTypeController(
 104         &profile_sync_factory_,
 105         &profile_,
 106         synced_window_getter_.get(),
 107         local_device_.get());
 108
 109     load_finished_ = false;
 110     last_type_ = syncer::UNSPECIFIED;
 111     last_error_ = syncer::SyncError();
 112   }
 113
 114   void TearDown() override {
 115     controller_ = NULL;
 116     local_device_.reset();
 117     synced_window_getter_.reset();
 118     synced_window_delegate_.reset();
 119   }
 120
 121   void Start() {
 122     controller_->LoadModels(
 123       base::Bind(&SessionDataTypeControllerTest::OnLoadFinished,
 124                  weak_ptr_factory_.GetWeakPtr()));
 125   }
 126
 127   void OnLoadFinished(syncer::ModelType type, syncer::SyncError error) {
 128     load_finished_ = true;
 129     last_type_ = type;
 130     last_error_ = error;
 131   }
 132
 133   testing::AssertionResult LoadResult() {
 134     if (!load_finished_) {
 135       return testing::AssertionFailure() <<
 136           "OnLoadFinished wasn't called";
 137     }
 138
 139     if (last_error_.IsSet()) {
 140       return testing::AssertionFailure() <<
 141           "OnLoadFinished was called with a SyncError: " <<
 142           last_error_.ToString();
 143     }
 144
 145     if (last_type_ != syncer::SESSIONS) {
 146       return testing::AssertionFailure() <<
 147           "OnLoadFinished was called with a wrong sync type: " <<
 148           last_type_;
 149     }
 150
 151     return testing::AssertionSuccess();
 152   }
 153
 154  protected:
 155   scoped_refptr<SessionDataTypeController> controller_;
 156   scoped_ptr<MockSyncedWindowDelegatesGetter> synced_window_getter_;
 157   scoped_ptr<LocalDeviceInfoProviderMock> local_device_;
 158   scoped_ptr<MockSyncedWindowDelegate> synced_window_delegate_;
 159   bool load_finished_;
 160
 161  private:
 162   content::TestBrowserThreadBundle thread_bundle_;
 163   ProfileSyncComponentsFactoryMock profile_sync_factory_;
 164   TestingProfile profile_;
 165   base::WeakPtrFactory<SessionDataTypeControllerTest> weak_ptr_factory_;
 166   syncer::ModelType last_type_;
 167   syncer::SyncError last_error_;
 168 };
 169
 170 TEST_F(SessionDataTypeControllerTest, StartModels) {
 171   Start();
 172   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
 173             controller_->state());
 174   EXPECT_TRUE(LoadResult());
 175 }
 176
 177 TEST_F(SessionDataTypeControllerTest, StartModelsDelayedByLocalDevice) {
 178   local_device_->SetInitialized(false);
 179   Start();
 180   EXPECT_FALSE(load_finished_);
 181   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
 182             controller_->state());
 183
 184   local_device_->SetInitialized(true);
 185   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
 186             controller_->state());
 187   EXPECT_TRUE(LoadResult());
 188 }
 189
 190 TEST_F(SessionDataTypeControllerTest, StartModelsDelayedByRestoreInProgress) {
 191   synced_window_delegate_->SetSessionRestoreInProgress(true);
 192   Start();
 193   EXPECT_FALSE(load_finished_);
 194   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
 195             controller_->state());
 196
 197   synced_window_delegate_->SetSessionRestoreInProgress(false);
 198   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
 199             controller_->state());
 200   EXPECT_TRUE(LoadResult());
 201 }
 202
 203 TEST_F(SessionDataTypeControllerTest,
 204        StartModelsDelayedByLocalDeviceThenRestoreInProgress) {
 205   local_device_->SetInitialized(false);
 206   synced_window_delegate_->SetSessionRestoreInProgress(true);
 207   Start();
 208   EXPECT_FALSE(load_finished_);
 209   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
 210             controller_->state());
 211
 212   local_device_->SetInitialized(true);
 213   EXPECT_FALSE(load_finished_);
 214   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
 215             controller_->state());
 216
 217   synced_window_delegate_->SetSessionRestoreInProgress(false);
 218   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
 219             controller_->state());
 220   EXPECT_TRUE(LoadResult());
 221 }
 222
 223 TEST_F(SessionDataTypeControllerTest,
 224        StartModelsDelayedByRestoreInProgressThenLocalDevice) {
 225   local_device_->SetInitialized(false);
 226   synced_window_delegate_->SetSessionRestoreInProgress(true);
 227   Start();
 228   EXPECT_FALSE(load_finished_);
 229   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
 230             controller_->state());
 231
 232   synced_window_delegate_->SetSessionRestoreInProgress(false);
 233   EXPECT_FALSE(load_finished_);
 234   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
 235             controller_->state());
 236
 237   local_device_->SetInitialized(true);
 238   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
 239             controller_->state());
 240   EXPECT_TRUE(LoadResult());
 241 }
 242
 243 }  // namespace
 244
 245 }  // namespace browser_sync