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

sync/test/engine/mock_connection_manager.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.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
 #include "sync/test/engine/mock_connection_manager.h"
 
 #include <map>
 
@@ skipping 58 matching lines @@
 }
 
 void MockConnectionManager::SetMidCommitObserver(
     MockConnectionManager::MidCommitObserver* observer) {
     mid_commit_observer_ = observer;
 }
 
 bool MockConnectionManager::PostBufferToPath(PostBufferParams* params,
     const string& path,
     const string& auth_token,
-    syncer::ScopedServerStatusWatcher* watcher) {
+    ScopedServerStatusWatcher* watcher) {
   ClientToServerMessage post;
   CHECK(post.ParseFromString(params->buffer_in));
   CHECK(post.has_protocol_version());
   last_request_.CopyFrom(post);
   client_stuck_ = post.sync_problem_detected();
   sync_pb::ClientToServerResponse response;
   response.Clear();
 
   if (directory_) {
     // If the Directory's locked when we do this, it's a problem as in normal
@@ skipping 148 matching lines @@
   ent->set_folder(is_dir);
   return ent;
 }
 
 sync_pb::SyncEntity* MockConnectionManager::SetNigori(
     int id, int64 version,int64 sync_ts,
     const sync_pb::EntitySpecifics& specifics) {
   sync_pb::SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(TestIdFactory::FromNumber(id).GetServerId());
   ent->set_parent_id_string(TestIdFactory::FromNumber(0).GetServerId());
-  ent->set_server_defined_unique_tag(syncer::ModelTypeToRootTag(
-      syncer::NIGORI));
+  ent->set_server_defined_unique_tag(ModelTypeToRootTag(NIGORI));
   ent->set_name("Nigori");
   ent->set_non_unique_name("Nigori");
   ent->set_version(version);
   ent->set_sync_timestamp(sync_ts);
   ent->set_mtime(sync_ts);
   ent->set_ctime(1);
   ent->set_position_in_parent(0);
   ent->set_folder(false);
   ent->mutable_specifics()->CopyFrom(specifics);
   return ent;
@@ skipping 135 matching lines @@
   EXPECT_FALSE(gu.has_requested_types());
 
   if (fail_non_periodic_get_updates_) {
     EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::PERIODIC,
               gu.caller_info().source());
   }
 
   // Verify that the GetUpdates filter sent by the Syncer matches the test
   // expectation.
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
-    ModelType model_type = syncer::ModelTypeFromInt(i);
+    ModelType model_type = ModelTypeFromInt(i);
     sync_pb::DataTypeProgressMarker const* progress_marker =
         GetProgressMarkerForType(gu.from_progress_marker(), model_type);
     EXPECT_EQ(expected_filter_.Has(model_type), (progress_marker != NULL))
         << "Syncer requested_types differs from test expectation.";
     if (progress_marker) {
       EXPECT_EQ((expected_payloads_.count(model_type) > 0 ?
                  expected_payloads_[model_type] :
                  std::string()),
                 progress_marker->notification_hint());
     }
   }
 
   // Verify that the items we're about to send back to the client are of
   // the types requested by the client.  If this fails, it probably indicates
   // a test bug.
   EXPECT_TRUE(gu.fetch_folders());
   EXPECT_FALSE(gu.has_requested_types());
   if (update_queue_.empty()) {
     GetUpdateResponse();
   }
   sync_pb::GetUpdatesResponse* updates = &update_queue_.front();
   for (int i = 0; i < updates->entries_size(); ++i) {
     if (!updates->entries(i).deleted()) {
-      ModelType entry_type = syncer::GetModelType(updates->entries(i));
+      ModelType entry_type = GetModelType(updates->entries(i));
       EXPECT_TRUE(
         IsModelTypePresentInSpecifics(gu.from_progress_marker(), entry_type))
           << "Syncer did not request updates being provided by the test.";
     }
   }
 
   response->mutable_get_updates()->CopyFrom(*updates);
 
   // Set appropriate progress markers, overriding the value squirreled
   // away by ApplyToken().
@@ skipping 108 matching lines @@
 }
 
 const CommitResponse& MockConnectionManager::last_commit_response() const {
   EXPECT_TRUE(!commit_responses_.empty());
   return *commit_responses_.back();
 }
 
 bool MockConnectionManager::IsModelTypePresentInSpecifics(
     const google::protobuf::RepeatedPtrField<
         sync_pb::DataTypeProgressMarker>& filter,
-    syncer::ModelType value) {
-  int data_type_id = syncer::GetSpecificsFieldNumberFromModelType(value);
+    ModelType value) {
+  int data_type_id = GetSpecificsFieldNumberFromModelType(value);
   for (int i = 0; i < filter.size(); ++i) {
     if (filter.Get(i).data_type_id() == data_type_id) {
       return true;
     }
   }
   return false;
 }
 
 sync_pb::DataTypeProgressMarker const*
     MockConnectionManager::GetProgressMarkerForType(
         const google::protobuf::RepeatedPtrField<
             sync_pb::DataTypeProgressMarker>& filter,
-        syncer::ModelType value) {
-  int data_type_id = syncer::GetSpecificsFieldNumberFromModelType(value);
+        ModelType value) {
+  int data_type_id = GetSpecificsFieldNumberFromModelType(value);
   for (int i = 0; i < filter.size(); ++i) {
     if (filter.Get(i).data_type_id() == data_type_id) {
       return &(filter.Get(i));
     }
   }
   return NULL;
 }
 
 void MockConnectionManager::SetServerReachable() {
   server_reachable_ = true;
 }
 
 void MockConnectionManager::SetServerNotReachable() {
   server_reachable_ = false;
 }
 
 void MockConnectionManager::UpdateConnectionStatus() {
   if (!server_reachable_) {
     server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
   } else {
     server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   }
 }
 
 }  // namespace syncer