[Sync] Add support for enabling session sync remotely.

chrome/browser/sync/glue/data_type_manager_impl_unittest.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/glue/data_type_manager_impl.h"
 
 #include <set>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 149 matching lines @@
   MessageLoopForUI message_loop_;
   BrowserThread ui_thread_;
   DataTypeController::TypeMap controllers_;
   SyncBackendHostMock backend_;
   NotificationObserverMock observer_;
   NotificationRegistrar registrar_;
   std::set<syncable::ModelType> types_;
 };
 
 TEST_F(DataTypeManagerImplTest, NoControllers) {
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm.state());
   dtm.Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 }
 
 TEST_F(DataTypeManagerImplTest, ConfigureOne) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   SetStartStopExpectations(bookmark_dtc);
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(1);
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   types_.insert(syncable::BOOKMARKS);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm.state());
   dtm.Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 }
 
 TEST_F(DataTypeManagerImplTest, ConfigureOneStopWhileStarting) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   SetBusyStartStopExpectations(bookmark_dtc,
                                DataTypeController::MODEL_STARTING);
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(1);
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   types_.insert(syncable::BOOKMARKS);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm.state());
   dtm.Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 }
 
 TEST_F(DataTypeManagerImplTest, ConfigureOneStopWhileAssociating) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   SetBusyStartStopExpectations(bookmark_dtc, DataTypeController::ASSOCIATING);
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(1);
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   types_.insert(syncable::BOOKMARKS);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm.state());
   dtm.Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 }
 
 TEST_F(DataTypeManagerImplTest, OneWaitingForCrypto) {
   DataTypeControllerMock* password_dtc = MakePasswordDTC();
   EXPECT_CALL(*password_dtc, state()).Times(AtLeast(2)).
       WillRepeatedly(Return(DataTypeController::NOT_RUNNING));
   EXPECT_CALL(*password_dtc, Start(_)).
       WillOnce(InvokeCallback((DataTypeController::NEEDS_CRYPTO)));
 
   controllers_[syncable::PASSWORDS] = password_dtc;
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(1);
 
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   types_.insert(syncable::PASSWORDS);
   SetConfigureStartExpectation();
 
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::BLOCKED, dtm.state());
 
   Mock::VerifyAndClearExpectations(&backend_);
   Mock::VerifyAndClearExpectations(&observer_);
   Mock::VerifyAndClearExpectations(password_dtc);
 
@@ skipping 15 matching lines @@
 
 TEST_F(DataTypeManagerImplTest, ConfigureOneThenAnother) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   SetStartStopExpectations(bookmark_dtc);
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
   DataTypeControllerMock* preference_dtc = MakePreferenceDTC();
   SetStartStopExpectations(preference_dtc);
   controllers_[syncable::PREFERENCES] = preference_dtc;
 
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(2);
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   types_.insert(syncable::BOOKMARKS);
 
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm.state());
 
   types_.insert(syncable::PREFERENCES);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm.state());
 
   dtm.Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 }
 
 TEST_F(DataTypeManagerImplTest, ConfigureOneThenSwitch) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   SetStartStopExpectations(bookmark_dtc);
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
   DataTypeControllerMock* preference_dtc = MakePreferenceDTC();
   SetStartStopExpectations(preference_dtc);
   controllers_[syncable::PREFERENCES] = preference_dtc;
 
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(2);
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   types_.insert(syncable::BOOKMARKS);
 
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::CONFIGURED, dtm.state());
 
   types_.clear();
   types_.insert(syncable::PREFERENCES);
   SetConfigureStartExpectation();
@@ skipping 33 matching lines @@
     EXPECT_CALL(*bookmark_dtc, Stop()).Times(1);
     EXPECT_CALL(*bookmark_dtc, state()).
         WillRepeatedly(Return(DataTypeController::NOT_RUNNING));
   }
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
 
   DataTypeControllerMock* preference_dtc = MakePreferenceDTC();
   SetStartStopExpectations(preference_dtc);
   controllers_[syncable::PREFERENCES] = preference_dtc;
 
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _))
     .WillOnce(Invoke(DoConfigureDataTypes))
     .WillOnce(DoAll(Invoke(DoConfigureDataTypes),
      InvokeWithoutArgs(QuitMessageLoop)));
 
   types_.insert(syncable::BOOKMARKS);
 
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
@@ skipping 15 matching lines @@
 
 TEST_F(DataTypeManagerImplTest, OneFailingController) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   EXPECT_CALL(*bookmark_dtc, Start(_)).
       WillOnce(InvokeCallback((DataTypeController::ASSOCIATION_FAILED)));
   EXPECT_CALL(*bookmark_dtc, Stop()).Times(0);
   EXPECT_CALL(*bookmark_dtc, state()).
       WillRepeatedly(Return(DataTypeController::NOT_RUNNING));
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
 
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::ASSOCIATION_FAILED);
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(1);
 
   types_.insert(syncable::BOOKMARKS);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 }
 
 TEST_F(DataTypeManagerImplTest, StopWhileInFlight) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   SetStartStopExpectations(bookmark_dtc);
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
 
   DataTypeControllerMock* preference_dtc = MakePreferenceDTC();
   // Save the callback here so we can interrupt startup.
   DataTypeController::StartCallback* callback;
   EXPECT_CALL(*preference_dtc, Start(_)).
       WillOnce(SaveArg<0>(&callback));
   EXPECT_CALL(*preference_dtc, state()).
       WillRepeatedly(Return(DataTypeController::NOT_RUNNING));
   controllers_[syncable::PREFERENCES] = preference_dtc;
 
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::ABORTED);
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(1);
 
   types_.insert(syncable::BOOKMARKS);
   types_.insert(syncable::PREFERENCES);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   // Configure should stop in the CONFIGURING state because we are
   // waiting for the preferences callback to be invoked.
   EXPECT_EQ(DataTypeManager::CONFIGURING, dtm.state());
@@ skipping 11 matching lines @@
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
 
   DataTypeControllerMock* preference_dtc = MakePreferenceDTC();
   EXPECT_CALL(*preference_dtc, Start(_)).
       WillOnce(InvokeCallback((DataTypeController::ASSOCIATION_FAILED)));
   EXPECT_CALL(*preference_dtc, Stop()).Times(0);
   EXPECT_CALL(*preference_dtc, state()).
       WillRepeatedly(Return(DataTypeController::NOT_RUNNING));
   controllers_[syncable::PREFERENCES] = preference_dtc;
 
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::ASSOCIATION_FAILED);
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).Times(1);
 
   types_.insert(syncable::BOOKMARKS);
   types_.insert(syncable::PREFERENCES);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 }
 
 TEST_F(DataTypeManagerImplTest, ConfigureWhileDownloadPending) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   SetStartStopExpectations(bookmark_dtc);
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
 
   DataTypeControllerMock* preference_dtc = MakePreferenceDTC();
   SetStartStopExpectations(preference_dtc);
   controllers_[syncable::PREFERENCES] = preference_dtc;
 
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::OK);
   base::Callback<void(bool)> task;
   // Grab the task the first time this is called so we can configure
   // before it is finished.
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).
       WillOnce(SaveArg<3>(&task)).
       WillOnce(DoDefault());
 
   types_.insert(syncable::BOOKMARKS);
@@ skipping 13 matching lines @@
 
   dtm.Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 }
 
 TEST_F(DataTypeManagerImplTest, StopWhileDownloadPending) {
   DataTypeControllerMock* bookmark_dtc = MakeBookmarkDTC();
   SetNotUsedExpectations(bookmark_dtc);
   controllers_[syncable::BOOKMARKS] = bookmark_dtc;
 
-  DataTypeManagerImpl dtm(&backend_, controllers_);
+  DataTypeManagerImpl dtm(&backend_, &controllers_);
   SetConfigureStartExpectation();
   SetConfigureDoneExpectation(DataTypeManager::ABORTED);
   base::Callback<void(bool)> task;
   // Grab the task the first time this is called so we can stop
   // before it is finished.
   EXPECT_CALL(backend_, ConfigureDataTypes(_, _, _, _, _)).
       WillOnce(SaveArg<3>(&task));
 
   types_.insert(syncable::BOOKMARKS);
   dtm.Configure(types_, sync_api::CONFIGURE_REASON_RECONFIGURATION);
   // Configure should stop in the DOWNLOAD_PENDING state because we
   // are waiting for the download ready task to be run.
   EXPECT_EQ(DataTypeManager::DOWNLOAD_PENDING, dtm.state());
 
   dtm.Stop();
   EXPECT_EQ(DataTypeManager::STOPPED, dtm.state());
 
   // It should be perfectly safe to run this task even though the DTM
   // has been stopped.
   task.Run(true);
 }