Add sync manager classes for backup/rollback:

sync/internal_api/sync_rollback_manager_base.h

Index: sync/internal_api/sync_rollback_manager_base.h
diff --git a/sync/internal_api/sync_rollback_manager_base.h b/sync/internal_api/sync_rollback_manager_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5227b0929572e583f21c1e57865aff305826601
--- /dev/null
+++ b/sync/internal_api/sync_rollback_manager_base.h
@@ -0,0 +1,139 @@
+// 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. Tow 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.

[maniscalco, 2014/04/15 16:29:14]

Can you help me understand why this class is a SyncManager?  Seems like that
forces it to implement a bunch of methods that don't really apply (i.e. are
no-op implementations).

[haitaol1, 2014/04/15 16:59:51]

It's sync manager because that's where the sync engine behaves very differently
in backup/rollback mode and in normal sync mode, thus those no-op
implementation. The objects used by normal sync manager, e.g. scheduler, syncer,
session context, etc, are not needed for backup purpose. The backup sync engine
is just a data store for local changes.

On 2014/04/15 16:29:14, maniscalco wrote:

[maniscalco, 2014/04/15 17:21:19]

What I'm asking is why does this class need to implement the SyncManager
interface?  Which other classes call into this class?  Could (should?) the
SyncManager interface be refactoring into smaller units so that this class could
only implement the parts that make sense?

On 2014/04/15 16:59:51, haitaol1 wrote:

[haitaol1, 2014/04/15 18:11:20]

SyncBackendHostCore interacts with SyncManager. Refactoring SyncManager is
desired (SyncManagerImpl is more than 1000 lines) but out of the scope of this
change.

On 2014/04/15 17:21:19, maniscalco wrote:

+  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:
+  UserShare share_;
+  SyncStatus status_;
+  ObserverList<SyncManager::Observer> observers_;
+
+ 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);
+
+  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_