[Sync] rename USS processor / worker interfaces

sync/sessions/model_type_registry.cc

 // 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.
 
 #include "sync/sessions/model_type_registry.h"
 
 #include "base/bind.h"
 #include "base/observer_list.h"
 #include "base/thread_task_runner_handle.h"
+#include "sync/engine/commit_queue.h"
+#include "sync/engine/commit_queue_impl.h"
 #include "sync/engine/directory_commit_contributor.h"
 #include "sync/engine/directory_update_handler.h"
-#include "sync/engine/model_type_sync_proxy.h"
-#include "sync/engine/model_type_sync_proxy_impl.h"
-#include "sync/engine/model_type_sync_worker.h"
-#include "sync/engine/model_type_sync_worker_impl.h"
+#include "sync/engine/model_type_processor.h"
+#include "sync/engine/model_type_processor_impl.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/util/cryptographer.h"
 
 namespace syncer {
 
 namespace {
 
-class ModelTypeSyncProxyWrapper : public syncer_v2::ModelTypeSyncProxy {
+class ModelTypeProcessorWrapper : public syncer_v2::ModelTypeProcessor {
  public:
-  ModelTypeSyncProxyWrapper(
-      const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy,
+  ModelTypeProcessorWrapper(
+      const base::WeakPtr<syncer_v2::ModelTypeProcessorImpl>& proxy,
       const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner);
-  ~ModelTypeSyncProxyWrapper() override;
+  ~ModelTypeProcessorWrapper() override;
 
   void OnCommitCompleted(
       const syncer_v2::DataTypeState& type_state,
       const syncer_v2::CommitResponseDataList& response_list) override;
   void OnUpdateReceived(
       const syncer_v2::DataTypeState& type_state,
       const syncer_v2::UpdateResponseDataList& response_list,
       const syncer_v2::UpdateResponseDataList& pending_updates) override;
 
  private:
-  base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl> processor_;
+  base::WeakPtr<syncer_v2::ModelTypeProcessorImpl> processor_;
   scoped_refptr<base::SequencedTaskRunner> processor_task_runner_;
 };
 
-ModelTypeSyncProxyWrapper::ModelTypeSyncProxyWrapper(
-    const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy,
+ModelTypeProcessorWrapper::ModelTypeProcessorWrapper(
+    const base::WeakPtr<syncer_v2::ModelTypeProcessorImpl>& proxy,
     const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner)
     : processor_(proxy), processor_task_runner_(processor_task_runner) {}
 
-ModelTypeSyncProxyWrapper::~ModelTypeSyncProxyWrapper() {
+ModelTypeProcessorWrapper::~ModelTypeProcessorWrapper() {
 }
 
-void ModelTypeSyncProxyWrapper::OnCommitCompleted(
+void ModelTypeProcessorWrapper::OnCommitCompleted(
     const syncer_v2::DataTypeState& type_state,
     const syncer_v2::CommitResponseDataList& response_list) {
   processor_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnCommitCompleted,
+      base::Bind(&syncer_v2::ModelTypeProcessorImpl::OnCommitCompleted,
                  processor_, type_state, response_list));
 }
 
-void ModelTypeSyncProxyWrapper::OnUpdateReceived(
+void ModelTypeProcessorWrapper::OnUpdateReceived(
     const syncer_v2::DataTypeState& type_state,
     const syncer_v2::UpdateResponseDataList& response_list,
     const syncer_v2::UpdateResponseDataList& pending_updates) {
   processor_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnUpdateReceived,
+      base::Bind(&syncer_v2::ModelTypeProcessorImpl::OnUpdateReceived,
                  processor_, type_state, response_list, pending_updates));
 }
 
-class ModelTypeSyncWorkerWrapper : public syncer_v2::ModelTypeSyncWorker {
+class CommitQueueWrapper : public syncer_v2::CommitQueue {
  public:
-  ModelTypeSyncWorkerWrapper(
-      const base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl>& worker,
+  CommitQueueWrapper(
+      const base::WeakPtr<syncer_v2::CommitQueueImpl>& worker,
       const scoped_refptr<base::SequencedTaskRunner>& sync_thread);
-  ~ModelTypeSyncWorkerWrapper() override;
+  ~CommitQueueWrapper() override;
 
   void EnqueueForCommit(const syncer_v2::CommitRequestDataList& list) override;
 
  private:
-  base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl> worker_;
+  base::WeakPtr<syncer_v2::CommitQueueImpl> worker_;
   scoped_refptr<base::SequencedTaskRunner> sync_thread_;
 };
 
-ModelTypeSyncWorkerWrapper::ModelTypeSyncWorkerWrapper(
-    const base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl>& worker,
+CommitQueueWrapper::CommitQueueWrapper(
+    const base::WeakPtr<syncer_v2::CommitQueueImpl>& worker,
     const scoped_refptr<base::SequencedTaskRunner>& sync_thread)
     : worker_(worker), sync_thread_(sync_thread) {}
 
-ModelTypeSyncWorkerWrapper::~ModelTypeSyncWorkerWrapper() {
+CommitQueueWrapper::~CommitQueueWrapper() {
 }
 
-void ModelTypeSyncWorkerWrapper::EnqueueForCommit(
+void CommitQueueWrapper::EnqueueForCommit(
     const syncer_v2::CommitRequestDataList& list) {
   sync_thread_->PostTask(
       FROM_HERE,
-      base::Bind(&syncer_v2::ModelTypeSyncWorkerImpl::EnqueueForCommit, worker_,
+      base::Bind(&syncer_v2::CommitQueueImpl::EnqueueForCommit, worker_,
                  list));
 }
 
 }  // namespace
 
 ModelTypeRegistry::ModelTypeRegistry(
     const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
     syncable::Directory* directory,
     NudgeHandler* nudge_handler)
     : directory_(directory),
@@ skipping 71 matching lines @@
   enabled_directory_types_ = GetRoutingInfoTypes(routing_info);
   DCHECK(Intersection(GetEnabledDirectoryTypes(),
                       GetEnabledNonBlockingTypes()).Empty());
 }
 
 void ModelTypeRegistry::ConnectSyncTypeToWorker(
     ModelType type,
     const syncer_v2::DataTypeState& data_type_state,
     const syncer_v2::UpdateResponseDataList& saved_pending_updates,
     const scoped_refptr<base::SequencedTaskRunner>& type_task_runner,
-    const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy_impl) {
+    const base::WeakPtr<syncer_v2::ModelTypeProcessorImpl>& proxy_impl) {
   DVLOG(1) << "Enabling an off-thread sync type: " << ModelTypeToString(type);
 
   // Initialize Worker -> Proxy communication channel.
-  scoped_ptr<syncer_v2::ModelTypeSyncProxy> proxy(
-      new ModelTypeSyncProxyWrapper(proxy_impl, type_task_runner));
+  scoped_ptr<syncer_v2::ModelTypeProcessor> proxy(
+      new ModelTypeProcessorWrapper(proxy_impl, type_task_runner));
   scoped_ptr<Cryptographer> cryptographer_copy;
   if (encrypted_types_.Has(type))
     cryptographer_copy.reset(new Cryptographer(*cryptographer_));
 
-  scoped_ptr<syncer_v2::ModelTypeSyncWorkerImpl> worker(
-      new syncer_v2::ModelTypeSyncWorkerImpl(
+  scoped_ptr<syncer_v2::CommitQueueImpl> worker(
+      new syncer_v2::CommitQueueImpl(
           type, data_type_state, saved_pending_updates,
           cryptographer_copy.Pass(), nudge_handler_, proxy.Pass()));
 
   // Initialize Proxy -> Worker communication channel.
-  scoped_ptr<syncer_v2::ModelTypeSyncWorker> wrapped_worker(
-      new ModelTypeSyncWorkerWrapper(worker->AsWeakPtr(),
+  scoped_ptr<syncer_v2::CommitQueue> wrapped_worker(
+      new CommitQueueWrapper(worker->AsWeakPtr(),
                                      scoped_refptr<base::SequencedTaskRunner>(
                                          base::ThreadTaskRunnerHandle::Get())));
   type_task_runner->PostTask(
-      FROM_HERE, base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnConnect,
+      FROM_HERE, base::Bind(&syncer_v2::ModelTypeProcessorImpl::OnConnect,
                             proxy_impl, base::Passed(&wrapped_worker)));
 
   DCHECK(update_handler_map_.find(type) == update_handler_map_.end());
   DCHECK(commit_contributor_map_.find(type) == commit_contributor_map_.end());
 
   update_handler_map_.insert(std::make_pair(type, worker.get()));
   commit_contributor_map_.insert(std::make_pair(type, worker.get()));
 
   // The container takes ownership.
-  model_type_sync_workers_.push_back(worker.Pass());
+  commit_queues_.push_back(worker.Pass());
 
   DCHECK(Intersection(GetEnabledDirectoryTypes(),
                       GetEnabledNonBlockingTypes()).Empty());
 }
 
 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());
 
   size_t updaters_erased = update_handler_map_.erase(type);
   size_t committers_erased = commit_contributor_map_.erase(type);
 
   DCHECK_EQ(1U, updaters_erased);
   DCHECK_EQ(1U, committers_erased);
 
   // Remove from the ScopedVector, deleting the worker in the process.
-  for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::iterator it =
-           model_type_sync_workers_.begin();
-       it != model_type_sync_workers_.end(); ++it) {
+  for (ScopedVector<syncer_v2::CommitQueueImpl>::iterator it =
+           commit_queues_.begin();
+       it != commit_queues_.end(); ++it) {
     if ((*it)->GetModelType() == type) {
-      model_type_sync_workers_.erase(it);
+      commit_queues_.erase(it);
       break;
     }
   }
 }
 
 ModelTypeSet ModelTypeRegistry::GetEnabledTypes() const {
   return Union(GetEnabledDirectoryTypes(), GetEnabledNonBlockingTypes());
 }
 
 UpdateHandlerMap* ModelTypeRegistry::update_handler_map() {
@@ skipping 73 matching lines @@
 
 void ModelTypeRegistry::OnLocalSetPassphraseEncryption(
     const SyncEncryptionHandler::NigoriState& nigori_state) {
 }
 
 ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const {
   return enabled_directory_types_;
 }
 
 void ModelTypeRegistry::OnEncryptionStateChanged() {
-  for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::iterator it =
-           model_type_sync_workers_.begin();
-       it != model_type_sync_workers_.end(); ++it) {
+  for (ScopedVector<syncer_v2::CommitQueueImpl>::iterator it =
+           commit_queues_.begin();
+       it != commit_queues_.end(); ++it) {
     if (encrypted_types_.Has((*it)->GetModelType())) {
       (*it)->UpdateCryptographer(
           make_scoped_ptr(new Cryptographer(*cryptographer_)));
     }
   }
 }
 
 ModelTypeSet ModelTypeRegistry::GetEnabledNonBlockingTypes() const {
   ModelTypeSet enabled_off_thread_types;
-  for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::const_iterator it =
-           model_type_sync_workers_.begin();
-       it != model_type_sync_workers_.end(); ++it) {
+  for (ScopedVector<syncer_v2::CommitQueueImpl>::const_iterator it =
+           commit_queues_.begin();
+       it != commit_queues_.end(); ++it) {
     enabled_off_thread_types.Put((*it)->GetModelType());
   }
   return enabled_off_thread_types;
 }
 
 }  // namespace syncer