[Sync] Move //components/sync to the syncer namespace, take 2.

components/sync/core/model_type_store_impl.cc

 // Copyright 2015 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 "components/sync/core/model_type_store_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/core/model_type_store_backend.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
-namespace syncer_v2 {
+namespace syncer {
 
 namespace {
 
 // Key prefix for data/metadata records.
 const char kDataPrefix[] = "-dt-";
 const char kMetadataPrefix[] = "-md-";
 
 // Key for global metadata record.
 const char kGlobalMetadataKey[] = "GlobalMetadata";
 
 void NoOpForBackendDtor(scoped_refptr<ModelTypeStoreBackend> backend) {
   // This function was intentionally left blank.
 }
 
 }  // namespace
 
 // static
-std::string ModelTypeStoreImpl::FormatDataPrefix(const syncer::ModelType type) {
-  return std::string(syncer::GetModelTypeRootTag(type)) + kDataPrefix;
+std::string ModelTypeStoreImpl::FormatDataPrefix(const ModelType type) {
+  return std::string(GetModelTypeRootTag(type)) + kDataPrefix;
 }
 
 // static
-std::string ModelTypeStoreImpl::FormatMetaPrefix(const syncer::ModelType type) {
-  return std::string(syncer::GetModelTypeRootTag(type)) + kMetadataPrefix;
+std::string ModelTypeStoreImpl::FormatMetaPrefix(const ModelType type) {
+  return std::string(GetModelTypeRootTag(type)) + kMetadataPrefix;
 }
 
 // static
 leveldb::WriteBatch* ModelTypeStoreImpl::GetLeveldbWriteBatch(
     WriteBatch* write_batch) {
   return static_cast<WriteBatchImpl*>(write_batch)->leveldb_write_batch_.get();
 }
 
 std::string ModelTypeStoreImpl::FormatDataKey(const std::string& id) {
   return data_prefix_ + id;
 }
 
 std::string ModelTypeStoreImpl::FormatMetadataKey(const std::string& id) {
   return metadata_prefix_ + id;
 }
 
 ModelTypeStoreImpl::ModelTypeStoreImpl(
-    const syncer::ModelType type,
+    const ModelType type,
     scoped_refptr<ModelTypeStoreBackend> backend,
     scoped_refptr<base::SequencedTaskRunner> backend_task_runner)
     : backend_(backend),
       backend_task_runner_(backend_task_runner),
       data_prefix_(FormatDataPrefix(type)),
       metadata_prefix_(FormatMetaPrefix(type)),
       weak_ptr_factory_(this) {
   DCHECK(backend_);
   DCHECK(backend_task_runner_);
 }
 
 ModelTypeStoreImpl::~ModelTypeStoreImpl() {
   DCHECK(CalledOnValidThread());
   backend_task_runner_->PostTask(
       FROM_HERE, base::Bind(&NoOpForBackendDtor, base::Passed(&backend_)));
 }
 
 // static
 void ModelTypeStoreImpl::CreateStore(
-    const syncer::ModelType type,
+    const ModelType type,
     const std::string& path,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
     const InitCallback& callback) {
   DCHECK(!callback.is_null());
   std::unique_ptr<leveldb::Env> env;
   std::unique_ptr<Result> result(new Result());
   auto task = base::Bind(&ModelTypeStoreBackend::GetOrCreateBackend, path,
                          base::Passed(&env), result.get());
   auto reply =
       base::Bind(&ModelTypeStoreImpl::BackendInitDone, type,
@@ skipping 16 matching lines @@
   path += "/in-memory";
 
   // In-memory store backend works on the same thread as test.
   scoped_refptr<base::SequencedTaskRunner> task_runner =
       base::ThreadTaskRunnerHandle::Get();
 
   std::unique_ptr<Result> result(new Result());
 
   auto task = base::Bind(&ModelTypeStoreBackend::GetOrCreateBackend, path,
                          base::Passed(&env), result.get());
-  auto reply =
-      base::Bind(&ModelTypeStoreImpl::BackendInitDone, syncer::UNSPECIFIED,
-                 base::Passed(&result), task_runner, callback);
+  auto reply = base::Bind(&ModelTypeStoreImpl::BackendInitDone, UNSPECIFIED,
+                          base::Passed(&result), task_runner, callback);
 
   base::PostTaskAndReplyWithResult(task_runner.get(), FROM_HERE, task, reply);
 }
 
 // static
 void ModelTypeStoreImpl::BackendInitDone(
-    const syncer::ModelType type,
+    const ModelType type,
     std::unique_ptr<Result> result,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
     const InitCallback& callback,
     scoped_refptr<ModelTypeStoreBackend> backend) {
   std::unique_ptr<ModelTypeStoreImpl> store;
   if (*result == Result::SUCCESS) {
     store.reset(new ModelTypeStoreImpl(type, backend, blocking_task_runner));
   }
 
   callback.Run(*result, std::move(store));
@@ skipping 195 matching lines @@
   DCHECK(CalledOnValidThread());
   GetLeveldbWriteBatch(write_batch)->Delete(kGlobalMetadataKey);
 }
 
 ModelTypeStoreImpl::WriteBatchImpl::WriteBatchImpl() {
   leveldb_write_batch_.reset(new leveldb::WriteBatch());
 }
 
 ModelTypeStoreImpl::WriteBatchImpl::~WriteBatchImpl() {}
 
-}  // namespace syncer_v2
+}  // namespace syncer