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 "sync/internal_api/public/test/fake_sync_manager.h" 6 7#include <cstddef> 8 9#include "base/bind.h" 10#include "base/bind_helpers.h" 11#include "base/location.h" 12#include "base/logging.h" 13#include "base/run_loop.h" 14#include "base/sequenced_task_runner.h" 15#include "base/single_thread_task_runner.h" 16#include "base/thread_task_runner_handle.h" 17#include "sync/internal_api/public/http_post_provider_factory.h" 18#include "sync/internal_api/public/internal_components_factory.h" 19#include "sync/internal_api/public/util/weak_handle.h" 20#include "sync/syncable/directory.h" 21#include "sync/test/fake_sync_encryption_handler.h" 22 23class GURL; 24 25namespace syncer { 26 27FakeSyncManager::FakeSyncManager(ModelTypeSet initial_sync_ended_types, 28 ModelTypeSet progress_marker_types, 29 ModelTypeSet configure_fail_types) : 30 initial_sync_ended_types_(initial_sync_ended_types), 31 progress_marker_types_(progress_marker_types), 32 configure_fail_types_(configure_fail_types), 33 last_configure_reason_(CONFIGURE_REASON_UNKNOWN) { 34 fake_encryption_handler_.reset(new FakeSyncEncryptionHandler()); 35} 36 37FakeSyncManager::~FakeSyncManager() {} 38 39ModelTypeSet FakeSyncManager::GetAndResetCleanedTypes() { 40 ModelTypeSet cleaned_types = cleaned_types_; 41 cleaned_types_.Clear(); 42 return cleaned_types; 43} 44 45ModelTypeSet FakeSyncManager::GetAndResetDownloadedTypes() { 46 ModelTypeSet downloaded_types = downloaded_types_; 47 downloaded_types_.Clear(); 48 return downloaded_types; 49} 50 51ModelTypeSet FakeSyncManager::GetAndResetEnabledTypes() { 52 ModelTypeSet enabled_types = enabled_types_; 53 enabled_types_.Clear(); 54 return enabled_types; 55} 56 57ConfigureReason FakeSyncManager::GetAndResetConfigureReason() { 58 ConfigureReason reason = last_configure_reason_; 59 last_configure_reason_ = CONFIGURE_REASON_UNKNOWN; 60 return reason; 61} 62 63void FakeSyncManager::WaitForSyncThread() { 64 // Post a task to |sync_task_runner_| and block until it runs. 65 base::RunLoop run_loop; 66 if (!sync_task_runner_->PostTaskAndReply( 67 FROM_HERE, 68 base::Bind(&base::DoNothing), 69 run_loop.QuitClosure())) { 70 NOTREACHED(); 71 } 72 run_loop.Run(); 73} 74 75void FakeSyncManager::Init(InitArgs* args) { 76 sync_task_runner_ = base::ThreadTaskRunnerHandle::Get(); 77 PurgePartiallySyncedTypes(); 78 79 test_user_share_.SetUp(); 80 UserShare* share = test_user_share_.user_share(); 81 for (ModelTypeSet::Iterator it = initial_sync_ended_types_.First(); 82 it.Good(); it.Inc()) { 83 TestUserShare::CreateRoot(it.Get(), share); 84 } 85 86 FOR_EACH_OBSERVER(SyncManager::Observer, observers_, 87 OnInitializationComplete( 88 WeakHandle<JsBackend>(), 89 WeakHandle<DataTypeDebugInfoListener>(), 90 true, initial_sync_ended_types_)); 91} 92 93ModelTypeSet FakeSyncManager::InitialSyncEndedTypes() { 94 return initial_sync_ended_types_; 95} 96 97ModelTypeSet FakeSyncManager::GetTypesWithEmptyProgressMarkerToken( 98 ModelTypeSet types) { 99 ModelTypeSet empty_types = types; 100 empty_types.RemoveAll(progress_marker_types_); 101 return empty_types; 102} 103 104bool FakeSyncManager::PurgePartiallySyncedTypes() { 105 ModelTypeSet partial_types; 106 for (ModelTypeSet::Iterator i = progress_marker_types_.First(); 107 i.Good(); i.Inc()) { 108 if (!initial_sync_ended_types_.Has(i.Get())) 109 partial_types.Put(i.Get()); 110 } 111 progress_marker_types_.RemoveAll(partial_types); 112 cleaned_types_.PutAll(partial_types); 113 return true; 114} 115 116void FakeSyncManager::UpdateCredentials(const SyncCredentials& credentials) { 117 NOTIMPLEMENTED(); 118} 119 120void FakeSyncManager::StartSyncingNormally( 121 const ModelSafeRoutingInfo& routing_info) { 122 // Do nothing. 123} 124 125void FakeSyncManager::ConfigureSyncer( 126 ConfigureReason reason, 127 ModelTypeSet to_download, 128 ModelTypeSet to_purge, 129 ModelTypeSet to_journal, 130 ModelTypeSet to_unapply, 131 const ModelSafeRoutingInfo& new_routing_info, 132 const base::Closure& ready_task, 133 const base::Closure& retry_task) { 134 last_configure_reason_ = reason; 135 enabled_types_ = GetRoutingInfoTypes(new_routing_info); 136 ModelTypeSet success_types = to_download; 137 success_types.RemoveAll(configure_fail_types_); 138 139 DVLOG(1) << "Faking configuration. Downloading: " 140 << ModelTypeSetToString(success_types) << ". Cleaning: " 141 << ModelTypeSetToString(to_purge); 142 143 // Update our fake directory by clearing and fake-downloading as necessary. 144 UserShare* share = GetUserShare(); 145 share->directory->PurgeEntriesWithTypeIn(to_purge, 146 to_journal, 147 to_unapply); 148 for (ModelTypeSet::Iterator it = success_types.First(); it.Good(); it.Inc()) { 149 // We must be careful to not create the same root node twice. 150 if (!initial_sync_ended_types_.Has(it.Get())) { 151 TestUserShare::CreateRoot(it.Get(), share); 152 } 153 } 154 155 // Simulate cleaning up disabled types. 156 // TODO(sync): consider only cleaning those types that were recently disabled, 157 // if this isn't the first cleanup, which more accurately reflects the 158 // behavior of the real cleanup logic. 159 initial_sync_ended_types_.RemoveAll(to_purge); 160 progress_marker_types_.RemoveAll(to_purge); 161 cleaned_types_.PutAll(to_purge); 162 163 // Now simulate the actual configuration for those types that successfully 164 // download + apply. 165 progress_marker_types_.PutAll(success_types); 166 initial_sync_ended_types_.PutAll(success_types); 167 downloaded_types_.PutAll(success_types); 168 169 ready_task.Run(); 170} 171 172void FakeSyncManager::AddObserver(Observer* observer) { 173 observers_.AddObserver(observer); 174} 175 176void FakeSyncManager::RemoveObserver(Observer* observer) { 177 observers_.RemoveObserver(observer); 178} 179 180SyncStatus FakeSyncManager::GetDetailedStatus() const { 181 NOTIMPLEMENTED(); 182 return SyncStatus(); 183} 184 185void FakeSyncManager::SaveChanges() { 186 // Do nothing. 187} 188 189void FakeSyncManager::ShutdownOnSyncThread(ShutdownReason reason) { 190 DCHECK(sync_task_runner_->RunsTasksOnCurrentThread()); 191 test_user_share_.TearDown(); 192} 193 194UserShare* FakeSyncManager::GetUserShare() { 195 return test_user_share_.user_share(); 196} 197 198syncer::SyncContextProxy* FakeSyncManager::GetSyncContextProxy() { 199 return &null_sync_context_proxy_; 200} 201 202const std::string FakeSyncManager::cache_guid() { 203 return test_user_share_.user_share()->directory->cache_guid(); 204} 205 206bool FakeSyncManager::ReceivedExperiment(Experiments* experiments) { 207 return false; 208} 209 210bool FakeSyncManager::HasUnsyncedItems() { 211 NOTIMPLEMENTED(); 212 return false; 213} 214 215SyncEncryptionHandler* FakeSyncManager::GetEncryptionHandler() { 216 return fake_encryption_handler_.get(); 217} 218 219ScopedVector<syncer::ProtocolEvent> 220FakeSyncManager::GetBufferedProtocolEvents() { 221 return ScopedVector<syncer::ProtocolEvent>(); 222} 223 224scoped_ptr<base::ListValue> FakeSyncManager::GetAllNodesForType( 225 syncer::ModelType type) { 226 return scoped_ptr<base::ListValue>(new base::ListValue()); 227} 228 229void FakeSyncManager::RefreshTypes(ModelTypeSet types) { 230 last_refresh_request_types_ = types; 231} 232 233void FakeSyncManager::RegisterDirectoryTypeDebugInfoObserver( 234 syncer::TypeDebugInfoObserver* observer) {} 235 236void FakeSyncManager::UnregisterDirectoryTypeDebugInfoObserver( 237 syncer::TypeDebugInfoObserver* observer) {} 238 239bool FakeSyncManager::HasDirectoryTypeDebugInfoObserver( 240 syncer::TypeDebugInfoObserver* observer) { 241 return false; 242} 243 244void FakeSyncManager::RequestEmitDebugInfo() {} 245 246void FakeSyncManager::OnIncomingInvalidation( 247 syncer::ModelType type, 248 scoped_ptr<InvalidationInterface> invalidation) { 249 // Do nothing. 250} 251 252ModelTypeSet FakeSyncManager::GetLastRefreshRequestTypes() { 253 return last_refresh_request_types_; 254} 255 256void FakeSyncManager::SetInvalidatorEnabled(bool invalidator_enabled) { 257 // Do nothing. 258} 259 260} // namespace syncer 261