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

sync/internal_api/write_node.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/internal_api/public/write_node.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base_transaction.h"
 #include "sync/internal_api/public/write_transaction.h"
@@ skipping 22 matching lines @@
 
 void WriteNode::SetIsFolder(bool folder) {
   if (entry_->Get(syncable::IS_DIR) == folder)
     return;  // Skip redundant changes.
 
   entry_->Put(syncable::IS_DIR, folder);
   MarkForSyncing();
 }
 
 void WriteNode::SetTitle(const std::wstring& title) {
-  DCHECK_NE(GetModelType(), syncer::UNSPECIFIED);
-  syncer::ModelType type = GetModelType();
+  DCHECK_NE(GetModelType(), UNSPECIFIED);
+  ModelType type = GetModelType();
   Cryptographer* cryptographer = GetTransaction()->GetCryptographer();
   // 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 needs_encryption = cryptographer->GetEncryptedTypes().Has(type) ||
                           entry_->Get(SPECIFICS).has_encrypted();
 
   // If this datatype is encrypted and is not a bookmark, we disregard the
   // specified title in favor of kEncryptedString. For encrypted bookmarks the
   // NON_UNIQUE_NAME will still be kEncryptedString, but we store the real title
   // into the specifics. All strings compared are server legal strings.
   std::string new_legal_title;
-  if (type != syncer::BOOKMARKS && needs_encryption) {
+  if (type != BOOKMARKS && needs_encryption) {
     new_legal_title = kEncryptedString;
   } else {
     SyncAPINameToServerName(WideToUTF8(title), &new_legal_title);
   }
 
   std::string current_legal_title;
-  if (syncer::BOOKMARKS == type &&
+  if (BOOKMARKS == type &&
       entry_->Get(syncable::SPECIFICS).has_encrypted()) {
     // Encrypted bookmarks only have their title in the unencrypted specifics.
     current_legal_title = GetBookmarkSpecifics().title();
   } else {
     // Non-bookmarks and legacy bookmarks (those with no title in their
     // specifics) store their title in NON_UNIQUE_NAME. Non-legacy bookmarks
     // store their title in specifics as well as NON_UNIQUE_NAME.
     current_legal_title = entry_->Get(syncable::NON_UNIQUE_NAME);
   }
 
   bool title_matches = (current_legal_title == new_legal_title);
   bool encrypted_without_overwriting_name = (needs_encryption &&
       entry_->Get(syncable::NON_UNIQUE_NAME) != kEncryptedString);
 
   // If the title matches and the NON_UNIQUE_NAME is properly overwritten as
   // necessary, nothing needs to change.
   if (title_matches && !encrypted_without_overwriting_name) {
     DVLOG(2) << "Title matches, dropping change.";
     return;
   }
 
   // For bookmarks, we also set the title field in the specifics.
   // TODO(zea): refactor bookmarks to not need this functionality.
-  if (GetModelType() == syncer::BOOKMARKS) {
+  if (GetModelType() == BOOKMARKS) {
     sync_pb::EntitySpecifics specifics = GetEntitySpecifics();
     specifics.mutable_bookmark()->set_title(new_legal_title);
     SetEntitySpecifics(specifics);  // Does it's own encryption checking.
   }
 
   // For bookmarks, this has to happen after we set the title in the specifics,
   // because the presence of a title in the NON_UNIQUE_NAME is what controls
   // the logic deciding whether this is an empty node or a legacy bookmark.
   // See BaseNode::GetUnencryptedSpecific(..).
   if (needs_encryption)
     entry_->Put(syncable::NON_UNIQUE_NAME, kEncryptedString);
   else
     entry_->Put(syncable::NON_UNIQUE_NAME, new_legal_title);
 
   DVLOG(1) << "Overwriting title of type "
-           << syncer::ModelTypeToString(type)
+           << ModelTypeToString(type)
            << " and marking for syncing.";
   MarkForSyncing();
 }
 
 void WriteNode::SetURL(const GURL& url) {
   sync_pb::BookmarkSpecifics new_value = GetBookmarkSpecifics();
   new_value.set_url(url.spec());
   SetBookmarkSpecifics(new_value);
 }
 
@@ skipping 28 matching lines @@
 
 void WriteNode::SetNigoriSpecifics(
     const sync_pb::NigoriSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_nigori()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetPasswordSpecifics(
     const sync_pb::PasswordSpecificsData& data) {
-  DCHECK_EQ(syncer::PASSWORDS, GetModelType());
+  DCHECK_EQ(GetModelType(), PASSWORDS);
 
   Cryptographer* cryptographer = GetTransaction()->GetCryptographer();
 
   // We have to do the idempotency check here (vs in UpdateEntryWithEncryption)
   // because Passwords have their encrypted data within the PasswordSpecifics,
   // vs within the EntitySpecifics like all the other types.
   const sync_pb::EntitySpecifics& old_specifics = GetEntry()->Get(SPECIFICS);
   sync_pb::EntitySpecifics entity_specifics;
   // Copy over the old specifics if they exist.
-  if (syncer::GetModelTypeFromSpecifics(old_specifics) == syncer::PASSWORDS) {
+  if (GetModelTypeFromSpecifics(old_specifics) == PASSWORDS) {
     entity_specifics.CopyFrom(old_specifics);
   } else {
-    syncer::AddDefaultFieldValue(syncer::PASSWORDS, &entity_specifics);
+    AddDefaultFieldValue(PASSWORDS, &entity_specifics);
   }
   sync_pb::PasswordSpecifics* password_specifics =
       entity_specifics.mutable_password();
   // This will only update password_specifics if the underlying unencrypted blob
   // was different from |data| or was not encrypted with the proper passphrase.
   if (!cryptographer->Encrypt(data, password_specifics->mutable_encrypted())) {
     NOTREACHED() << "Failed to encrypt password, possibly due to sync node "
                  << "corruption";
     return;
   }
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetThemeSpecifics(
     const sync_pb::ThemeSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_theme()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetSessionSpecifics(
     const sync_pb::SessionSpecifics& new_value) {
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_session()->CopyFrom(new_value);
   SetEntitySpecifics(entity_specifics);
 }
 
 void WriteNode::SetEntitySpecifics(
     const sync_pb::EntitySpecifics& new_value) {
-  syncer::ModelType new_specifics_type =
-      syncer::GetModelTypeFromSpecifics(new_value);
-  DCHECK_NE(new_specifics_type, syncer::UNSPECIFIED);
+  ModelType new_specifics_type =
+      GetModelTypeFromSpecifics(new_value);
+  DCHECK_NE(new_specifics_type, UNSPECIFIED);
   DVLOG(1) << "Writing entity specifics of type "
-           << syncer::ModelTypeToString(new_specifics_type);
+           << ModelTypeToString(new_specifics_type);
   // GetModelType() can be unspecified if this is the first time this
   // node is being initialized (see PutModelType()).  Otherwise, it
   // should match |new_specifics_type|.
-  if (GetModelType() != syncer::UNSPECIFIED) {
+  if (GetModelType() != UNSPECIFIED) {
     DCHECK_EQ(new_specifics_type, GetModelType());
   }
-  syncer::Cryptographer* cryptographer =
-      GetTransaction()->GetCryptographer();
+  Cryptographer* cryptographer = GetTransaction()->GetCryptographer();
 
   // Preserve unknown fields.
   const sync_pb::EntitySpecifics& old_specifics = entry_->Get(SPECIFICS);
   sync_pb::EntitySpecifics new_specifics;
   new_specifics.CopyFrom(new_value);
   new_specifics.mutable_unknown_fields()->MergeFrom(
       old_specifics.unknown_fields());
 
   // Will update the entry if encryption was necessary.
   if (!UpdateEntryWithEncryption(cryptographer, new_specifics, entry_)) {
@@ skipping 54 matching lines @@
     return INIT_FAILED_ENTRY_NOT_GOOD;
   if (entry_->Get(syncable::IS_DEL))
     return INIT_FAILED_ENTRY_IS_DEL;
   return DecryptIfNecessary() ? INIT_OK : INIT_FAILED_DECRYPT_IF_NECESSARY;
 }
 
 // Find a node by client tag, and bind this WriteNode to it.
 // Return true if the write node was found, and was not deleted.
 // Undeleting a deleted node is possible by ClientTag.
 BaseNode::InitByLookupResult WriteNode::InitByClientTagLookup(
-    syncer::ModelType model_type,
+    ModelType model_type,
     const std::string& tag) {
   DCHECK(!entry_) << "Init called twice";
   if (tag.empty())
     return INIT_FAILED_PRECONDITION;
 
   const std::string hash = GenerateSyncableHash(model_type, tag);
 
   entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
                                       syncable::GET_BY_CLIENT_TAG, hash);
   if (!entry_->good())
     return INIT_FAILED_ENTRY_NOT_GOOD;
   if (entry_->Get(syncable::IS_DEL))
     return INIT_FAILED_ENTRY_IS_DEL;
   return DecryptIfNecessary() ? INIT_OK : INIT_FAILED_DECRYPT_IF_NECESSARY;
 }
 
 BaseNode::InitByLookupResult WriteNode::InitByTagLookup(
     const std::string& tag) {
   DCHECK(!entry_) << "Init called twice";
   if (tag.empty())
     return INIT_FAILED_PRECONDITION;
   entry_ = new syncable::MutableEntry(transaction_->GetWrappedWriteTrans(),
                                       syncable::GET_BY_SERVER_TAG, tag);
   if (!entry_->good())
     return INIT_FAILED_ENTRY_NOT_GOOD;
   if (entry_->Get(syncable::IS_DEL))
     return INIT_FAILED_ENTRY_IS_DEL;
-  syncer::ModelType model_type = GetModelType();
-  DCHECK_EQ(syncer::NIGORI, model_type);
+  ModelType model_type = GetModelType();
+  DCHECK_EQ(model_type, NIGORI);
   return INIT_OK;
 }
 
-void WriteNode::PutModelType(syncer::ModelType model_type) {
+void WriteNode::PutModelType(ModelType model_type) {
   // Set an empty specifics of the appropriate datatype.  The presence
   // of the specific field will identify the model type.
   DCHECK(GetModelType() == model_type ||
-         GetModelType() == syncer::UNSPECIFIED);  // Immutable once set.
+         GetModelType() == UNSPECIFIED);  // Immutable once set.
 
   sync_pb::EntitySpecifics specifics;
-  syncer::AddDefaultFieldValue(model_type, &specifics);
+  AddDefaultFieldValue(model_type, &specifics);
   SetEntitySpecifics(specifics);
 }
 
 // Create a new node with default properties, and bind this WriteNode to it.
 // Return true on success.
-bool WriteNode::InitByCreation(syncer::ModelType model_type,
+bool WriteNode::InitByCreation(ModelType model_type,
                                const BaseNode& parent,
                                const BaseNode* predecessor) {
   DCHECK(!entry_) << "Init called twice";
   // |predecessor| must be a child of |parent| or NULL.
   if (predecessor && predecessor->GetParentId() != parent.GetId()) {
     DCHECK(false);
     return false;
   }
 
   syncable::Id parent_id = parent.GetEntry()->Get(syncable::ID);
@@ skipping 17 matching lines @@
   return PutPredecessor(predecessor);
 }
 
 // Create a new node with default properties and a client defined unique tag,
 // and bind this WriteNode to it.
 // Return true on success. If the tag exists in the database, then
 // we will attempt to undelete the node.
 // TODO(chron): Code datatype into hash tag.
 // TODO(chron): Is model type ever lost?
 WriteNode::InitUniqueByCreationResult WriteNode::InitUniqueByCreation(
-    syncer::ModelType model_type,
+    ModelType model_type,
     const BaseNode& parent,
     const std::string& tag) {
   // This DCHECK will only fail if init is called twice.
   DCHECK(!entry_);
   if (tag.empty()) {
     LOG(WARNING) << "InitUniqueByCreation failed due to empty tag.";
     return INIT_FAILED_EMPTY_TAG;
   }
 
   const std::string hash = GenerateSyncableHash(model_type, tag);
@@ skipping 127 matching lines @@
   sync_pb::BookmarkSpecifics new_value = GetBookmarkSpecifics();
   new_value.set_favicon(bytes.empty() ? NULL : &bytes[0], bytes.size());
   SetBookmarkSpecifics(new_value);
 }
 
 void WriteNode::MarkForSyncing() {
   syncable::MarkForSyncing(entry_);
 }
 
 }  // namespace syncer