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

components/sync/engine_impl/model_type_registry_unittest.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 "components/sync/engine_impl/model_type_registry.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/deferred_sequenced_task_runner.h"
@@ skipping 21 matching lines @@
 
   ModelTypeRegistry* registry();
 
   static sync_pb::DataTypeState MakeInitialDataTypeState(ModelType type) {
     sync_pb::DataTypeState state;
     state.mutable_progress_marker()->set_data_type_id(
         GetSpecificsFieldNumberFromModelType(type));
     return state;
   }
 
-  static std::unique_ptr<syncer_v2::ActivationContext> MakeActivationContext(
+  static std::unique_ptr<ActivationContext> MakeActivationContext(
       const sync_pb::DataTypeState& data_type_state,
-      std::unique_ptr<syncer_v2::ModelTypeProcessor> type_processor) {
-    std::unique_ptr<syncer_v2::ActivationContext> context =
-        base::WrapUnique(new syncer_v2::ActivationContext);
+      std::unique_ptr<ModelTypeProcessor> type_processor) {
+    std::unique_ptr<ActivationContext> context =
+        base::WrapUnique(new ActivationContext);
     context->data_type_state = data_type_state;
     context->type_processor = std::move(type_processor);
     return context;
   }
 
   void MarkInitialSyncEndedForDirectoryType(ModelType type) {
     syncable::ModelNeutralWriteTransaction trans(FROM_HERE, syncable::SYNCER,
                                                  directory());
     syncable::ModelNeutralMutableEntry entry(
         &trans, syncable::CREATE_NEW_TYPE_ROOT, type);
@@ skipping 118 matching lines @@
   ModelSafeRoutingInfo routing_info2;
   registry()->SetEnabledDirectoryTypes(routing_info2);
 
   registry()->SetEnabledDirectoryTypes(routing_info1);
 }
 
 TEST_F(ModelTypeRegistryTest, NonBlockingTypes) {
   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 
   registry()->ConnectType(
-      syncer::THEMES,
-      MakeActivationContext(
-          MakeInitialDataTypeState(THEMES),
-          base::MakeUnique<syncer_v2::FakeModelTypeProcessor>()));
-  EXPECT_EQ(ModelTypeSet(syncer::THEMES), registry()->GetEnabledTypes());
+      THEMES,
+      MakeActivationContext(MakeInitialDataTypeState(THEMES),
+                            base::MakeUnique<FakeModelTypeProcessor>()));
+  EXPECT_EQ(ModelTypeSet(THEMES), registry()->GetEnabledTypes());
 
   registry()->ConnectType(
-      syncer::SESSIONS,
-      MakeActivationContext(
-          MakeInitialDataTypeState(SESSIONS),
-          base::MakeUnique<syncer_v2::FakeModelTypeProcessor>()));
-  EXPECT_EQ(ModelTypeSet(syncer::THEMES, syncer::SESSIONS),
-            registry()->GetEnabledTypes());
+      SESSIONS,
+      MakeActivationContext(MakeInitialDataTypeState(SESSIONS),
+                            base::MakeUnique<FakeModelTypeProcessor>()));
+  EXPECT_EQ(ModelTypeSet(THEMES, SESSIONS), registry()->GetEnabledTypes());
 
-  registry()->DisconnectType(syncer::THEMES);
-  EXPECT_EQ(ModelTypeSet(syncer::SESSIONS), registry()->GetEnabledTypes());
+  registry()->DisconnectType(THEMES);
+  EXPECT_EQ(ModelTypeSet(SESSIONS), registry()->GetEnabledTypes());
 
   // Allow ModelTypeRegistry destruction to delete the
   // Sessions' ModelTypeSyncWorker.
 }
 
 TEST_F(ModelTypeRegistryTest, NonBlockingTypesWithDirectoryTypes) {
   ModelSafeRoutingInfo routing_info1;
   routing_info1.insert(std::make_pair(NIGORI, GROUP_PASSIVE));
   routing_info1.insert(std::make_pair(BOOKMARKS, GROUP_UI));
   routing_info1.insert(std::make_pair(AUTOFILL, GROUP_DB));
   routing_info1.insert(std::make_pair(THEMES, GROUP_NON_BLOCKING));
   routing_info1.insert(std::make_pair(SESSIONS, GROUP_NON_BLOCKING));
 
   ModelTypeSet directory_types(NIGORI, BOOKMARKS, AUTOFILL);
 
   ModelTypeSet current_types;
   EXPECT_TRUE(registry()->GetEnabledTypes().Empty());
 
   // Add the themes non-blocking type.
   registry()->ConnectType(
-      syncer::THEMES,
-      MakeActivationContext(
-          MakeInitialDataTypeState(THEMES),
-          base::MakeUnique<syncer_v2::FakeModelTypeProcessor>()));
-  current_types.Put(syncer::THEMES);
+      THEMES,
+      MakeActivationContext(MakeInitialDataTypeState(THEMES),
+                            base::MakeUnique<FakeModelTypeProcessor>()));
+  current_types.Put(THEMES);
   EXPECT_EQ(current_types, registry()->GetEnabledTypes());
 
   // Add some directory types.
   registry()->SetEnabledDirectoryTypes(routing_info1);
   current_types.PutAll(directory_types);
   EXPECT_EQ(current_types, registry()->GetEnabledTypes());
 
   // Add sessions non-blocking type.
   registry()->ConnectType(
-      syncer::SESSIONS,
-      MakeActivationContext(
-          MakeInitialDataTypeState(SESSIONS),
-          base::MakeUnique<syncer_v2::FakeModelTypeProcessor>()));
-  current_types.Put(syncer::SESSIONS);
+      SESSIONS,
+      MakeActivationContext(MakeInitialDataTypeState(SESSIONS),
+                            base::MakeUnique<FakeModelTypeProcessor>()));
+  current_types.Put(SESSIONS);
   EXPECT_EQ(current_types, registry()->GetEnabledTypes());
 
   // Remove themes non-blocking type.
-  registry()->DisconnectType(syncer::THEMES);
-  current_types.Remove(syncer::THEMES);
+  registry()->DisconnectType(THEMES);
+  current_types.Remove(THEMES);
   EXPECT_EQ(current_types, registry()->GetEnabledTypes());
 
   // Clear all directory types.
   ModelSafeRoutingInfo routing_info2;
   registry()->SetEnabledDirectoryTypes(routing_info2);
   current_types.RemoveAll(directory_types);
   EXPECT_EQ(current_types, registry()->GetEnabledTypes());
 }
 
 // Tests correct result returned from GetInitialSyncEndedTypes.
 TEST_F(ModelTypeRegistryTest, GetInitialSyncEndedTypes) {
   ModelSafeRoutingInfo routing_info;
   // Add two directory and two non-blocking types.
   routing_info.insert(std::make_pair(AUTOFILL, GROUP_PASSIVE));
   routing_info.insert(std::make_pair(BOOKMARKS, GROUP_PASSIVE));
   routing_info.insert(std::make_pair(THEMES, GROUP_NON_BLOCKING));
   routing_info.insert(std::make_pair(SESSIONS, GROUP_NON_BLOCKING));
   registry()->SetEnabledDirectoryTypes(routing_info);
 
   // Only Autofill and Themes types finished initial sync.
   MarkInitialSyncEndedForDirectoryType(AUTOFILL);
 
   sync_pb::DataTypeState data_type_state = MakeInitialDataTypeState(THEMES);
   data_type_state.set_initial_sync_done(true);
   registry()->ConnectType(
-      syncer::THEMES,
-      MakeActivationContext(
-          data_type_state,
-          base::WrapUnique(new syncer_v2::FakeModelTypeProcessor())));
+      THEMES,
+      MakeActivationContext(data_type_state,
+                            base::WrapUnique(new FakeModelTypeProcessor())));
 
   EXPECT_EQ(ModelTypeSet(AUTOFILL, THEMES),
             registry()->GetInitialSyncEndedTypes());
 }
 
 }  // namespace syncer