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