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

sync/internal_api/base_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/base_node.h"
 
 #include "base/base64.h"
 #include "base/sha1.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 46 matching lines @@
     --length_to_copy;
   }
   *out = std::string(server_name.c_str(), length_to_copy);
 }
 
 BaseNode::BaseNode() : password_data_(new sync_pb::PasswordSpecificsData) {}
 
 BaseNode::~BaseNode() {}
 
 std::string BaseNode::GenerateSyncableHash(
-    syncer::ModelType model_type, const std::string& client_tag) {
+    ModelType model_type, const std::string& client_tag) {
   // Blank PB with just the field in it has termination symbol,
   // handy for delimiter.
   sync_pb::EntitySpecifics serialized_type;
-  syncer::AddDefaultFieldValue(model_type, &serialized_type);
+  AddDefaultFieldValue(model_type, &serialized_type);
   std::string hash_input;
   serialized_type.AppendToString(&hash_input);
   hash_input.append(client_tag);
 
   std::string encode_output;
   CHECK(base::Base64Encode(base::SHA1HashString(hash_input), &encode_output));
   return encode_output;
 }
 
 bool BaseNode::DecryptIfNecessary() {
@@ skipping 12 matching lines @@
     password_data_.swap(data);
     return true;
   }
 
   // We assume any node with the encrypted field set has encrypted data and if
   // not we have no work to do, with the exception of bookmarks. For bookmarks
   // we must make sure the bookmarks data has the title field supplied. If not,
   // we fill the unencrypted_data_ with a copy of the bookmark specifics that
   // follows the new bookmarks format.
   if (!specifics.has_encrypted()) {
-    if (GetModelType() == syncer::BOOKMARKS &&
+    if (GetModelType() == BOOKMARKS &&
         !specifics.bookmark().has_title() &&
         !GetTitle().empty()) {  // Last check ensures this isn't a new node.
       // We need to fill in the title.
       std::string title = GetTitle();
       std::string server_legal_title;
       SyncAPINameToServerName(title, &server_legal_title);
       DVLOG(1) << "Reading from legacy bookmark, manually returning title "
                << title;
       unencrypted_data_.CopyFrom(specifics);
       unencrypted_data_.mutable_bookmark()->set_title(
           server_legal_title);
     }
     return true;
   }
 
   const sync_pb::EncryptedData& encrypted = specifics.encrypted();
   std::string plaintext_data = GetTransaction()->GetCryptographer()->
       DecryptToString(encrypted);
   if (plaintext_data.length() == 0) {
     LOG(ERROR) << "Failed to decrypt encrypted node of type " <<
-      syncer::ModelTypeToString(GetModelType()) << ".";
+      ModelTypeToString(GetModelType()) << ".";

[Nicolas Zea, 2012/07/19 19:37:56]

nit: fix up indent

[akalin, 2012/07/19 20:56:02]

Done.

     // Debugging for crbug.com/123223. We failed to decrypt the data, which
     // means we applied an update without having the key or lost the key at a
     // later point.
     CHECK(false);
     return false;
   } else if (!unencrypted_data_.ParseFromString(plaintext_data)) {
     // Debugging for crbug.com/123223. We should never succeed in decrypting
     // but fail to parse into a protobuf.
     CHECK(false);
     return false;
   }
   DVLOG(2) << "Decrypted specifics of type "
-           << syncer::ModelTypeToString(GetModelType())
+           << ModelTypeToString(GetModelType())
            << " with content: " << plaintext_data;
   return true;
 }
 
 const sync_pb::EntitySpecifics& BaseNode::GetUnencryptedSpecifics(
     const syncable::Entry* entry) const {
   const sync_pb::EntitySpecifics& specifics = entry->Get(SPECIFICS);
   if (specifics.has_encrypted()) {
-    DCHECK_NE(syncer::GetModelTypeFromSpecifics(unencrypted_data_),
-              syncer::UNSPECIFIED);
+    DCHECK_NE(GetModelTypeFromSpecifics(unencrypted_data_), UNSPECIFIED);
     return unencrypted_data_;
   } else {
     // Due to the change in bookmarks format, we need to check to see if this is
     // a legacy bookmarks (and has no title field in the proto). If it is, we
     // return the unencrypted_data_, which was filled in with the title by
     // DecryptIfNecessary().
-    if (GetModelType() == syncer::BOOKMARKS) {
+    if (GetModelType() == BOOKMARKS) {
       const sync_pb::BookmarkSpecifics& bookmark_specifics =
           specifics.bookmark();
       if (bookmark_specifics.has_title() ||
           GetTitle().empty() ||  // For the empty node case
           !GetEntry()->Get(syncable::UNIQUE_SERVER_TAG).empty()) {
         // It's possible we previously had to convert and set
         // |unencrypted_data_| but then wrote our own data, so we allow
         // |unencrypted_data_| to be non-empty.
         return specifics;
       } else {
-        DCHECK_EQ(syncer::GetModelTypeFromSpecifics(unencrypted_data_),
-                  syncer::BOOKMARKS);
+        DCHECK_EQ(GetModelTypeFromSpecifics(unencrypted_data_), BOOKMARKS);
         return unencrypted_data_;
       }
     } else {
-      DCHECK_EQ(syncer::GetModelTypeFromSpecifics(unencrypted_data_),
-                syncer::UNSPECIFIED);
+      DCHECK_EQ(GetModelTypeFromSpecifics(unencrypted_data_), UNSPECIFIED);
       return specifics;
     }
   }
 }
 
 int64 BaseNode::GetParentId() const {
   return IdToMetahandle(GetTransaction()->GetWrappedTrans(),
                         GetEntry()->Get(syncable::PARENT_ID));
 }
 
 int64 BaseNode::GetId() const {
   return GetEntry()->Get(syncable::META_HANDLE);
 }
 
 const base::Time& BaseNode::GetModificationTime() const {
   return GetEntry()->Get(syncable::MTIME);
 }
 
 bool BaseNode::GetIsFolder() const {
   return GetEntry()->Get(syncable::IS_DIR);
 }
 
 std::string BaseNode::GetTitle() const {
   std::string result;
   // TODO(zea): refactor bookmarks to not need this functionality.
-  if (syncer::BOOKMARKS == GetModelType() &&
+  if (BOOKMARKS == GetModelType() &&
       GetEntry()->Get(syncable::SPECIFICS).has_encrypted()) {
     // Special case for legacy bookmarks dealing with encryption.
     ServerNameToSyncAPIName(GetBookmarkSpecifics().title(), &result);
   } else {
     ServerNameToSyncAPIName(GetEntry()->Get(syncable::NON_UNIQUE_NAME),
                             &result);
   }
   return result;
 }
 
@@ skipping 40 matching lines @@
   node_info->SetBoolean("isFolder", GetIsFolder());
   node_info->SetString("title", GetTitle());
   node_info->Set("type", ModelTypeToValue(GetModelType()));
   return node_info;
 }
 
 DictionaryValue* BaseNode::GetDetailsAsValue() const {
   DictionaryValue* node_info = GetSummaryAsValue();
   node_info->SetString(
       "modificationTime",
-      syncer::GetTimeDebugString(GetModificationTime()));
+      GetTimeDebugString(GetModificationTime()));
   node_info->SetString("parentId", base::Int64ToString(GetParentId()));
   // Specifics are already in the Entry value, so no need to duplicate
   // it here.
   node_info->SetString("externalId",
                        base::Int64ToString(GetExternalId()));
   node_info->SetString("predecessorId",
                        base::Int64ToString(GetPredecessorId()));
   node_info->SetString("successorId",
                        base::Int64ToString(GetSuccessorId()));
   node_info->SetString("firstChildId",
                        base::Int64ToString(GetFirstChildId()));
   node_info->Set("entry", GetEntry()->ToValue());
   return node_info;
 }
 
 void BaseNode::GetFaviconBytes(std::vector<unsigned char>* output) const {
   if (!output)
     return;
   const std::string& favicon = GetBookmarkSpecifics().favicon();
   output->assign(reinterpret_cast<const unsigned char*>(favicon.data()),
       reinterpret_cast<const unsigned char*>(favicon.data() +
                                              favicon.length()));
 }
 
 int64 BaseNode::GetExternalId() const {
   return GetEntry()->Get(syncable::LOCAL_EXTERNAL_ID);
 }
 
 const sync_pb::AppSpecifics& BaseNode::GetAppSpecifics() const {
-  DCHECK_EQ(syncer::APPS, GetModelType());
+  DCHECK_EQ(GetModelType(), APPS);

[Nicolas Zea, 2012/07/19 19:37:56]

nit: these should be the other way around right? i.e.: expected value, test
value

[akalin, 2012/07/19 20:56:02]

that's only for gtest functions (EXPECT_EQ, ASSERT_EQ)

   return GetEntitySpecifics().app();
 }
 
 const sync_pb::AutofillSpecifics& BaseNode::GetAutofillSpecifics() const {
-  DCHECK_EQ(syncer::AUTOFILL, GetModelType());
+  DCHECK_EQ(GetModelType(), AUTOFILL);
   return GetEntitySpecifics().autofill();
 }
 
 const AutofillProfileSpecifics& BaseNode::GetAutofillProfileSpecifics() const {
-  DCHECK_EQ(GetModelType(), syncer::AUTOFILL_PROFILE);
+  DCHECK_EQ(GetModelType(), AUTOFILL_PROFILE);
   return GetEntitySpecifics().autofill_profile();
 }
 
 const sync_pb::BookmarkSpecifics& BaseNode::GetBookmarkSpecifics() const {
-  DCHECK_EQ(syncer::BOOKMARKS, GetModelType());
+  DCHECK_EQ(GetModelType(), BOOKMARKS);
   return GetEntitySpecifics().bookmark();
 }
 
 const sync_pb::NigoriSpecifics& BaseNode::GetNigoriSpecifics() const {
-  DCHECK_EQ(syncer::NIGORI, GetModelType());
+  DCHECK_EQ(GetModelType(), NIGORI);
   return GetEntitySpecifics().nigori();
 }
 
 const sync_pb::PasswordSpecificsData& BaseNode::GetPasswordSpecifics() const {
-  DCHECK_EQ(syncer::PASSWORDS, GetModelType());
+  DCHECK_EQ(GetModelType(), PASSWORDS);
   return *password_data_;
 }
 
 const sync_pb::ThemeSpecifics& BaseNode::GetThemeSpecifics() const {
-  DCHECK_EQ(syncer::THEMES, GetModelType());
+  DCHECK_EQ(GetModelType(), THEMES);
   return GetEntitySpecifics().theme();
 }
 
 const sync_pb::TypedUrlSpecifics& BaseNode::GetTypedUrlSpecifics() const {
-  DCHECK_EQ(syncer::TYPED_URLS, GetModelType());
+  DCHECK_EQ(GetModelType(), TYPED_URLS);
   return GetEntitySpecifics().typed_url();
 }
 
 const sync_pb::ExtensionSpecifics& BaseNode::GetExtensionSpecifics() const {
-  DCHECK_EQ(syncer::EXTENSIONS, GetModelType());
+  DCHECK_EQ(GetModelType(), EXTENSIONS);
   return GetEntitySpecifics().extension();
 }
 
 const sync_pb::SessionSpecifics& BaseNode::GetSessionSpecifics() const {
-  DCHECK_EQ(syncer::SESSIONS, GetModelType());
+  DCHECK_EQ(GetModelType(), SESSIONS);
   return GetEntitySpecifics().session();
 }
 
 const sync_pb::EntitySpecifics& BaseNode::GetEntitySpecifics() const {
   return GetUnencryptedSpecifics(GetEntry());
 }
 
-syncer::ModelType BaseNode::GetModelType() const {
+ModelType BaseNode::GetModelType() const {
   return GetEntry()->GetModelType();
 }
 
 void BaseNode::SetUnencryptedSpecifics(
     const sync_pb::EntitySpecifics& specifics) {
-  syncer::ModelType type = syncer::GetModelTypeFromSpecifics(specifics);
-  DCHECK_NE(syncer::UNSPECIFIED, type);
-  if (GetModelType() != syncer::UNSPECIFIED) {
+  ModelType type = GetModelTypeFromSpecifics(specifics);
+  DCHECK_NE(UNSPECIFIED, type);
+  if (GetModelType() != UNSPECIFIED) {
     DCHECK_EQ(GetModelType(), type);
   }
   unencrypted_data_.CopyFrom(specifics);
 }
 
 }  // namespace syncer