sync: Inheritance refactor for non-blocking sync

Implements several previously discussed changes to the inheritance
hierarchy for non-blocking sync classes.

Changes SyncContext from a wrapper around ModelTypeRegistry to an
interface class that ModelTypeRegistry implemnts.

Makes ModelTypeSyncWorkerImpl implement the ModelTypeSyncWorker
interface, even though it is never referenced via this interface.  Makes
the same change to ModelTypeSyncProxyImpl and the ModelTypeSyncProxy
interface.  These refactoring required that some methods be renamed to
be consistent with the interface.

This completes the refactoring that was started in r279618.

BUG=351005

Review URL: https://codereview.chromium.org/351073005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@280417 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 56 insertions, 45 deletions

diff --git a/sync/sessions/model_type_registry.cc b/sync/sessions/model_type_registry.cc
index b8ab74b..46e09a5 100644
--- a/sync/sessions/model_type_registry.cc
+++ b/sync/sessions/model_type_registry.cc
@@ -27,10 +27,10 @@ class ModelTypeSyncProxyWrapper : public ModelTypeSyncProxy {
       const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner);
   virtual ~ModelTypeSyncProxyWrapper();
 
-  virtual void ReceiveCommitResponse(
+  virtual void OnCommitCompleted(
       const DataTypeState& type_state,
       const CommitResponseDataList& response_list) OVERRIDE;
-  virtual void ReceiveUpdateResponse(
+  virtual void OnUpdateReceived(
       const DataTypeState& type_state,
       const UpdateResponseDataList& response_list) OVERRIDE;
 
@@ -48,18 +48,18 @@ ModelTypeSyncProxyWrapper::ModelTypeSyncProxyWrapper(
 ModelTypeSyncProxyWrapper::~ModelTypeSyncProxyWrapper() {
 }
 
-void ModelTypeSyncProxyWrapper::ReceiveCommitResponse(
+void ModelTypeSyncProxyWrapper::OnCommitCompleted(
     const DataTypeState& type_state,
     const CommitResponseDataList& response_list) {
   processor_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&ModelTypeSyncProxyImpl::OnCommitCompletion,
+      base::Bind(&ModelTypeSyncProxyImpl::OnCommitCompleted,
                  processor_,
                  type_state,
                  response_list));
 }
 
-void ModelTypeSyncProxyWrapper::ReceiveUpdateResponse(
+void ModelTypeSyncProxyWrapper::OnUpdateReceived(
     const DataTypeState& type_state,
     const UpdateResponseDataList& response_list) {
   processor_task_runner_->PostTask(
@@ -77,7 +77,7 @@ class ModelTypeSyncWorkerWrapper : public ModelTypeSyncWorker {
       const scoped_refptr<base::SequencedTaskRunner>& sync_thread);
   virtual ~ModelTypeSyncWorkerWrapper();
 
-  virtual void RequestCommits(const CommitRequestDataList& list) OVERRIDE;
+  virtual void EnqueueForCommit(const CommitRequestDataList& list) OVERRIDE;
 
  private:
   base::WeakPtr<ModelTypeSyncWorkerImpl> worker_;
@@ -93,7 +93,7 @@ ModelTypeSyncWorkerWrapper::ModelTypeSyncWorkerWrapper(
 ModelTypeSyncWorkerWrapper::~ModelTypeSyncWorkerWrapper() {
 }
 
-void ModelTypeSyncWorkerWrapper::RequestCommits(
+void ModelTypeSyncWorkerWrapper::EnqueueForCommit(
     const CommitRequestDataList& list) {
   sync_thread_->PostTask(
       FROM_HERE,
@@ -102,12 +102,14 @@ void ModelTypeSyncWorkerWrapper::RequestCommits(
 
 }  // namespace
 
-ModelTypeRegistry::ModelTypeRegistry() : directory_(NULL) {}
+ModelTypeRegistry::ModelTypeRegistry()
+    : directory_(NULL), weak_ptr_factory_(this) {
+}
 
 ModelTypeRegistry::ModelTypeRegistry(
     const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
     syncable::Directory* directory)
-    : directory_(directory) {
+    : directory_(directory), weak_ptr_factory_(this) {
   for (size_t i = 0u; i < workers.size(); ++i) {
     workers_map_.insert(
         std::make_pair(workers[i]->GetModelSafeGroup(), workers[i]));
@@ -181,7 +183,7 @@ void ModelTypeRegistry::SetEnabledDirectoryTypes(
                       GetEnabledNonBlockingTypes()).Empty());
 }
 
-void ModelTypeRegistry::InitializeNonBlockingType(
+void ModelTypeRegistry::ConnectSyncTypeToWorker(
     ModelType type,
     const DataTypeState& data_type_state,
     const scoped_refptr<base::SequencedTaskRunner>& type_task_runner,
@@ -217,7 +219,7 @@ void ModelTypeRegistry::InitializeNonBlockingType(
                       GetEnabledNonBlockingTypes()).Empty());
 }
 
-void ModelTypeRegistry::RemoveNonBlockingType(ModelType type) {
+void ModelTypeRegistry::DisconnectSyncWorker(ModelType type) {
   DVLOG(1) << "Disabling an off-thread sync type: " << ModelTypeToString(type);
   DCHECK(update_handler_map_.find(type) != update_handler_map_.end());
   DCHECK(commit_contributor_map_.find(type) != commit_contributor_map_.end());
@@ -283,6 +285,10 @@ void ModelTypeRegistry::RequestEmitDebugInfo() {
   }
 }
 
+base::WeakPtr<SyncContext> ModelTypeRegistry::AsWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
 ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const {
   return enabled_directory_types_;
 }
diff --git a/sync/sessions/model_type_registry.h b/sync/sessions/model_type_registry.h
index 255a841..4444682 100644
--- a/sync/sessions/model_type_registry.h
+++ b/sync/sessions/model_type_registry.h
@@ -10,10 +10,12 @@
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/memory/weak_ptr.h"
 #include "sync/base/sync_export.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/internal_api/public/sessions/type_debug_info_observer.h"
+#include "sync/internal_api/public/sync_context.h"
 
 namespace syncer {
 
@@ -36,7 +38,7 @@ typedef std::map<ModelType, DirectoryTypeDebugInfoEmitter*>
     DirectoryTypeDebugInfoEmitterMap;
 
 // Keeps track of the sets of active update handlers and commit contributors.
-class SYNC_EXPORT_PRIVATE ModelTypeRegistry {
+class SYNC_EXPORT_PRIVATE ModelTypeRegistry : public SyncContext {
  public:
   // This alternative constructor does not support any directory types.
   // It is used only in tests.
@@ -46,7 +48,7 @@ class SYNC_EXPORT_PRIVATE ModelTypeRegistry {
   ModelTypeRegistry(
       const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
       syncable::Directory* directory);
-  ~ModelTypeRegistry();
+  virtual ~ModelTypeRegistry();
 
   // Sets the set of enabled types.
   void SetEnabledDirectoryTypes(const ModelSafeRoutingInfo& routing_info);
@@ -55,17 +57,17 @@ class SYNC_EXPORT_PRIVATE ModelTypeRegistry {
   // and its task_runner to the newly created worker.
   //
   // Expects that the proxy's ModelType is not currently enabled.
-  void InitializeNonBlockingType(
+  virtual void ConnectSyncTypeToWorker(
       syncer::ModelType type,
       const DataTypeState& data_type_state,
       const scoped_refptr<base::SequencedTaskRunner>& type_task_runner,
-      const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy);
+      const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy) OVERRIDE;
 
   // Disables the syncing of an off-thread type.
   //
   // Expects that the type is currently enabled.
   // Deletes the worker associated with the type.
-  void RemoveNonBlockingType(syncer::ModelType type);
+  virtual void DisconnectSyncWorker(syncer::ModelType type) OVERRIDE;
 
   // Gets the set of enabled types.
   ModelTypeSet GetEnabledTypes() const;
@@ -83,6 +85,8 @@ class SYNC_EXPORT_PRIVATE ModelTypeRegistry {
       syncer::TypeDebugInfoObserver* observer);
   void RequestEmitDebugInfo();
 
+  base::WeakPtr<SyncContext> AsWeakPtr();
+
  private:
   ModelTypeSet GetEnabledNonBlockingTypes() const;
   ModelTypeSet GetEnabledDirectoryTypes() const;
@@ -122,10 +126,11 @@ class SYNC_EXPORT_PRIVATE ModelTypeRegistry {
   // guaranteed to live as long as this sync backend.
   ObserverList<TypeDebugInfoObserver> type_debug_info_observers_;
 
+  base::WeakPtrFactory<ModelTypeRegistry> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(ModelTypeRegistry);
 };
 
 }  // namespace syncer
 
 #endif // SYNC_ENGINE_MODEL_TYPE_REGISTRY_H_
-
diff --git a/sync/sessions/model_type_registry_unittest.cc b/sync/sessions/model_type_registry_unittest.cc
index d9d314e..ca1ddb1 100644
--- a/sync/sessions/model_type_registry_unittest.cc
+++ b/sync/sessions/model_type_registry_unittest.cc
@@ -147,21 +147,21 @@ TEST_F(ModelTypeRegistryTest, NonBlockingTypes) {
 
   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 
-  registry()->InitializeNonBlockingType(syncer::THEMES,
-                                        MakeInitialDataTypeState(THEMES),
-                                        task_runner,
-                                        themes_sync_proxy.AsWeakPtrForUI());
+  registry()->ConnectSyncTypeToWorker(syncer::THEMES,
+                                      MakeInitialDataTypeState(THEMES),
+                                      task_runner,
+                                      themes_sync_proxy.AsWeakPtrForUI());
   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(
       ModelTypeSet(syncer::THEMES)));
 
-  registry()->InitializeNonBlockingType(syncer::SESSIONS,
-                                        MakeInitialDataTypeState(SESSIONS),
-                                        task_runner,
-                                        sessions_sync_proxy.AsWeakPtrForUI());
+  registry()->ConnectSyncTypeToWorker(syncer::SESSIONS,
+                                      MakeInitialDataTypeState(SESSIONS),
+                                      task_runner,
+                                      sessions_sync_proxy.AsWeakPtrForUI());
   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(
       ModelTypeSet(syncer::THEMES, syncer::SESSIONS)));
 
-  registry()->RemoveNonBlockingType(syncer::THEMES);
+  registry()->DisconnectSyncWorker(syncer::THEMES);
   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(
       ModelTypeSet(syncer::SESSIONS)));
 
@@ -184,10 +184,10 @@ TEST_F(ModelTypeRegistryTest, NonBlockingTypesWithDirectoryTypes) {
   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 
   // Add the themes non-blocking type.
-  registry()->InitializeNonBlockingType(syncer::THEMES,
-                                        MakeInitialDataTypeState(THEMES),
-                                        task_runner,
-                                        themes_sync_proxy.AsWeakPtrForUI());
+  registry()->ConnectSyncTypeToWorker(syncer::THEMES,
+                                      MakeInitialDataTypeState(THEMES),
+                                      task_runner,
+                                      themes_sync_proxy.AsWeakPtrForUI());
   current_types.Put(syncer::THEMES);
   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 
@@ -197,15 +197,15 @@ TEST_F(ModelTypeRegistryTest, NonBlockingTypesWithDirectoryTypes) {
   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 
   // Add sessions non-blocking type.
-  registry()->InitializeNonBlockingType(syncer::SESSIONS,
-                                        MakeInitialDataTypeState(SESSIONS),
-                                        task_runner,
-                                        sessions_sync_proxy.AsWeakPtrForUI());
+  registry()->ConnectSyncTypeToWorker(syncer::SESSIONS,
+                                      MakeInitialDataTypeState(SESSIONS),
+                                      task_runner,
+                                      sessions_sync_proxy.AsWeakPtrForUI());
   current_types.Put(syncer::SESSIONS);
   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 
   // Remove themes non-blocking type.
-  registry()->RemoveNonBlockingType(syncer::THEMES);
+  registry()->DisconnectSyncWorker(syncer::THEMES);
   current_types.Remove(syncer::THEMES);
   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(current_types));
 
@@ -226,24 +226,24 @@ TEST_F(ModelTypeRegistryTest, DeletionOrdering) {
 
   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 
-  registry()->InitializeNonBlockingType(syncer::THEMES,
-                                        MakeInitialDataTypeState(THEMES),
-                                        task_runner,
-                                        themes_sync_proxy->AsWeakPtrForUI());
-  registry()->InitializeNonBlockingType(syncer::SESSIONS,
-                                        MakeInitialDataTypeState(SESSIONS),
-                                        task_runner,
-                                        sessions_sync_proxy->AsWeakPtrForUI());
+  registry()->ConnectSyncTypeToWorker(syncer::THEMES,
+                                      MakeInitialDataTypeState(THEMES),
+                                      task_runner,
+                                      themes_sync_proxy->AsWeakPtrForUI());
+  registry()->ConnectSyncTypeToWorker(syncer::SESSIONS,
+                                      MakeInitialDataTypeState(SESSIONS),
+                                      task_runner,
+                                      sessions_sync_proxy->AsWeakPtrForUI());
   EXPECT_TRUE(registry()->GetEnabledTypes().Equals(
       ModelTypeSet(syncer::THEMES, syncer::SESSIONS)));
 
   // Tear down themes processing, starting with the worker.
-  registry()->RemoveNonBlockingType(syncer::THEMES);
+  registry()->DisconnectSyncWorker(syncer::THEMES);
   themes_sync_proxy.reset();
 
   // Tear down sessions processing, starting with the type sync proxy.
   sessions_sync_proxy.reset();
-  registry()->RemoveNonBlockingType(syncer::SESSIONS);
+  registry()->DisconnectSyncWorker(syncer::SESSIONS);
 
   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 }