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   fake_encryption_handler_.reset(new FakeSyncEncryptionHandler());
  35 }
  36
  37 FakeSyncManager::~FakeSyncManager() {}
  38
  39 ModelTypeSet FakeSyncManager::GetAndResetCleanedTypes() {
  40   ModelTypeSet cleaned_types = cleaned_types_;
  41   cleaned_types_.Clear();
  42   return cleaned_types;
  43 }
  44
  45 ModelTypeSet FakeSyncManager::GetAndResetDownloadedTypes() {
  46   ModelTypeSet downloaded_types = downloaded_types_;
  47   downloaded_types_.Clear();
  48   return downloaded_types;
  49 }
  50
  51 ModelTypeSet FakeSyncManager::GetAndResetEnabledTypes() {
  52   ModelTypeSet enabled_types = enabled_types_;
  53   enabled_types_.Clear();
  54   return enabled_types;
  55 }
  56
  57 ConfigureReason FakeSyncManager::GetAndResetConfigureReason() {
  58   ConfigureReason reason = last_configure_reason_;
  59   last_configure_reason_ = CONFIGURE_REASON_UNKNOWN;
  60   return reason;
  61 }
  62
  63 void 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
  75 void 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
  93 ModelTypeSet FakeSyncManager::InitialSyncEndedTypes() {
  94   return initial_sync_ended_types_;
  95 }
  96
  97 ModelTypeSet FakeSyncManager::GetTypesWithEmptyProgressMarkerToken(
  98     ModelTypeSet types) {
  99   ModelTypeSet empty_types = types;
 100   empty_types.RemoveAll(progress_marker_types_);
 101   return empty_types;
 102 }
 103
 104 bool 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
 116 void FakeSyncManager::UpdateCredentials(const SyncCredentials& credentials) {
 117   NOTIMPLEMENTED();
 118 }
 119
 120 void FakeSyncManager::StartSyncingNormally(
 121       const ModelSafeRoutingInfo& routing_info) {
 122   // Do nothing.
 123 }
 124
 125 void 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
 172 void FakeSyncManager::AddObserver(Observer* observer) {
 173   observers_.AddObserver(observer);
 174 }
 175
 176 void FakeSyncManager::RemoveObserver(Observer* observer) {
 177   observers_.RemoveObserver(observer);
 178 }
 179
 180 SyncStatus FakeSyncManager::GetDetailedStatus() const {
 181   NOTIMPLEMENTED();
 182   return SyncStatus();
 183 }
 184
 185 void FakeSyncManager::SaveChanges() {
 186   // Do nothing.
 187 }
 188
 189 void FakeSyncManager::ShutdownOnSyncThread(ShutdownReason reason) {
 190   DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
 191   test_user_share_.TearDown();
 192 }
 193
 194 UserShare* FakeSyncManager::GetUserShare() {
 195   return test_user_share_.user_share();
 196 }
 197
 198 syncer::SyncContextProxy* FakeSyncManager::GetSyncContextProxy() {
 199   return &null_sync_context_proxy_;
 200 }
 201
 202 const std::string FakeSyncManager::cache_guid() {
 203   return test_user_share_.user_share()->directory->cache_guid();
 204 }
 205
 206 bool FakeSyncManager::ReceivedExperiment(Experiments* experiments) {
 207   return false;
 208 }
 209
 210 bool FakeSyncManager::HasUnsyncedItems() {
 211   NOTIMPLEMENTED();
 212   return false;
 213 }
 214
 215 SyncEncryptionHandler* FakeSyncManager::GetEncryptionHandler() {
 216   return fake_encryption_handler_.get();
 217 }
 218
 219 ScopedVector<syncer::ProtocolEvent>
 220 FakeSyncManager::GetBufferedProtocolEvents() {
 221   return ScopedVector<syncer::ProtocolEvent>();
 222 }
 223
 224 scoped_ptr<base::ListValue> FakeSyncManager::GetAllNodesForType(
 225     syncer::ModelType type) {
 226   return scoped_ptr<base::ListValue>(new base::ListValue());
 227 }
 228
 229 void FakeSyncManager::RefreshTypes(ModelTypeSet types) {
 230   last_refresh_request_types_ = types;
 231 }
 232
 233 void FakeSyncManager::RegisterDirectoryTypeDebugInfoObserver(
 234     syncer::TypeDebugInfoObserver* observer) {}
 235
 236 void FakeSyncManager::UnregisterDirectoryTypeDebugInfoObserver(
 237     syncer::TypeDebugInfoObserver* observer) {}
 238
 239 bool FakeSyncManager::HasDirectoryTypeDebugInfoObserver(
 240     syncer::TypeDebugInfoObserver* observer) {
 241   return false;
 242 }
 243
 244 void FakeSyncManager::RequestEmitDebugInfo() {}
 245
 246 void FakeSyncManager::OnIncomingInvalidation(
 247     syncer::ModelType type,
 248     scoped_ptr<InvalidationInterface> invalidation) {
 249   // Do nothing.
 250 }
 251
 252 ModelTypeSet FakeSyncManager::GetLastRefreshRequestTypes() {
 253   return last_refresh_request_types_;
 254 }
 255
 256 void FakeSyncManager::SetInvalidatorEnabled(bool invalidator_enabled) {
 257   // Do nothing.
 258 }
 259
 260 }  // namespace syncer