[Sync] Move ModelType and related classes to 'syncer' namespace

sync/engine/syncer_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/engine/syncer_util.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 232 matching lines @@
   // passphrase may not arrive within this GetUpdates, we can't just return
   // conflict, else we try to perform normal conflict resolution prematurely or
   // the syncer may get stuck. As such, we return CONFLICT_ENCRYPTION, which is
   // treated as an unresolvable conflict. See the description in syncer_types.h.
   // This prevents any unsynced changes from commiting and postpones conflict
   // resolution until all data can be decrypted.
   if (specifics.has_encrypted() &&
       !cryptographer->CanDecrypt(specifics.encrypted())) {
     // We can't decrypt this node yet.
     DVLOG(1) << "Received an undecryptable "
-             << syncable::ModelTypeToString(entry->GetServerModelType())
+             << syncer::ModelTypeToString(entry->GetServerModelType())

[rlarocque, 2012/07/03 17:51:25]

It's not necessary to explicitly specify the namespace here (or anywhere else in
this file).  

I understand that trying to remove all instances of this would be a lot of work.
 I guess we'll just leave it like this for now?

[akalin, 2012/07/03 21:47:08]

Yeah.  I'm planning to clean it all up once everything is in 'syncer'. (As then
I can just remove all instances of 'syncer::' in sync/.)

              << " update, returning encryption_conflict.";
     return CONFLICT_ENCRYPTION;
   } else if (specifics.has_password() &&
              entry->Get(UNIQUE_SERVER_TAG).empty()) {
     // Passwords use their own legacy encryption scheme.
     const sync_pb::PasswordSpecifics& password = specifics.password();
     if (!cryptographer->CanDecrypt(password.encrypted())) {
       DVLOG(1) << "Received an undecryptable password update, returning "
                << "encryption_conflict.";
       return CONFLICT_ENCRYPTION;
@@ skipping 31 matching lines @@
   }
 
   if (entry->Get(IS_UNSYNCED)) {
     DVLOG(1) << "Skipping update, returning conflict for: " << id
              << " ; it's unsynced.";
     return CONFLICT_SIMPLE;
   }
 
   if (specifics.has_encrypted()) {
     DVLOG(2) << "Received a decryptable "
-             << syncable::ModelTypeToString(entry->GetServerModelType())
+             << syncer::ModelTypeToString(entry->GetServerModelType())
              << " update, applying normally.";
   } else {
     DVLOG(2) << "Received an unencrypted "
-             << syncable::ModelTypeToString(entry->GetServerModelType())
+             << syncer::ModelTypeToString(entry->GetServerModelType())
              << " update, applying normally.";
   }
 
   UpdateLocalDataFromServerData(trans, entry);
 
   return SUCCESS;
 }
 
 namespace {
 // Helper to synthesize a new-style sync_pb::EntitySpecifics for use locally,
@@ skipping 59 matching lines @@
   if (update.has_server_defined_unique_tag()) {
     const std::string& tag = update.server_defined_unique_tag();
     target->Put(UNIQUE_SERVER_TAG, tag);
   }
   if (update.has_client_defined_unique_tag()) {
     const std::string& tag = update.client_defined_unique_tag();
     target->Put(UNIQUE_CLIENT_TAG, tag);
   }
   // Store the datatype-specific part as a protobuf.
   if (update.has_specifics()) {
-    DCHECK(update.GetModelType() != syncable::UNSPECIFIED)
+    DCHECK(update.GetModelType() != syncer::UNSPECIFIED)
         << "Storing unrecognized datatype in sync database.";
     target->Put(SERVER_SPECIFICS, update.specifics());
   } else if (update.has_bookmarkdata()) {
     // Legacy protocol response for bookmark data.
     const SyncEntity::BookmarkData& bookmark = update.bookmarkdata();
     UpdateBookmarkSpecifics(update.server_defined_unique_tag(),
                             bookmark.bookmark_url(),
                             bookmark.bookmark_favicon(),
                             target);
   }
@@ skipping 188 matching lines @@
 }
 
 // Assumes we have an existing entry; check here for updates that break
 // consistency rules.
 VerifyResult VerifyUpdateConsistency(
     syncable::WriteTransaction* trans,
     const SyncEntity& update,
     syncable::MutableEntry* target,
     const bool deleted,
     const bool is_directory,
-    syncable::ModelType model_type) {
+    syncer::ModelType model_type) {
 
   CHECK(target->good());
 
   // If the update is a delete, we don't really need to worry at this stage.
   if (deleted)
     return VERIFY_SUCCESS;
 
-  if (model_type == syncable::UNSPECIFIED) {
+  if (model_type == syncer::UNSPECIFIED) {
     // This update is to an item of a datatype we don't recognize. The server
     // shouldn't have sent it to us.  Throw it on the ground.
     return VERIFY_SKIP;
   }
 
   if (target->Get(SERVER_VERSION) > 0) {
     // Then we've had an update for this entry before.
     if (is_directory != target->Get(SERVER_IS_DIR) ||
         model_type != target->GetServerModelType()) {
       if (target->Get(IS_DEL)) {  // If we've deleted the item, we don't care.
@@ skipping 73 matching lines @@
   if (update.version() < target->Get(SERVER_VERSION)) {
     LOG(WARNING) << "Update older than current server version for "
                  << *target << " Update:"
                  << SyncerProtoUtil::SyncEntityDebugString(update);
     return VERIFY_SUCCESS;  // Expected in new sync protocol.
   }
   return VERIFY_UNDECIDED;
 }
 
 }  // namespace syncer