1 // Copyright (c) 2011 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/sync/test_profile_sync_service.h"
6
7 #include "chrome/browser/sync/abstract_profile_sync_service_test.h"
8 #include "chrome/browser/sync/engine/syncapi.h"
9 #include "chrome/browser/sync/glue/data_type_controller.h"
10 #include "chrome/browser/sync/glue/sync_backend_host.h"
11 #include "chrome/browser/sync/profile_sync_factory.h"
12 #include "chrome/browser/sync/sessions/session_state.h"
13 #include "chrome/browser/sync/syncable/directory_manager.h"
14 #include "chrome/browser/sync/syncable/syncable.h"
15 #include "chrome/test/sync/test_http_bridge_factory.h"
16
17 using browser_sync::ModelSafeRoutingInfo;
18 using browser_sync::sessions::ErrorCounters;
19 using browser_sync::sessions::SyncSourceInfo;
20 using browser_sync::sessions::SyncerStatus;
21 using browser_sync::sessions::SyncSessionSnapshot;
22 using syncable::DirectoryManager;
23 using syncable::ModelType;
24 using syncable::ScopedDirLookup;
25 using sync_api::UserShare;
26
27 namespace browser_sync {
28
29 using ::testing::_;
SyncBackendHostForProfileSyncTest(Profile * profile,bool set_initial_sync_ended_on_init,bool synchronous_init)30 SyncBackendHostForProfileSyncTest::SyncBackendHostForProfileSyncTest(
31 Profile* profile,
32 bool set_initial_sync_ended_on_init,
33 bool synchronous_init)
34 : browser_sync::SyncBackendHost(profile),
35 synchronous_init_(synchronous_init) {
36 ON_CALL(*this, RequestNudge(_)).WillByDefault(
37 testing::Invoke(this,
38 &SyncBackendHostForProfileSyncTest::
39 SimulateSyncCycleCompletedInitialSyncEnded));
40 EXPECT_CALL(*this, RequestNudge(_)).Times(testing::AnyNumber());
41 }
42
~SyncBackendHostForProfileSyncTest()43 SyncBackendHostForProfileSyncTest::~SyncBackendHostForProfileSyncTest() {}
44
ConfigureDataTypes(const DataTypeController::TypeMap & data_type_controllers,const syncable::ModelTypeSet & types,CancelableTask * ready_task)45 void SyncBackendHostForProfileSyncTest::ConfigureDataTypes(
46 const DataTypeController::TypeMap& data_type_controllers,
47 const syncable::ModelTypeSet& types,
48 CancelableTask* ready_task) {
49 SetAutofillMigrationState(syncable::MIGRATED);
50 SyncBackendHost::ConfigureDataTypes(
51 data_type_controllers, types, ready_task);
52 }
53
54 void SyncBackendHostForProfileSyncTest::
SimulateSyncCycleCompletedInitialSyncEnded(const tracked_objects::Location & location)55 SimulateSyncCycleCompletedInitialSyncEnded(
56 const tracked_objects::Location& location) {
57 syncable::ModelTypeBitSet sync_ended;
58 ModelSafeRoutingInfo enabled_types;
59 GetModelSafeRoutingInfo(&enabled_types);
60 std::string download_progress_markers[syncable::MODEL_TYPE_COUNT];
61 for (ModelSafeRoutingInfo::const_iterator i = enabled_types.begin();
62 i != enabled_types.end(); ++i) {
63 sync_ended.set(i->first);
64 }
65 core_->HandleSyncCycleCompletedOnFrontendLoop(new SyncSessionSnapshot(
66 SyncerStatus(), ErrorCounters(), 0, false,
67 sync_ended, download_progress_markers, false, false, 0, 0, false,
68 SyncSourceInfo()));
69 }
70
71 sync_api::HttpPostProviderFactory*
MakeHttpBridgeFactory(net::URLRequestContextGetter * getter)72 SyncBackendHostForProfileSyncTest::MakeHttpBridgeFactory(
73 net::URLRequestContextGetter* getter) {
74 return new browser_sync::TestHttpBridgeFactory;
75 }
76
InitCore(const Core::DoInitializeOptions & options)77 void SyncBackendHostForProfileSyncTest::InitCore(
78 const Core::DoInitializeOptions& options) {
79 std::wstring user = L"testuser@gmail.com";
80 core_loop()->PostTask(
81 FROM_HERE,
82 NewRunnableMethod(core_.get(),
83 &SyncBackendHost::Core::DoInitializeForTest,
84 user,
85 options.http_bridge_factory,
86 options.delete_sync_data_folder));
87
88 // TODO(akalin): Figure out a better way to do this.
89 if (synchronous_init_) {
90 // The SyncBackend posts a task to the current loop when
91 // initialization completes.
92 MessageLoop::current()->Run();
93 }
94 }
95
GetJsBackend()96 JsBackend* SyncBackendHostForProfileSyncTest::GetJsBackend() {
97 // Return a non-NULL result only when the overridden function does.
98 if (SyncBackendHost::GetJsBackend()) {
99 return this;
100 } else {
101 NOTREACHED();
102 return NULL;
103 }
104 }
105
SetParentJsEventRouter(JsEventRouter * router)106 void SyncBackendHostForProfileSyncTest::SetParentJsEventRouter(
107 JsEventRouter* router) {
108 core_->SetParentJsEventRouter(router);
109 }
110
RemoveParentJsEventRouter()111 void SyncBackendHostForProfileSyncTest::RemoveParentJsEventRouter() {
112 core_->RemoveParentJsEventRouter();
113 }
114
115 const JsEventRouter*
GetParentJsEventRouter() const116 SyncBackendHostForProfileSyncTest::GetParentJsEventRouter() const {
117 return core_->GetParentJsEventRouter();
118 }
119
ProcessMessage(const std::string & name,const JsArgList & args,const JsEventHandler * sender)120 void SyncBackendHostForProfileSyncTest::ProcessMessage(
121 const std::string& name, const JsArgList& args,
122 const JsEventHandler* sender) {
123 if (name.find("delay") != name.npos) {
124 core_->RouteJsEvent(name, args, sender);
125 } else {
126 core_->RouteJsEventOnFrontendLoop(name, args, sender);
127 }
128 }
129
StartConfiguration(Callback0::Type *)130 void SyncBackendHostForProfileSyncTest::StartConfiguration(Callback0::Type*) {
131 SyncBackendHost::FinishConfigureDataTypesOnFrontendLoop();
132 }
133
134 void SyncBackendHostForProfileSyncTest::
SetDefaultExpectationsForWorkerCreation(ProfileMock * profile)135 SetDefaultExpectationsForWorkerCreation(ProfileMock* profile) {
136 EXPECT_CALL(*profile, GetPasswordStore(testing::_)).
137 WillOnce(testing::Return((PasswordStore*)NULL));
138 }
139
SetHistoryServiceExpectations(ProfileMock * profile)140 void SyncBackendHostForProfileSyncTest::SetHistoryServiceExpectations(
141 ProfileMock* profile) {
142 EXPECT_CALL(*profile, GetHistoryService(testing::_)).
143 WillOnce(testing::Return((HistoryService*)NULL));
144 }
145
146 } // namespace browser_sync
147
id_factory()148 browser_sync::TestIdFactory* TestProfileSyncService::id_factory() {
149 return &id_factory_;
150 }
151
152 browser_sync::SyncBackendHostForProfileSyncTest*
GetBackendForTest()153 TestProfileSyncService::GetBackendForTest() {
154 return static_cast<browser_sync::SyncBackendHostForProfileSyncTest*>(
155 ProfileSyncService::GetBackendForTest());
156 }
157
TestProfileSyncService(ProfileSyncFactory * factory,Profile * profile,const std::string & test_user,bool synchronous_backend_initialization,Task * initial_condition_setup_task)158 TestProfileSyncService::TestProfileSyncService(
159 ProfileSyncFactory* factory,
160 Profile* profile,
161 const std::string& test_user,
162 bool synchronous_backend_initialization,
163 Task* initial_condition_setup_task)
164 : ProfileSyncService(factory, profile, test_user),
165 synchronous_backend_initialization_(
166 synchronous_backend_initialization),
167 synchronous_sync_configuration_(false),
168 initial_condition_setup_task_(initial_condition_setup_task),
169 set_initial_sync_ended_on_init_(true) {
170 RegisterPreferences();
171 SetSyncSetupCompleted();
172 }
173
~TestProfileSyncService()174 TestProfileSyncService::~TestProfileSyncService() {}
175
SetInitialSyncEndedForEnabledTypes()176 void TestProfileSyncService::SetInitialSyncEndedForEnabledTypes() {
177 UserShare* user_share = GetUserShare();
178 DirectoryManager* dir_manager = user_share->dir_manager.get();
179
180 ScopedDirLookup dir(dir_manager, user_share->name);
181 if (!dir.good())
182 FAIL();
183
184 ModelSafeRoutingInfo enabled_types;
185 backend_->GetModelSafeRoutingInfo(&enabled_types);
186 for (ModelSafeRoutingInfo::const_iterator i = enabled_types.begin();
187 i != enabled_types.end(); ++i) {
188 dir->set_initial_sync_ended_for_type(i->first, true);
189 }
190 }
191
OnBackendInitialized()192 void TestProfileSyncService::OnBackendInitialized() {
193 // Set this so below code can access GetUserShare().
194 backend_initialized_ = true;
195
196 // Set up any nodes the test wants around before model association.
197 if (initial_condition_setup_task_) {
198 initial_condition_setup_task_->Run();
199 initial_condition_setup_task_ = NULL;
200 }
201
202 // Pretend we downloaded initial updates and set initial sync ended bits
203 // if we were asked to.
204 bool send_passphrase_required = false;
205 if (set_initial_sync_ended_on_init_) {
206 UserShare* user_share = GetUserShare();
207 DirectoryManager* dir_manager = user_share->dir_manager.get();
208
209 ScopedDirLookup dir(dir_manager, user_share->name);
210 if (!dir.good())
211 FAIL();
212
213 if (!dir->initial_sync_ended_for_type(syncable::NIGORI)) {
214 ProfileSyncServiceTestHelper::CreateRoot(
215 syncable::NIGORI, GetUserShare(),
216 id_factory());
217
218 // A side effect of adding the NIGORI mode (normally done by the syncer)
219 // is a decryption attempt, which will fail the first time.
220 send_passphrase_required = true;
221 }
222
223 SetInitialSyncEndedForEnabledTypes();
224 }
225
226 ProfileSyncService::OnBackendInitialized();
227 if (send_passphrase_required)
228 OnPassphraseRequired(true);
229
230 // TODO(akalin): Figure out a better way to do this.
231 if (synchronous_backend_initialization_) {
232 MessageLoop::current()->Quit();
233 }
234 }
235
Observe(NotificationType type,const NotificationSource & source,const NotificationDetails & details)236 void TestProfileSyncService::Observe(NotificationType type,
237 const NotificationSource& source,
238 const NotificationDetails& details) {
239 ProfileSyncService::Observe(type, source, details);
240 if (type == NotificationType::SYNC_CONFIGURE_DONE &&
241 !synchronous_sync_configuration_) {
242 MessageLoop::current()->Quit();
243 }
244 }
245
dont_set_initial_sync_ended_on_init()246 void TestProfileSyncService::dont_set_initial_sync_ended_on_init() {
247 set_initial_sync_ended_on_init_ = false;
248 }
set_synchronous_sync_configuration()249 void TestProfileSyncService::set_synchronous_sync_configuration() {
250 synchronous_sync_configuration_ = true;
251 }
252
CreateBackend()253 void TestProfileSyncService::CreateBackend() {
254 backend_.reset(new browser_sync::SyncBackendHostForProfileSyncTest(
255 profile(),
256 set_initial_sync_ended_on_init_,
257 synchronous_backend_initialization_));
258 }
259
GetLsidForAuthBootstraping()260 std::string TestProfileSyncService::GetLsidForAuthBootstraping() {
261 return "foo";
262 }
263