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

sync/syncable/nigori_util.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/syncable/nigori_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_util.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/util/cryptographer.h"
 
 namespace syncer {
 namespace syncable {
 
 bool ProcessUnsyncedChangesForEncryption(
     WriteTransaction* const trans,
-    syncer::Cryptographer* cryptographer) {
+    Cryptographer* cryptographer) {
   DCHECK(cryptographer->is_ready());
   // Get list of all datatypes with unsynced changes. It's possible that our
   // local changes need to be encrypted if encryption for that datatype was
   // just turned on (and vice versa).
   // Note: we do not attempt to re-encrypt data with a new key here as key
   // changes in this code path are likely due to consistency issues (we have
   // to be updated to a key we already have, e.g. an old key).
   std::vector<int64> handles;
   GetUnsyncedEntries(trans, &handles);
   for (size_t i = 0; i < handles.size(); ++i) {
@@ skipping 27 matching lines @@
     if (EntryNeedsEncryption(encrypted_types, entry))
       return false;
   }
   return true;
 }
 
 bool EntryNeedsEncryption(ModelTypeSet encrypted_types,
                           const Entry& entry) {
   if (!entry.Get(UNIQUE_SERVER_TAG).empty())
     return false;  // We don't encrypt unique server nodes.
-  syncer::ModelType type = entry.GetModelType();
+  ModelType type = entry.GetModelType();
   if (type == PASSWORDS || type == NIGORI)
     return false;
   // Checking NON_UNIQUE_NAME is not necessary for the correctness of encrypting
   // the data, nor for determining if data is encrypted. We simply ensure it has
   // been overwritten to avoid any possible leaks of sensitive data.
   return SpecificsNeedsEncryption(encrypted_types, entry.Get(SPECIFICS)) ||
          (encrypted_types.Has(type) &&
           entry.Get(NON_UNIQUE_NAME) != kEncryptedString);
 }
 
 bool SpecificsNeedsEncryption(ModelTypeSet encrypted_types,
                               const sync_pb::EntitySpecifics& specifics) {
   const ModelType type = GetModelTypeFromSpecifics(specifics);
   if (type == PASSWORDS || type == NIGORI)
     return false;  // These types have their own encryption schemes.
   if (!encrypted_types.Has(type))
     return false;  // This type does not require encryption
   return !specifics.has_encrypted();
 }
 
 // Mainly for testing.
 bool VerifyDataTypeEncryptionForTest(
     BaseTransaction* const trans,
-    syncer::Cryptographer* cryptographer,
+    Cryptographer* cryptographer,
     ModelType type,
     bool is_encrypted) {
   if (type == PASSWORDS || type == NIGORI) {
     NOTREACHED();
     return true;
   }
   std::string type_tag = ModelTypeToRootTag(type);
   Entry type_root(trans, GET_BY_SERVER_TAG, type_tag);
   if (!type_root.good()) {
     NOTREACHED();
@@ skipping 43 matching lines @@
           return false;
       }
     }
     // Push the successor.
     to_visit.push(child.Get(NEXT_ID));
   }
   return true;
 }
 
 bool UpdateEntryWithEncryption(
-    syncer::Cryptographer* cryptographer,
+    Cryptographer* cryptographer,
     const sync_pb::EntitySpecifics& new_specifics,
     syncable::MutableEntry* entry) {
-  syncer::ModelType type = syncer::GetModelTypeFromSpecifics(new_specifics);
-  DCHECK_GE(type, syncer::FIRST_REAL_MODEL_TYPE);
+  ModelType type = GetModelTypeFromSpecifics(new_specifics);
+  DCHECK_GE(type, FIRST_REAL_MODEL_TYPE);
   const sync_pb::EntitySpecifics& old_specifics = entry->Get(SPECIFICS);
-  const syncer::ModelTypeSet encrypted_types =
-      cryptographer->GetEncryptedTypes();
+  const ModelTypeSet encrypted_types = cryptographer->GetEncryptedTypes();
   // It's possible the nigori lost the set of encrypted types. If the current
   // specifics are already encrypted, we want to ensure we continue encrypting.
   bool was_encrypted = old_specifics.has_encrypted();
   sync_pb::EntitySpecifics generated_specifics;
   if (new_specifics.has_encrypted()) {
     NOTREACHED() << "New specifics already has an encrypted blob.";
     return false;
   }
   if ((!SpecificsNeedsEncryption(encrypted_types, new_specifics) &&
        !was_encrypted) ||
       !cryptographer->is_initialized()) {
     // No encryption required or we are unable to encrypt.
     generated_specifics.CopyFrom(new_specifics);
   } else {
     // Encrypt new_specifics into generated_specifics.
     if (VLOG_IS_ON(2)) {
       scoped_ptr<DictionaryValue> value(entry->ToValue());
       std::string info;
       base::JSONWriter::WriteWithOptions(value.get(),
                                          base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                          &info);
       DVLOG(2) << "Encrypting specifics of type "
-               << syncer::ModelTypeToString(type)
+               << ModelTypeToString(type)
                << " with content: "
                << info;
     }
     // Only copy over the old specifics if it is of the right type and already
     // encrypted. The first time we encrypt a node we start from scratch, hence
     // removing all the unencrypted data, but from then on we only want to
     // update the node if the data changes or the encryption key changes.
-    if (syncer::GetModelTypeFromSpecifics(old_specifics) == type &&
+    if (GetModelTypeFromSpecifics(old_specifics) == type &&
         was_encrypted) {
       generated_specifics.CopyFrom(old_specifics);
     } else {
-      syncer::AddDefaultFieldValue(type, &generated_specifics);
+      AddDefaultFieldValue(type, &generated_specifics);
     }
     // Does not change anything if underlying encrypted blob was already up
     // to date and encrypted with the default key.
     if (!cryptographer->Encrypt(new_specifics,
                                 generated_specifics.mutable_encrypted())) {
       NOTREACHED() << "Could not encrypt data for node of type "
-                   << syncer::ModelTypeToString(type);
+                   << ModelTypeToString(type);
       return false;
     }
   }
 
   // It's possible this entry was encrypted but didn't properly overwrite the
   // non_unique_name (see crbug.com/96314).
   bool encrypted_without_overwriting_name = (was_encrypted &&
       entry->Get(syncable::NON_UNIQUE_NAME) != kEncryptedString);
 
   // If we're encrypted but the name wasn't overwritten properly we still want
   // to rewrite the entry, irrespective of whether the specifics match.
   if (!encrypted_without_overwriting_name &&
       old_specifics.SerializeAsString() ==
           generated_specifics.SerializeAsString()) {
-    DVLOG(2) << "Specifics of type " << syncer::ModelTypeToString(type)
+    DVLOG(2) << "Specifics of type " << ModelTypeToString(type)
              << " already match, dropping change.";
     return true;
   }
 
   if (generated_specifics.has_encrypted()) {
     // Overwrite the possibly sensitive non-specifics data.
     entry->Put(syncable::NON_UNIQUE_NAME, kEncryptedString);
     // For bookmarks we actually put bogus data into the unencrypted specifics,
     // else the server will try to do it for us.
-    if (type == syncer::BOOKMARKS) {
+    if (type == BOOKMARKS) {
       sync_pb::BookmarkSpecifics* bookmark_specifics =
           generated_specifics.mutable_bookmark();
       if (!entry->Get(syncable::IS_DIR))
         bookmark_specifics->set_url(kEncryptedString);
       bookmark_specifics->set_title(kEncryptedString);
     }
   }
   entry->Put(syncable::SPECIFICS, generated_specifics);
   DVLOG(1) << "Overwriting specifics of type "
-           << syncer::ModelTypeToString(type)
+           << ModelTypeToString(type)
            << " and marking for syncing.";
   syncable::MarkForSyncing(entry);
   return true;
 }
 
 }  // namespace syncable
 }  // namespace syncer