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

sync/engine/get_commit_ids_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/get_commit_ids_command.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 25 matching lines @@
 GetCommitIdsCommand::~GetCommitIdsCommand() {}
 
 SyncerError GetCommitIdsCommand::ExecuteImpl(SyncSession* session) {
   // Gather the full set of unsynced items and store it in the session. They
   // are not in the correct order for commit.
   std::set<int64> ready_unsynced_set;
   syncable::Directory::UnsyncedMetaHandles all_unsynced_handles;
   GetUnsyncedEntries(session->write_transaction(),
                      &all_unsynced_handles);
 
-  syncer::ModelTypeSet encrypted_types;
+  ModelTypeSet encrypted_types;
   bool passphrase_missing = false;
   Cryptographer* cryptographer =
       session->context()->
       directory()->GetCryptographer(session->write_transaction());
   if (cryptographer) {
     encrypted_types = cryptographer->GetEncryptedTypes();
     passphrase_missing = cryptographer->has_pending_keys();
   };
 
-  const syncer::ModelTypeSet throttled_types =
+  const ModelTypeSet throttled_types =
        session->context()->throttled_data_type_tracker()->GetThrottledTypes();
   // We filter out all unready entries from the set of unsynced handles. This
   // new set of ready and unsynced items (which excludes throttled items as
   // well) is then what we use to determine what is a candidate for commit.
   FilterUnreadyEntries(session->write_transaction(),
                        throttled_types,
                        encrypted_types,
                        passphrase_missing,
                        all_unsynced_handles,
                        &ready_unsynced_set);
@@ skipping 28 matching lines @@
   return false;
 }
 
 // An entry is not considered ready for commit if any are true:
 // 1. It's in conflict.
 // 2. It requires encryption (either the type is encrypted but a passphrase
 //    is missing from the cryptographer, or the entry itself wasn't properly
 //    encrypted).
 // 3. It's type is currently throttled.
 // 4. It's a delete but has not been committed.
-bool IsEntryReadyForCommit(syncer::ModelTypeSet throttled_types,
-                           syncer::ModelTypeSet encrypted_types,
+bool IsEntryReadyForCommit(ModelTypeSet throttled_types,
+                           ModelTypeSet encrypted_types,
                            bool passphrase_missing,
                            const syncable::Entry& entry) {
   DCHECK(entry.Get(syncable::IS_UNSYNCED));
   if (IsEntryInConflict(entry))
     return false;
 
-  const syncer::ModelType type = entry.GetModelType();
+  const ModelType type = entry.GetModelType();
   // We special case the nigori node because even though it is considered an
   // "encrypted type", not all nigori node changes require valid encryption
   // (ex: sync_tabs).
-  if ((type != syncer::NIGORI) && encrypted_types.Has(type) &&
+  if ((type != NIGORI) && encrypted_types.Has(type) &&
       (passphrase_missing ||
        syncable::EntryNeedsEncryption(encrypted_types, entry))) {
     // This entry requires encryption but is not properly encrypted (possibly
     // due to the cryptographer not being initialized or the user hasn't
     // provided the most recent passphrase).
     DVLOG(1) << "Excluding entry from commit due to lack of encryption "
              << entry;
     return false;
   }
 
@@ skipping 24 matching lines @@
   }
 
   DVLOG(2) << "Entry is ready for commit: " << entry;
   return true;
 }
 
 }  // namespace
 
 void GetCommitIdsCommand::FilterUnreadyEntries(
     syncable::BaseTransaction* trans,
-    syncer::ModelTypeSet throttled_types,
-    syncer::ModelTypeSet encrypted_types,
+    ModelTypeSet throttled_types,
+    ModelTypeSet encrypted_types,
     bool passphrase_missing,
     const syncable::Directory::UnsyncedMetaHandles& unsynced_handles,
     std::set<int64>* ready_unsynced_set) {
   for (syncable::Directory::UnsyncedMetaHandles::const_iterator iter =
            unsynced_handles.begin(); iter != unsynced_handles.end(); ++iter) {
     syncable::Entry entry(trans, syncable::GET_BY_HANDLE, *iter);
     if (IsEntryReadyForCommit(throttled_types,
                               encrypted_types,
                               passphrase_missing,
                               entry)) {
@@ skipping 252 matching lines @@
   // delete trees.
 
   // Add moves and creates, and prepend their uncommitted parents.
   AddCreatesAndMoves(write_transaction, routes, ready_unsynced_set);
 
   // Add all deletes.
   AddDeletes(write_transaction, ready_unsynced_set);
 }
 
 }  // namespace syncer