[Sync] Remove unneeded 'using syncer::' lines and 'syncer::' scopings

sync/sessions/sync_session_unittest.cc

 // Copyright (c) 2012 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/sync_session.h"
 
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ skipping 35 matching lines @@
 
     GetModelSafeRoutingInfo(&routing_info);
     GetWorkers(&workers);
 
     context_.reset(
         new SyncSessionContext(
             NULL, NULL, routing_info, workers, &extensions_activity_monitor_,
             throttled_data_type_tracker_.get(),
             std::vector<SyncEngineEventListener*>(), NULL, NULL));
     routes_.clear();
-    routes_[syncer::BOOKMARKS] = GROUP_UI;
-    routes_[syncer::AUTOFILL] = GROUP_DB;
+    routes_[BOOKMARKS] = GROUP_UI;
+    routes_[AUTOFILL] = GROUP_DB;
     scoped_refptr<ModelSafeWorker> passive_worker(
         new FakeModelWorker(GROUP_PASSIVE));
     scoped_refptr<ModelSafeWorker> ui_worker(
         new FakeModelWorker(GROUP_UI));
     scoped_refptr<ModelSafeWorker> db_worker(
         new FakeModelWorker(GROUP_DB));
     workers_.clear();
     workers_.push_back(passive_worker);
     workers_.push_back(ui_worker);
     workers_.push_back(db_worker);
@@ skipping 43 matching lines @@
     *out = routes_;
   }
 
   StatusController* status() { return session_->mutable_status_controller(); }
  protected:
   void FailControllerInvocationIfDisabled(const std::string& msg) {
     if (!controller_invocations_allowed_)
       FAIL() << msg;
   }
 
-  syncer::ModelTypeSet ParamsMeaningAllEnabledTypes() {
-    syncer::ModelTypeSet request_params(syncer::BOOKMARKS, syncer::AUTOFILL);
+  ModelTypeSet ParamsMeaningAllEnabledTypes() {
+    ModelTypeSet request_params(BOOKMARKS, AUTOFILL);
     return request_params;
   }
 
-  syncer::ModelTypeSet ParamsMeaningJustOneEnabledType() {
-    return syncer::ModelTypeSet(syncer::AUTOFILL);
+  ModelTypeSet ParamsMeaningJustOneEnabledType() {
+    return ModelTypeSet(AUTOFILL);
   }
 
   MessageLoop message_loop_;
   bool controller_invocations_allowed_;
   scoped_ptr<SyncSession> session_;
   scoped_ptr<SyncSessionContext> context_;
   std::vector<scoped_refptr<ModelSafeWorker> > workers_;
   ModelSafeRoutingInfo routes_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
   scoped_ptr<ThrottledDataTypeTracker> throttled_data_type_tracker_;
@@ skipping 121 matching lines @@
   session_->PrepareForAnotherSyncCycle();
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION,
             session_->source().updates_source);
   EXPECT_FALSE(status()->conflicts_resolved());
   EXPECT_FALSE(session_->HasMoreToSync());
 }
 
 TEST_F(SyncSessionTest, Coalesce) {
   std::vector<ModelSafeWorker*> workers_one, workers_two;
   ModelSafeRoutingInfo routes_one, routes_two;
-  syncer::ModelTypePayloadMap one_type =
-      syncer::ModelTypePayloadMapFromEnumSet(
+  ModelTypePayloadMap one_type =
+      ModelTypePayloadMapFromEnumSet(
           ParamsMeaningJustOneEnabledType(),
           std::string());
-  syncer::ModelTypePayloadMap all_types =
-      syncer::ModelTypePayloadMapFromEnumSet(
+  ModelTypePayloadMap all_types =
+      ModelTypePayloadMapFromEnumSet(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_one(sync_pb::GetUpdatesCallerInfo::PERIODIC, one_type);
   SyncSourceInfo source_two(sync_pb::GetUpdatesCallerInfo::LOCAL, all_types);
 
   scoped_refptr<ModelSafeWorker> passive_worker(
       new FakeModelWorker(GROUP_PASSIVE));
   scoped_refptr<ModelSafeWorker> db_worker(new FakeModelWorker(GROUP_DB));
   scoped_refptr<ModelSafeWorker> ui_worker(new FakeModelWorker(GROUP_UI));
   workers_one.push_back(passive_worker);
   workers_one.push_back(db_worker);
   workers_two.push_back(passive_worker);
   workers_two.push_back(db_worker);
   workers_two.push_back(ui_worker);
-  routes_one[syncer::AUTOFILL] = GROUP_DB;
-  routes_two[syncer::AUTOFILL] = GROUP_DB;
-  routes_two[syncer::BOOKMARKS] = GROUP_UI;
+  routes_one[AUTOFILL] = GROUP_DB;
+  routes_two[AUTOFILL] = GROUP_DB;
+  routes_two[BOOKMARKS] = GROUP_UI;
   SyncSession one(context_.get(), this, source_one, routes_one, workers_one);
   SyncSession two(context_.get(), this, source_two, routes_two, workers_two);
 
   std::set<ModelSafeGroup> expected_enabled_groups_one;
   expected_enabled_groups_one.insert(GROUP_PASSIVE);
   expected_enabled_groups_one.insert(GROUP_DB);
 
   std::set<ModelSafeGroup> expected_enabled_groups_two;
   expected_enabled_groups_two.insert(GROUP_PASSIVE);
   expected_enabled_groups_two.insert(GROUP_DB);
@@ skipping 14 matching lines @@
   std::vector<ModelSafeWorker*>::const_iterator it_ui =
       std::find(one.workers().begin(), one.workers().end(), ui_worker);
   EXPECT_NE(it_db, one.workers().end());
   EXPECT_NE(it_ui, one.workers().end());
   EXPECT_EQ(routes_two, one.routing_info());
 }
 
 TEST_F(SyncSessionTest, RebaseRoutingInfoWithLatestRemoveOneType) {
   std::vector<ModelSafeWorker*> workers_one, workers_two;
   ModelSafeRoutingInfo routes_one, routes_two;
-  syncer::ModelTypePayloadMap one_type =
-      syncer::ModelTypePayloadMapFromEnumSet(
+  ModelTypePayloadMap one_type =
+      ModelTypePayloadMapFromEnumSet(
           ParamsMeaningJustOneEnabledType(),
           std::string());
-  syncer::ModelTypePayloadMap all_types =
-      syncer::ModelTypePayloadMapFromEnumSet(
+  ModelTypePayloadMap all_types =
+      ModelTypePayloadMapFromEnumSet(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_one(sync_pb::GetUpdatesCallerInfo::PERIODIC, one_type);
   SyncSourceInfo source_two(sync_pb::GetUpdatesCallerInfo::LOCAL, all_types);
 
   scoped_refptr<ModelSafeWorker> passive_worker(
       new FakeModelWorker(GROUP_PASSIVE));
   scoped_refptr<ModelSafeWorker> db_worker(new FakeModelWorker(GROUP_DB));
   scoped_refptr<ModelSafeWorker> ui_worker(new FakeModelWorker(GROUP_UI));
   workers_one.push_back(passive_worker);
   workers_one.push_back(db_worker);
   workers_two.push_back(passive_worker);
   workers_two.push_back(db_worker);
   workers_two.push_back(ui_worker);
-  routes_one[syncer::AUTOFILL] = GROUP_DB;
-  routes_two[syncer::AUTOFILL] = GROUP_DB;
-  routes_two[syncer::BOOKMARKS] = GROUP_UI;
+  routes_one[AUTOFILL] = GROUP_DB;
+  routes_two[AUTOFILL] = GROUP_DB;
+  routes_two[BOOKMARKS] = GROUP_UI;
   SyncSession one(context_.get(), this, source_one, routes_one, workers_one);
   SyncSession two(context_.get(), this, source_two, routes_two, workers_two);
 
   std::set<ModelSafeGroup> expected_enabled_groups_one;
   expected_enabled_groups_one.insert(GROUP_PASSIVE);
   expected_enabled_groups_one.insert(GROUP_DB);
 
   std::set<ModelSafeGroup> expected_enabled_groups_two;
   expected_enabled_groups_two.insert(GROUP_PASSIVE);
   expected_enabled_groups_two.insert(GROUP_DB);
@@ skipping 18 matching lines @@
   std::vector<ModelSafeWorker*>::const_iterator it_db =
       std::find(two.workers().begin(), two.workers().end(), db_worker);
   std::vector<ModelSafeWorker*>::const_iterator it_ui =
       std::find(two.workers().begin(), two.workers().end(), ui_worker);
   EXPECT_NE(it_db, two.workers().end());
   EXPECT_EQ(it_ui, two.workers().end());
   EXPECT_EQ(two.workers().size(), 2U);
 
   // Make sure the model safe routing info is reduced to one type.
   ModelSafeRoutingInfo::const_iterator it =
-      two.routing_info().find(syncer::AUTOFILL);
+      two.routing_info().find(AUTOFILL);
   // Note that attempting to use EXPECT_NE would fail for an Android build due
   // to seeming incompatibility with gtest and stlport.
   EXPECT_TRUE(it != two.routing_info().end());
   EXPECT_EQ(it->second, GROUP_DB);
   EXPECT_EQ(two.routing_info().size(), 1U);
 }
 
 TEST_F(SyncSessionTest, RebaseRoutingInfoWithLatestWithSameType) {
   std::vector<ModelSafeWorker*> workers_first, workers_second;
   ModelSafeRoutingInfo routes_first, routes_second;
-  syncer::ModelTypePayloadMap all_types =
-      syncer::ModelTypePayloadMapFromEnumSet(
+  ModelTypePayloadMap all_types =
+      ModelTypePayloadMapFromEnumSet(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_first(sync_pb::GetUpdatesCallerInfo::PERIODIC,
       all_types);
   SyncSourceInfo source_second(sync_pb::GetUpdatesCallerInfo::LOCAL,
       all_types);
 
   scoped_refptr<ModelSafeWorker> passive_worker(
       new FakeModelWorker(GROUP_PASSIVE));
   scoped_refptr<FakeModelWorker> db_worker(new FakeModelWorker(GROUP_DB));
   scoped_refptr<FakeModelWorker> ui_worker(new FakeModelWorker(GROUP_UI));
   workers_first.push_back(passive_worker);
   workers_first.push_back(db_worker);
   workers_first.push_back(ui_worker);
   workers_second.push_back(passive_worker);
   workers_second.push_back(db_worker);
   workers_second.push_back(ui_worker);
-  routes_first[syncer::AUTOFILL] = GROUP_DB;
-  routes_first[syncer::BOOKMARKS] = GROUP_UI;
-  routes_second[syncer::AUTOFILL] = GROUP_DB;
-  routes_second[syncer::BOOKMARKS] = GROUP_UI;
+  routes_first[AUTOFILL] = GROUP_DB;
+  routes_first[BOOKMARKS] = GROUP_UI;
+  routes_second[AUTOFILL] = GROUP_DB;
+  routes_second[BOOKMARKS] = GROUP_UI;
   SyncSession first(context_.get(), this, source_first, routes_first,
       workers_first);
   SyncSession second(context_.get(), this, source_second, routes_second,
       workers_second);
 
   std::set<ModelSafeGroup> expected_enabled_groups;
   expected_enabled_groups.insert(GROUP_PASSIVE);
   expected_enabled_groups.insert(GROUP_DB);
   expected_enabled_groups.insert(GROUP_UI);
 
@@ skipping 20 matching lines @@
       std::find(second.workers().begin(), second.workers().end(), db_worker);
   std::vector<ModelSafeWorker*>::const_iterator it_ui =
       std::find(second.workers().begin(), second.workers().end(), ui_worker);
   EXPECT_NE(it_passive, second.workers().end());
   EXPECT_NE(it_db, second.workers().end());
   EXPECT_NE(it_ui, second.workers().end());
   EXPECT_EQ(second.workers().size(), 3U);
 
   // Make sure the model safe routing info is reduced to first type.
   ModelSafeRoutingInfo::const_iterator it1 =
-      second.routing_info().find(syncer::AUTOFILL);
+      second.routing_info().find(AUTOFILL);
   ModelSafeRoutingInfo::const_iterator it2 =
-      second.routing_info().find(syncer::BOOKMARKS);
+      second.routing_info().find(BOOKMARKS);
 
   // Note that attempting to use EXPECT_NE would fail for an Android build due
   // to seeming incompatibility with gtest and stlport.
   EXPECT_TRUE(it1 != second.routing_info().end());
   EXPECT_EQ(it1->second, GROUP_DB);
 
   // Note that attempting to use EXPECT_NE would fail for an Android build due
   // to seeming incompatibility with gtest and stlport.
   EXPECT_TRUE(it2 != second.routing_info().end());
   EXPECT_EQ(it2->second, GROUP_UI);
   EXPECT_EQ(second.routing_info().size(), 2U);
 }
 
 
 TEST_F(SyncSessionTest, MakeTypePayloadMapFromBitSet) {
-  syncer::ModelTypeSet types;
+  ModelTypeSet types;
   std::string payload = "test";
-  syncer::ModelTypePayloadMap types_with_payloads =
-      syncer::ModelTypePayloadMapFromEnumSet(types, payload);
+  ModelTypePayloadMap types_with_payloads =
+      ModelTypePayloadMapFromEnumSet(types, payload);
   EXPECT_TRUE(types_with_payloads.empty());
 
-  types.Put(syncer::BOOKMARKS);
-  types.Put(syncer::PASSWORDS);
-  types.Put(syncer::AUTOFILL);
+  types.Put(BOOKMARKS);
+  types.Put(PASSWORDS);
+  types.Put(AUTOFILL);
   payload = "test2";
-  types_with_payloads =
-      syncer::ModelTypePayloadMapFromEnumSet(types, payload);
+  types_with_payloads = ModelTypePayloadMapFromEnumSet(types, payload);
 
   ASSERT_EQ(3U, types_with_payloads.size());
-  EXPECT_EQ(types_with_payloads[syncer::BOOKMARKS], payload);
-  EXPECT_EQ(types_with_payloads[syncer::PASSWORDS], payload);
-  EXPECT_EQ(types_with_payloads[syncer::AUTOFILL], payload);
+  EXPECT_EQ(types_with_payloads[BOOKMARKS], payload);
+  EXPECT_EQ(types_with_payloads[PASSWORDS], payload);
+  EXPECT_EQ(types_with_payloads[AUTOFILL], payload);
 }
 
 }  // namespace
 }  // namespace sessions
 }  // namespace syncer