Revert of [Sync] Move //components/sync to the syncer namespace. (patchset #5 id:40001 of https://co

components/sync/api/model_type_service_unittest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "components/sync/api/data_type_error_handler_mock.h"
 #include "components/sync/api/fake_model_type_change_processor.h"
 #include "components/sync/api/stub_model_type_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace syncer {
+namespace syncer_v2 {
 
 // A mock MTCP that lets us know when DisableSync is called.
 class MockModelTypeChangeProcessor : public FakeModelTypeChangeProcessor {
  public:
   explicit MockModelTypeChangeProcessor(const base::Closure& disabled_callback)
       : disabled_callback_(disabled_callback) {}
   ~MockModelTypeChangeProcessor() override {}
 
   void DisableSync() override { disabled_callback_.Run(); }
 
@@ skipping 16 matching lines @@
   }
 
   bool on_processor_set_called() const { return on_processor_set_called_; }
   void clear_on_processor_set_called() { on_processor_set_called_ = false; }
   bool processor_disable_sync_called() const {
     return processor_disable_sync_called_;
   }
 
  private:
   std::unique_ptr<ModelTypeChangeProcessor> CreateProcessor(
-      ModelType type,
+      syncer::ModelType type,
       ModelTypeService* service) {
     return base::MakeUnique<MockModelTypeChangeProcessor>(base::Bind(
         &MockModelTypeService::OnProcessorDisableSync, base::Unretained(this)));
   }
 
   void OnChangeProcessorSet() override { on_processor_set_called_ = true; }
 
   void OnProcessorDisableSync() { processor_disable_sync_called_ = true; }
 
   bool on_processor_set_called_ = false;
   bool processor_disable_sync_called_ = false;
 };
 
 class ModelTypeServiceTest : public ::testing::Test {
  public:
   ModelTypeServiceTest() {}
   ~ModelTypeServiceTest() override {}
 
   void OnSyncStarting() {
     service_.OnSyncStarting(
-        base::MakeUnique<DataTypeErrorHandlerMock>(),
+        base::MakeUnique<syncer::DataTypeErrorHandlerMock>(),
         base::Bind(&ModelTypeServiceTest::OnProcessorStarted,
                    base::Unretained(this)));
   }
 
   bool start_callback_called() const { return start_callback_called_; }
   MockModelTypeService* service() { return &service_; }
 
  private:
   void OnProcessorStarted(
-      SyncError error,
+      syncer::SyncError error,
       std::unique_ptr<ActivationContext> activation_context) {
     start_callback_called_ = true;
   }
 
   bool start_callback_called_;
   MockModelTypeService service_;
 };
 
 // CreateChangeProcessor should construct a processor and call
 // OnChangeProcessorSet if and only if one doesn't already exist.
@@ skipping 52 matching lines @@
   EXPECT_EQ(ConflictResolution::USE_REMOTE,
             service()->ResolveConflict(local_data, remote_data).type());
 
   local_data.specifics.clear_preference();
   EXPECT_TRUE(local_data.is_deleted());
   EXPECT_FALSE(remote_data.is_deleted());
   EXPECT_EQ(ConflictResolution::USE_REMOTE,
             service()->ResolveConflict(local_data, remote_data).type());
 }
 
-}  // namespace syncer
+}  // namespace syncer_v2