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