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

sync/engine/verify_updates_command.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/engine/verify_updates_command.h"
 
 #include <string>
 
 #include "base/location.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_proto_util.h"
 #include "sync/syncable/write_transaction.h"
 
 namespace syncer {
 
 using syncable::GET_BY_ID;
-using syncer::ModelTypeSet;
 using syncable::SYNCER;
 using syncable::WriteTransaction;
 
 namespace {
 
 // This function attempts to determine whether or not this update is genuinely
 // new, or if it is a reflection of one of our own commits.
 //
 // There is a known inaccuracy in its implementation.  If this update ends up
 // being applied to a local item with a different ID, we will count the change
@@ skipping 43 matching lines @@
 VerifyUpdatesCommand::~VerifyUpdatesCommand() {}
 
 std::set<ModelSafeGroup> VerifyUpdatesCommand::GetGroupsToChange(
     const sessions::SyncSession& session) const {
   std::set<ModelSafeGroup> groups_with_updates;
 
   const sync_pb::GetUpdatesResponse& updates =
       session.status_controller().updates_response().get_updates();
   for (int i = 0; i < updates.entries().size(); i++) {
     groups_with_updates.insert(
-        GetGroupForModelType(syncer::GetModelType(updates.entries(i)),
+        GetGroupForModelType(GetModelType(updates.entries(i)),
                              session.routing_info()));
   }
 
   return groups_with_updates;
 }
 
 SyncerError VerifyUpdatesCommand::ModelChangingExecuteImpl(
     sessions::SyncSession* session) {
   DVLOG(1) << "Beginning Update Verification";
   syncable::Directory* dir = session->context()->directory();
   WriteTransaction trans(FROM_HERE, SYNCER, dir);
   sessions::StatusController* status = session->mutable_status_controller();
   const sync_pb::GetUpdatesResponse& updates =
       status->updates_response().get_updates();
   int update_count = updates.entries().size();
 
-  ModelTypeSet requested_types = syncer::GetRoutingInfoTypes(
+  ModelTypeSet requested_types = GetRoutingInfoTypes(
       session->routing_info());
 
   DVLOG(1) << update_count << " entries to verify";
   for (int i = 0; i < update_count; i++) {
     const sync_pb::SyncEntity& update = updates.entries(i);
     ModelSafeGroup g = GetGroupForModelType(GetModelType(update),
                                             session->routing_info());
     if (g != status->group_restriction())
       continue;
 
@@ skipping 13 matching lines @@
 
 VerifyUpdatesCommand::VerifyUpdateResult VerifyUpdatesCommand::VerifyUpdate(
     syncable::WriteTransaction* trans, const sync_pb::SyncEntity& entry,
     const ModelTypeSet& requested_types,
     const ModelSafeRoutingInfo& routes) {
   syncable::Id id = SyncableIdFromProto(entry.id_string());
   VerifyUpdateResult result = {VERIFY_FAIL, GROUP_PASSIVE};
 
   const bool deleted = entry.has_deleted() && entry.deleted();
   const bool is_directory = IsFolder(entry);
-  const syncer::ModelType model_type = GetModelType(entry);
+  const ModelType model_type = GetModelType(entry);
 
   if (!id.ServerKnows()) {
     LOG(ERROR) << "Illegal negative id in received updates";
     return result;
   }
   {
     const std::string name = SyncerProtoUtil::NameFromSyncEntity(entry);
     if (name.empty() && !deleted) {
       LOG(ERROR) << "Zero length name in non-deleted update";
       return result;
     }
   }
 
   syncable::MutableEntry same_id(trans, GET_BY_ID, id);
   result.value = VerifyNewEntry(entry, &same_id, deleted);
 
-  syncer::ModelType placement_type = !deleted ? GetModelType(entry)
-      : same_id.good() ? same_id.GetModelType() : syncer::UNSPECIFIED;
+  ModelType placement_type = !deleted ? GetModelType(entry)
+      : same_id.good() ? same_id.GetModelType() : UNSPECIFIED;
   result.placement = GetGroupForModelType(placement_type, routes);
 
   if (VERIFY_UNDECIDED == result.value) {
     result.value = VerifyTagConsistency(entry, same_id);
   }
 
   if (VERIFY_UNDECIDED == result.value) {
     if (deleted) {
       // For deletes the server could send tombostones for items that
       // the client did not request. If so ignore those items.
@@ skipping 13 matching lines @@
         deleted, is_directory, model_type);
   }
 
   if (VERIFY_UNDECIDED == result.value)
     result.value = VERIFY_SUCCESS;  // No news is good news.
 
   return result;  // This might be VERIFY_SUCCESS as well
 }
 
 }  // namespace syncer