move V2 classes in chrome/engine to syncer_v2 namespace

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/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/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 ModelTypeSyncProxy {
+class ModelTypeSyncProxyWrapper : public syncer_v2::ModelTypeSyncProxy {
  public:
   ModelTypeSyncProxyWrapper(
-      const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy,
+      const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy,
       const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner);
   ~ModelTypeSyncProxyWrapper() 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<ModelTypeSyncProxyImpl> processor_;
+  base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl> processor_;
   scoped_refptr<base::SequencedTaskRunner> processor_task_runner_;
 };
 
 ModelTypeSyncProxyWrapper::ModelTypeSyncProxyWrapper(
-    const base::WeakPtr<ModelTypeSyncProxyImpl>& proxy,
+    const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy,
     const scoped_refptr<base::SequencedTaskRunner>& processor_task_runner)
-    : processor_(proxy), processor_task_runner_(processor_task_runner) {
-}
+    : processor_(proxy), processor_task_runner_(processor_task_runner) {}
 
 ModelTypeSyncProxyWrapper::~ModelTypeSyncProxyWrapper() {
 }
 
 void ModelTypeSyncProxyWrapper::OnCommitCompleted(
     const syncer_v2::DataTypeState& type_state,
     const syncer_v2::CommitResponseDataList& response_list) {
   processor_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&ModelTypeSyncProxyImpl::OnCommitCompleted,
-                 processor_,
-                 type_state,
-                 response_list));
+      base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnCommitCompleted,
+                 processor_, type_state, response_list));
 }
 
 void ModelTypeSyncProxyWrapper::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(&ModelTypeSyncProxyImpl::OnUpdateReceived,
-                 processor_,
-                 type_state,
-                 response_list,
-                 pending_updates));
+      base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::OnUpdateReceived,
+                 processor_, type_state, response_list, pending_updates));
 }
 
-class ModelTypeSyncWorkerWrapper : public ModelTypeSyncWorker {
+class ModelTypeSyncWorkerWrapper : public syncer_v2::ModelTypeSyncWorker {
  public:
   ModelTypeSyncWorkerWrapper(
-      const base::WeakPtr<ModelTypeSyncWorkerImpl>& worker,
+      const base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl>& worker,
       const scoped_refptr<base::SequencedTaskRunner>& sync_thread);
   ~ModelTypeSyncWorkerWrapper() override;
 
   void EnqueueForCommit(const syncer_v2::CommitRequestDataList& list) override;
 
  private:
-  base::WeakPtr<ModelTypeSyncWorkerImpl> worker_;
+  base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl> worker_;
   scoped_refptr<base::SequencedTaskRunner> sync_thread_;
 };
 
 ModelTypeSyncWorkerWrapper::ModelTypeSyncWorkerWrapper(
-    const base::WeakPtr<ModelTypeSyncWorkerImpl>& worker,
+    const base::WeakPtr<syncer_v2::ModelTypeSyncWorkerImpl>& worker,
     const scoped_refptr<base::SequencedTaskRunner>& sync_thread)
-    : worker_(worker), sync_thread_(sync_thread) {
-}
+    : worker_(worker), sync_thread_(sync_thread) {}
 
 ModelTypeSyncWorkerWrapper::~ModelTypeSyncWorkerWrapper() {
 }
 
 void ModelTypeSyncWorkerWrapper::EnqueueForCommit(
     const syncer_v2::CommitRequestDataList& list) {
   sync_thread_->PostTask(
       FROM_HERE,
-      base::Bind(&ModelTypeSyncWorkerImpl::EnqueueForCommit, worker_, list));
+      base::Bind(&syncer_v2::ModelTypeSyncWorkerImpl::EnqueueForCommit, worker_,
+                 list));
 }
 
 }  // namespace
 
 ModelTypeRegistry::ModelTypeRegistry(
     const std::vector<scoped_refptr<ModelSafeWorker> >& workers,
     syncable::Directory* directory,
     NudgeHandler* nudge_handler)
     : directory_(directory),
       nudge_handler_(nudge_handler),
@@ skipping 70 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<ModelTypeSyncProxyImpl>& proxy_impl) {
+    const base::WeakPtr<syncer_v2::ModelTypeSyncProxyImpl>& proxy_impl) {
   DVLOG(1) << "Enabling an off-thread sync type: " << ModelTypeToString(type);
 
   // Initialize Worker -> Proxy communication channel.
-  scoped_ptr<ModelTypeSyncProxy> proxy(
+  scoped_ptr<syncer_v2::ModelTypeSyncProxy> proxy(
       new ModelTypeSyncProxyWrapper(proxy_impl, type_task_runner));
   scoped_ptr<Cryptographer> cryptographer_copy;
   if (encrypted_types_.Has(type))
     cryptographer_copy.reset(new Cryptographer(*cryptographer_));
 
-  scoped_ptr<ModelTypeSyncWorkerImpl> worker(
-      new ModelTypeSyncWorkerImpl(type,
-                                  data_type_state,
-                                  saved_pending_updates,
-                                  cryptographer_copy.Pass(),
-                                  nudge_handler_,
-                                  proxy.Pass()));
+  scoped_ptr<syncer_v2::ModelTypeSyncWorkerImpl> worker(
+      new syncer_v2::ModelTypeSyncWorkerImpl(
+          type, data_type_state, saved_pending_updates,
+          cryptographer_copy.Pass(), nudge_handler_, proxy.Pass()));
 
   // Initialize Proxy -> Worker communication channel.
-  scoped_ptr<ModelTypeSyncWorker> wrapped_worker(
+  scoped_ptr<syncer_v2::ModelTypeSyncWorker> wrapped_worker(
       new ModelTypeSyncWorkerWrapper(worker->AsWeakPtr(),
                                      scoped_refptr<base::SequencedTaskRunner>(
                                          base::ThreadTaskRunnerHandle::Get())));
-  type_task_runner->PostTask(FROM_HERE,
-                             base::Bind(&ModelTypeSyncProxyImpl::OnConnect,
-                                        proxy_impl,
-                                        base::Passed(&wrapped_worker)));
+  type_task_runner->PostTask(
+      FROM_HERE, base::Bind(&syncer_v2::ModelTypeSyncProxyImpl::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());
 
   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<ModelTypeSyncWorkerImpl>::iterator it =
+  for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::iterator it =
            model_type_sync_workers_.begin();
-       it != model_type_sync_workers_.end();
-       ++it) {
+       it != model_type_sync_workers_.end(); ++it) {
     if ((*it)->GetModelType() == type) {
       model_type_sync_workers_.erase(it);
       break;
     }
   }
 }
 
 ModelTypeSet ModelTypeRegistry::GetEnabledTypes() const {
   return Union(GetEnabledDirectoryTypes(), GetEnabledNonBlockingTypes());
 }
@@ skipping 75 matching lines @@
 
 void ModelTypeRegistry::OnLocalSetPassphraseEncryption(
     const SyncEncryptionHandler::NigoriState& nigori_state) {
 }
 
 ModelTypeSet ModelTypeRegistry::GetEnabledDirectoryTypes() const {
   return enabled_directory_types_;
 }
 
 void ModelTypeRegistry::OnEncryptionStateChanged() {
-  for (ScopedVector<ModelTypeSyncWorkerImpl>::iterator it =
+  for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::iterator it =
            model_type_sync_workers_.begin();
-       it != model_type_sync_workers_.end();
-       ++it) {
+       it != model_type_sync_workers_.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<ModelTypeSyncWorkerImpl>::const_iterator it =
+  for (ScopedVector<syncer_v2::ModelTypeSyncWorkerImpl>::const_iterator it =
            model_type_sync_workers_.begin();
-       it != model_type_sync_workers_.end();
-       ++it) {
+       it != model_type_sync_workers_.end(); ++it) {
     enabled_off_thread_types.Put((*it)->GetModelType());
   }
   return enabled_off_thread_types;
 }
 
 }  // namespace syncer