sync/internal_api/sync_rollback_manager_base.cc

   1 // Copyright 2014 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/sync_rollback_manager_base.h"
   6
   7 #include "sync/internal_api/public/base/model_type.h"
   8 #include "sync/internal_api/public/read_node.h"
   9 #include "sync/internal_api/public/read_transaction.h"
  10 #include "sync/internal_api/public/write_transaction.h"
  11 #include "sync/syncable/directory_backing_store.h"
  12 #include "sync/syncable/mutable_entry.h"
  13
  14 namespace {
  15
  16 // Permanent bookmark folders as defined in bookmark_model_associator.cc.
  17 // No mobile bookmarks because they only exists with sync enabled.
  18 const char kBookmarkBarTag[] = "bookmark_bar";
  19 const char kOtherBookmarksTag[] = "other_bookmarks";
  20
  21 class DummyEntryptionHandler : public syncer::SyncEncryptionHandler {
  22   virtual void AddObserver(Observer* observer) OVERRIDE {}
  23   virtual void RemoveObserver(Observer* observer) OVERRIDE {}
  24   virtual void Init() OVERRIDE {}
  25   virtual void SetEncryptionPassphrase(const std::string& passphrase,
  26                                        bool is_explicit) OVERRIDE {}
  27   virtual void SetDecryptionPassphrase(const std::string& passphrase)
  28       OVERRIDE {}
  29   virtual void EnableEncryptEverything() OVERRIDE {}
  30   virtual bool EncryptEverythingEnabled() const OVERRIDE {
  31     return false;
  32   }
  33   virtual syncer::PassphraseType GetPassphraseType() const OVERRIDE {
  34     return syncer::KEYSTORE_PASSPHRASE;
  35   }
  36 };
  37
  38 }  // anonymous namespace
  39
  40 namespace syncer {
  41
  42 SyncRollbackManagerBase::SyncRollbackManagerBase()
  43     : report_unrecoverable_error_function_(NULL),
  44       weak_ptr_factory_(this),
  45       dummy_handler_(new DummyEntryptionHandler),
  46       initialized_(false) {
  47 }
  48
  49 SyncRollbackManagerBase::~SyncRollbackManagerBase() {
  50 }
  51
  52 bool SyncRollbackManagerBase::InitInternal(
  53     const base::FilePath& database_location,
  54     InternalComponentsFactory* internal_components_factory,
  55     InternalComponentsFactory::StorageOption storage,
  56     scoped_ptr<UnrecoverableErrorHandler> unrecoverable_error_handler,
  57     ReportUnrecoverableErrorFunction report_unrecoverable_error_function) {
  58   unrecoverable_error_handler_ = unrecoverable_error_handler.Pass();
  59   report_unrecoverable_error_function_ = report_unrecoverable_error_function;
  60
  61   if (!InitBackupDB(database_location, internal_components_factory, storage)) {
  62     NotifyInitializationFailure();
  63     return false;
  64   }
  65
  66   initialized_ = true;
  67   NotifyInitializationSuccess();
  68   return true;
  69 }
  70
  71 ModelTypeSet SyncRollbackManagerBase::InitialSyncEndedTypes() {
  72   return share_.directory->InitialSyncEndedTypes();
  73 }
  74
  75 ModelTypeSet SyncRollbackManagerBase::GetTypesWithEmptyProgressMarkerToken(
  76       ModelTypeSet types) {
  77   ModelTypeSet inited_types = share_.directory->InitialSyncEndedTypes();
  78   types.RemoveAll(inited_types);
  79   return types;
  80 }
  81
  82 bool SyncRollbackManagerBase::PurgePartiallySyncedTypes() {
  83   NOTREACHED();
  84   return true;
  85 }
  86
  87 void SyncRollbackManagerBase::UpdateCredentials(
  88     const SyncCredentials& credentials) {
  89 }
  90
  91 void SyncRollbackManagerBase::StartSyncingNormally(
  92     const ModelSafeRoutingInfo& routing_info){
  93 }
  94
  95 void SyncRollbackManagerBase::ConfigureSyncer(
  96       ConfigureReason reason,
  97       ModelTypeSet to_download,
  98       ModelTypeSet to_purge,
  99       ModelTypeSet to_journal,
 100       ModelTypeSet to_unapply,
 101       const ModelSafeRoutingInfo& new_routing_info,
 102       const base::Closure& ready_task,
 103       const base::Closure& retry_task) {
 104   for (ModelTypeSet::Iterator type = to_download.First();
 105       type.Good(); type.Inc()) {
 106     if (InitTypeRootNode(type.Get())) {
 107       if (type.Get() == BOOKMARKS) {
 108         InitBookmarkFolder(kBookmarkBarTag);
 109         InitBookmarkFolder(kOtherBookmarksTag);
 110       }
 111     }
 112   }
 113
 114   ready_task.Run();
 115 }
 116
 117 void SyncRollbackManagerBase::SetInvalidatorEnabled(bool invalidator_enabled) {
 118 }
 119
 120 void SyncRollbackManagerBase::OnIncomingInvalidation(
 121     syncer::ModelType type,
 122     scoped_ptr<InvalidationInterface> invalidation) {
 123   NOTREACHED();
 124 }
 125
 126 void SyncRollbackManagerBase::AddObserver(SyncManager::Observer* observer) {
 127   observers_.AddObserver(observer);
 128 }
 129
 130 void SyncRollbackManagerBase::RemoveObserver(SyncManager::Observer* observer) {
 131   observers_.RemoveObserver(observer);
 132 }
 133
 134 SyncStatus SyncRollbackManagerBase::GetDetailedStatus() const {
 135   return SyncStatus();
 136 }
 137
 138 void SyncRollbackManagerBase::SaveChanges() {
 139 }
 140
 141 void SyncRollbackManagerBase::ShutdownOnSyncThread(ShutdownReason reason) {
 142   if (initialized_) {
 143     share_.directory->Close();
 144     share_.directory.reset();
 145     initialized_ = false;
 146   }
 147 }
 148
 149 UserShare* SyncRollbackManagerBase::GetUserShare() {
 150   return &share_;
 151 }
 152
 153 const std::string SyncRollbackManagerBase::cache_guid() {
 154   return share_.directory->cache_guid();
 155 }
 156
 157 bool SyncRollbackManagerBase::ReceivedExperiment(Experiments* experiments) {
 158   return false;
 159 }
 160
 161 bool SyncRollbackManagerBase::HasUnsyncedItems() {
 162   ReadTransaction trans(FROM_HERE, &share_);
 163   syncable::Directory::Metahandles unsynced;
 164   share_.directory->GetUnsyncedMetaHandles(trans.GetWrappedTrans(), &unsynced);
 165   return !unsynced.empty();
 166 }
 167
 168 SyncEncryptionHandler* SyncRollbackManagerBase::GetEncryptionHandler() {
 169   return dummy_handler_.get();
 170 }
 171
 172 void SyncRollbackManagerBase::RefreshTypes(ModelTypeSet types) {
 173
 174 }
 175
 176 void SyncRollbackManagerBase::HandleTransactionCompleteChangeEvent(
 177     ModelTypeSet models_with_changes) {
 178 }
 179
 180 ModelTypeSet SyncRollbackManagerBase::HandleTransactionEndingChangeEvent(
 181       const syncable::ImmutableWriteTransactionInfo& write_transaction_info,
 182       syncable::BaseTransaction* trans) {
 183   return ModelTypeSet();
 184 }
 185
 186 void SyncRollbackManagerBase::HandleCalculateChangesChangeEventFromSyncApi(
 187       const syncable::ImmutableWriteTransactionInfo& write_transaction_info,
 188       syncable::BaseTransaction* trans,
 189       std::vector<int64>* entries_changed) {
 190 }
 191
 192 void SyncRollbackManagerBase::HandleCalculateChangesChangeEventFromSyncer(
 193       const syncable::ImmutableWriteTransactionInfo& write_transaction_info,
 194       syncable::BaseTransaction* trans,
 195       std::vector<int64>* entries_changed) {
 196 }
 197
 198 void SyncRollbackManagerBase::OnTransactionWrite(
 199     const syncable::ImmutableWriteTransactionInfo& write_transaction_info,
 200     ModelTypeSet models_with_changes) {
 201 }
 202
 203 void SyncRollbackManagerBase::NotifyInitializationSuccess() {
 204   FOR_EACH_OBSERVER(
 205       SyncManager::Observer, observers_,
 206       OnInitializationComplete(
 207           MakeWeakHandle(base::WeakPtr<JsBackend>()),
 208           MakeWeakHandle(base::WeakPtr<DataTypeDebugInfoListener>()),
 209           true, InitialSyncEndedTypes()));
 210 }
 211
 212 void SyncRollbackManagerBase::NotifyInitializationFailure() {
 213   FOR_EACH_OBSERVER(
 214       SyncManager::Observer, observers_,
 215       OnInitializationComplete(
 216           MakeWeakHandle(base::WeakPtr<JsBackend>()),
 217           MakeWeakHandle(base::WeakPtr<DataTypeDebugInfoListener>()),
 218           false, ModelTypeSet()));
 219 }
 220
 221 syncer::SyncContextProxy* SyncRollbackManagerBase::GetSyncContextProxy() {
 222   return NULL;
 223 }
 224
 225 ScopedVector<syncer::ProtocolEvent>
 226 SyncRollbackManagerBase::GetBufferedProtocolEvents() {
 227   return ScopedVector<syncer::ProtocolEvent>().Pass();
 228 }
 229
 230 scoped_ptr<base::ListValue> SyncRollbackManagerBase::GetAllNodesForType(
 231     syncer::ModelType type) {
 232   ReadTransaction trans(FROM_HERE, GetUserShare());
 233   scoped_ptr<base::ListValue> nodes(
 234       trans.GetDirectory()->GetNodeDetailsForType(trans.GetWrappedTrans(),
 235                                                   type));
 236   return nodes.Pass();
 237 }
 238
 239 bool SyncRollbackManagerBase::InitBackupDB(
 240     const base::FilePath& sync_folder,
 241     InternalComponentsFactory* internal_components_factory,
 242     InternalComponentsFactory::StorageOption storage) {
 243   base::FilePath backup_db_path = sync_folder.Append(
 244       syncable::Directory::kSyncDatabaseFilename);
 245   scoped_ptr<syncable::DirectoryBackingStore> backing_store =
 246       internal_components_factory->BuildDirectoryBackingStore(
 247           storage, "backup", backup_db_path).Pass();
 248
 249   DCHECK(backing_store.get());
 250   share_.directory.reset(
 251       new syncable::Directory(
 252           backing_store.release(),
 253           unrecoverable_error_handler_.get(),
 254           report_unrecoverable_error_function_,
 255           NULL,
 256           NULL));
 257   return syncable::OPENED ==
 258       share_.directory->Open(
 259           "backup", this,
 260           MakeWeakHandle(weak_ptr_factory_.GetWeakPtr()));
 261 }
 262
 263 bool SyncRollbackManagerBase::InitTypeRootNode(ModelType type) {
 264   WriteTransaction trans(FROM_HERE, &share_);
 265   ReadNode root(&trans);
 266   if (BaseNode::INIT_OK == root.InitTypeRoot(type))
 267     return true;
 268
 269   syncable::MutableEntry entry(trans.GetWrappedWriteTrans(),
 270                                syncable::CREATE_NEW_UPDATE_ITEM,
 271                                syncable::Id::CreateFromServerId(
 272                                    ModelTypeToString(type)));
 273   if (!entry.good())
 274     return false;
 275
 276   entry.PutParentId(syncable::Id());
 277   entry.PutBaseVersion(1);
 278   entry.PutUniqueServerTag(ModelTypeToRootTag(type));
 279   entry.PutNonUniqueName(ModelTypeToString(type));
 280   entry.PutIsDel(false);
 281   entry.PutIsDir(true);
 282
 283   sync_pb::EntitySpecifics specifics;
 284   AddDefaultFieldValue(type, &specifics);
 285   entry.PutSpecifics(specifics);
 286
 287   return true;
 288 }
 289
 290 void SyncRollbackManagerBase::InitBookmarkFolder(const std::string& folder) {
 291   WriteTransaction trans(FROM_HERE, &share_);
 292   syncable::Entry bookmark_root(trans.GetWrappedTrans(),
 293                                 syncable::GET_TYPE_ROOT,
 294                                 BOOKMARKS);
 295   if (!bookmark_root.good())
 296     return;
 297
 298   syncable::MutableEntry entry(trans.GetWrappedWriteTrans(),
 299                                syncable::CREATE_NEW_UPDATE_ITEM,
 300                                syncable::Id::CreateFromServerId(folder));
 301   if (!entry.good())
 302     return;
 303
 304   entry.PutParentId(bookmark_root.GetId());
 305   entry.PutBaseVersion(1);
 306   entry.PutUniqueServerTag(folder);
 307   entry.PutNonUniqueName(folder);
 308   entry.PutIsDel(false);
 309   entry.PutIsDir(true);
 310
 311   sync_pb::EntitySpecifics specifics;
 312   AddDefaultFieldValue(BOOKMARKS, &specifics);
 313   entry.PutSpecifics(specifics);
 314 }
 315
 316 ObserverList<SyncManager::Observer>* SyncRollbackManagerBase::GetObservers() {
 317   return &observers_;
 318 }
 319
 320 void SyncRollbackManagerBase::RegisterDirectoryTypeDebugInfoObserver(
 321     syncer::TypeDebugInfoObserver* observer) {}
 322
 323 void SyncRollbackManagerBase::UnregisterDirectoryTypeDebugInfoObserver(
 324     syncer::TypeDebugInfoObserver* observer) {}
 325
 326 bool SyncRollbackManagerBase::HasDirectoryTypeDebugInfoObserver(
 327     syncer::TypeDebugInfoObserver* observer) { return false; }
 328
 329 void SyncRollbackManagerBase::RequestEmitDebugInfo() {}
 330
 331 }  // namespace syncer