Add sync manager classes for backup/rollback:

sync/internal_api/sync_rollback_manager_base.h

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SYNC_INTERNAL_API_SYNC_ROLLBACK_MANAGER_BASE_H_
+#define SYNC_INTERNAL_API_SYNC_ROLLBACK_MANAGER_BASE_H_
+
+#include <string>
+#include <vector>
+
+#include "sync/internal_api/public/http_post_provider_factory.h"
+#include "sync/internal_api/public/sync_manager.h"
+#include "sync/internal_api/public/user_share.h"
+#include "sync/syncable/directory_change_delegate.h"
+#include "sync/syncable/transaction_observer.h"
+
+namespace syncer {
+
+class WriteTransaction;
+
+// Base class of sync managers used for backup and rollback. Two major
+// functions are:
+//   * Init(): load backup DB into sync directory.
+//   * ConfigureSyncer(): initialize permanent sync nodes (root, bookmark
+//                        permanent folders) for configured type as needed.
+//
+// Most of other functions are no ops.
+class SyncRollbackManagerBase :
+    public SyncManager,
+    public syncable::DirectoryChangeDelegate,
+    public syncable::TransactionObserver {
+ public:
+  SyncRollbackManagerBase();
+  virtual ~SyncRollbackManagerBase();
+
+  // SyncManager implementation.
+  virtual void Init(
+      const base::FilePath& database_location,
+      const WeakHandle<JsEventHandler>& event_handler,
+      const std::string& sync_server_and_path,
+      int sync_server_port,
+      bool use_ssl,
+      scoped_ptr<HttpPostProviderFactory> post_factory,
+      const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
+      ExtensionsActivity* extensions_activity,
+      SyncManager::ChangeDelegate* change_delegate,
+      const SyncCredentials& credentials,
+      const std::string& invalidator_client_id,
+      const std::string& restored_key_for_bootstrapping,
+      const std::string& restored_keystore_key_for_bootstrapping,
+      InternalComponentsFactory* internal_components_factory,
+      Encryptor* encryptor,
+      scoped_ptr<UnrecoverableErrorHandler> unrecoverable_error_handler,
+      ReportUnrecoverableErrorFunction
+          report_unrecoverable_error_function,
+      CancelationSignal* cancelation_signal) OVERRIDE;
+  virtual void ThrowUnrecoverableError() OVERRIDE;
+  virtual ModelTypeSet InitialSyncEndedTypes() OVERRIDE;
+  virtual ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
+      ModelTypeSet types) OVERRIDE;
+  virtual bool PurgePartiallySyncedTypes() OVERRIDE;
+  virtual void UpdateCredentials(const SyncCredentials& credentials) OVERRIDE;
+  virtual void StartSyncingNormally(const ModelSafeRoutingInfo& routing_info)
+      OVERRIDE;
+  virtual void ConfigureSyncer(
+      ConfigureReason reason,
+      ModelTypeSet to_download,
+      ModelTypeSet to_purge,
+      ModelTypeSet to_journal,
+      ModelTypeSet to_unapply,
+      const ModelSafeRoutingInfo& new_routing_info,
+      const base::Closure& ready_task,
+      const base::Closure& retry_task) OVERRIDE;
+  virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
+  virtual void OnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
+  virtual void AddObserver(SyncManager::Observer* observer) OVERRIDE;
+  virtual void RemoveObserver(SyncManager::Observer* observer) OVERRIDE;
+  virtual SyncStatus GetDetailedStatus() const OVERRIDE;
+  virtual void SaveChanges() OVERRIDE;
+  virtual void ShutdownOnSyncThread() OVERRIDE;
+  virtual UserShare* GetUserShare() OVERRIDE;
+  virtual const std::string cache_guid() OVERRIDE;
+  virtual bool ReceivedExperiment(Experiments* experiments) OVERRIDE;
+  virtual bool HasUnsyncedItems() OVERRIDE;
+  virtual SyncEncryptionHandler* GetEncryptionHandler() OVERRIDE;
+  virtual void RefreshTypes(ModelTypeSet types) OVERRIDE;
+  virtual std::string GetOwnerName() const OVERRIDE;
+  virtual SyncCoreProxy* GetSyncCoreProxy() OVERRIDE;
+  virtual ScopedVector<ProtocolEvent> GetBufferedProtocolEvents()
+      OVERRIDE;
+  virtual scoped_ptr<base::ListValue> GetAllNodesForType(
+      syncer::ModelType type) OVERRIDE;
+
+  // DirectoryChangeDelegate implementation.
+  virtual void HandleTransactionCompleteChangeEvent(
+      ModelTypeSet models_with_changes) OVERRIDE;
+  virtual ModelTypeSet HandleTransactionEndingChangeEvent(
+      const syncable::ImmutableWriteTransactionInfo& write_transaction_info,
+      syncable::BaseTransaction* trans) OVERRIDE;
+  virtual void HandleCalculateChangesChangeEventFromSyncApi(
+      const syncable::ImmutableWriteTransactionInfo& write_transaction_info,
+      syncable::BaseTransaction* trans,
+      std::vector<int64>* entries_changed) OVERRIDE;
+  virtual void HandleCalculateChangesChangeEventFromSyncer(
+      const syncable::ImmutableWriteTransactionInfo& write_transaction_info,
+      syncable::BaseTransaction* trans,
+      std::vector<int64>* entries_changed) OVERRIDE;
+
+  // syncable::TransactionObserver implementation.
+  virtual void OnTransactionWrite(
+      const syncable::ImmutableWriteTransactionInfo& write_transaction_info,
+      ModelTypeSet models_with_changes) OVERRIDE;
+
+ protected:
+  void UpdateNewEntryStats(ModelType type);

[Nicolas Zea, 2014/04/17 18:22:56]

do these two methods need to be part of the parent class? It seems like they're
only used by the backup manager

[haitaol1, 2014/04/17 19:30:38]

Added to access private status_

On 2014/04/17 18:22:56, Nicolas Zea wrote:

[Nicolas Zea, 2014/04/17 20:26:44]

I think it's cleaner to have the implementations of this class own the status,
and handle any status updates they want. You could maybe pass a pointer to the
status in the init call to let the directory fill the initial status
information.

In general, it seems like this base class should never be instantiated on its
own, and should ideally have only that logic shared by both the backup and
rollback managers

[haitaol1, 2014/04/17 22:21:18]

Done.

+  void UpdateDeletedEntryStats(ModelType type);
+
+ private:
+  void NotifyInitializationSuccess();
+  void NotifyInitializationFailure();
+
+  bool InitBackupDB(
+      const base::FilePath& sync_folder,
+      InternalComponentsFactory* internal_components_factory);
+
+  bool InitTypeRootNode(ModelType type);
+  void InitBookmarkFolder(const std::string& folder);
+
+  UserShare share_;
+  SyncStatus status_;
+  ObserverList<SyncManager::Observer> observers_;
+
+  scoped_ptr<UnrecoverableErrorHandler> unrecoverable_error_handler_;
+  ReportUnrecoverableErrorFunction report_unrecoverable_error_function_;
+
+  base::WeakPtrFactory<SyncRollbackManagerBase> weak_ptr_factory_;
+};
+
+}  // namespace syncer
+
+#endif  // SYNC_INTERNAL_API_SYNC_ROLLBACK_MANAGER_BASE_H_