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

chrome/browser/sync/glue/generic_change_processor.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 "chrome/browser/sync/glue/generic_change_processor.h"
 
 #include "base/location.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 61 matching lines @@
   }
 }
 
 void GenericChangeProcessor::CommitChangesFromSyncModel() {
   DCHECK(CalledOnValidThread());
   if (!running())
     return;
   if (syncer_changes_.empty())
     return;
   if (!local_service_) {
-    syncable::ModelType type = syncer_changes_[0].sync_data().GetDataType();
+    syncer::ModelType type = syncer_changes_[0].sync_data().GetDataType();
     syncer::SyncError error(FROM_HERE, "Local service destroyed.", type);
     error_handler()->OnSingleDatatypeUnrecoverableError(error.location(),
                                                         error.message());
     return;
   }
   syncer::SyncError error = local_service_->ProcessSyncChanges(FROM_HERE,
                                                        syncer_changes_);
   syncer_changes_.clear();
   if (error.IsSet()) {
     error_handler()->OnSingleDatatypeUnrecoverableError(
         error.location(), error.message());
   }
 }
 
 syncer::SyncError GenericChangeProcessor::GetSyncDataForType(
-    syncable::ModelType type,
+    syncer::ModelType type,
     syncer::SyncDataList* current_sync_data) {
   DCHECK(CalledOnValidThread());
-  std::string type_name = syncable::ModelTypeToString(type);
+  std::string type_name = syncer::ModelTypeToString(type);
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
   syncer::ReadNode root(&trans);
-  if (root.InitByTagLookup(syncable::ModelTypeToRootTag(type)) !=
+  if (root.InitByTagLookup(syncer::ModelTypeToRootTag(type)) !=
           syncer::BaseNode::INIT_OK) {
     syncer::SyncError error(FROM_HERE,
                     "Server did not create the top-level " + type_name +
                     " node. We might be running against an out-of-date server.",
                     type);
     return error;
   }
 
   // TODO(akalin): We'll have to do a tree traversal for bookmarks.
-  DCHECK_NE(type, syncable::BOOKMARKS);
+  DCHECK_NE(type, syncer::BOOKMARKS);
 
   int64 sync_child_id = root.GetFirstChildId();
   while (sync_child_id != syncer::kInvalidId) {
     syncer::ReadNode sync_child_node(&trans);
     if (sync_child_node.InitByIdLookup(sync_child_id) !=
             syncer::BaseNode::INIT_OK) {
       syncer::SyncError error(FROM_HERE,
                       "Failed to fetch child node for type " + type_name + ".",
                        type);
       return error;
     }
     current_sync_data->push_back(syncer::SyncData::CreateRemoteData(
         sync_child_node.GetId(), sync_child_node.GetEntitySpecifics()));
     sync_child_id = sync_child_node.GetSuccessorId();
   }
   return syncer::SyncError();
 }
 
 namespace {
 
 // TODO(isherman): Investigating http://crbug.com/121592
 // WARNING: this code is sensitive to compiler optimizations. Be careful
 // modifying any code around an OnSingleDatatypeUnrecoverableError call, else
 // the compiler attempts to merge it with other calls, losing useful information
 // in breakpad uploads.
 syncer::SyncError LogLookupFailure(
     syncer::BaseNode::InitByLookupResult lookup_result,
     const tracked_objects::Location& from_here,
     const std::string& error_prefix,
-    syncable::ModelType type,
+    syncer::ModelType type,
     DataTypeErrorHandler* error_handler) {
   switch (lookup_result) {
     case syncer::BaseNode::INIT_FAILED_ENTRY_NOT_GOOD: {
       syncer::SyncError error;
       error.Reset(from_here,
                   error_prefix +
                       "could not find entry matching the lookup criteria.",
                   type);
       error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                         error.message());
@@ skipping 31 matching lines @@
       // Should have listed all the possible error cases above.
       error.Reset(from_here, error_prefix + "unknown error", type);
       error_handler->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                         error.message());
       LOG(ERROR) << "Delete: Unknown error.";
       return error;
     }
   }
 }
 
-syncer::SyncError AttemptDelete(const syncer::SyncChange& change,
-                        syncable::ModelType type,
-                        const std::string& type_str,
-                        syncer::WriteNode* node,
-                        DataTypeErrorHandler* error_handler) {
+syncer::SyncError AttemptDelete(
+    const syncer::SyncChange& change,
+    syncer::ModelType type,
+    const std::string& type_str,
+    syncer::WriteNode* node,
+    DataTypeErrorHandler* error_handler) {
   DCHECK_EQ(change.change_type(), syncer::SyncChange::ACTION_DELETE);
   if (change.sync_data().IsLocal()) {
     const std::string& tag = change.sync_data().GetTag();
     if (tag.empty()) {
       syncer::SyncError error(
           FROM_HERE,
           "Failed to delete " + type_str + " node. Local data, empty tag.",
           type);
       error_handler->OnSingleDatatypeUnrecoverableError(error.location(),
                                                         error.message());
@@ skipping 32 matching lines @@
 syncer::SyncError GenericChangeProcessor::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& list_of_changes) {
   DCHECK(CalledOnValidThread());
   syncer::WriteTransaction trans(from_here, share_handle());
 
   for (syncer::SyncChangeList::const_iterator iter = list_of_changes.begin();
        iter != list_of_changes.end();
        ++iter) {
     const syncer::SyncChange& change = *iter;
-    DCHECK_NE(change.sync_data().GetDataType(), syncable::UNSPECIFIED);
-    syncable::ModelType type = change.sync_data().GetDataType();
-    std::string type_str = syncable::ModelTypeToString(type);
+    DCHECK_NE(change.sync_data().GetDataType(), syncer::UNSPECIFIED);
+    syncer::ModelType type = change.sync_data().GetDataType();
+    std::string type_str = syncer::ModelTypeToString(type);
     syncer::WriteNode sync_node(&trans);
     if (change.change_type() == syncer::SyncChange::ACTION_DELETE) {
       syncer::SyncError error =
           AttemptDelete(change, type, type_str, &sync_node,
                         error_handler());
       if (error.IsSet()) {
         NOTREACHED();
         return error;
       }
     } else if (change.change_type() == syncer::SyncChange::ACTION_ADD) {
       // TODO(sync): Handle other types of creation (custom parents, folders,
       // etc.).
       syncer::ReadNode root_node(&trans);
       if (root_node.InitByTagLookup(
-              syncable::ModelTypeToRootTag(change.sync_data().GetDataType())) !=
+              syncer::ModelTypeToRootTag(change.sync_data().GetDataType())) !=
                   syncer::BaseNode::INIT_OK) {
         syncer::SyncError error(FROM_HERE,
                         "Failed to look up root node for type " + type_str,
                         type);
         error_handler()->OnSingleDatatypeUnrecoverableError(FROM_HERE,
                                                             error.message());
         NOTREACHED();
         LOG(ERROR) << "Create: no root node.";
         return error;
       }
@@ skipping 78 matching lines @@
           syncer::SyncError error;
           error.Reset(FROM_HERE,
                       "Failed to load deleted entry for " + type_str + ".",
                       type);
           error_handler()->OnSingleDatatypeUnrecoverableError(
               FROM_HERE, error.message());
           LOG(ERROR) << "Update: deleted entry.";
           return error;
         } else {
           syncer::Cryptographer* crypto = trans.GetCryptographer();
-          syncable::ModelTypeSet encrypted_types(crypto->GetEncryptedTypes());
+          syncer::ModelTypeSet encrypted_types(crypto->GetEncryptedTypes());
           const sync_pb::EntitySpecifics& specifics =
               sync_node.GetEntry()->Get(syncer::syncable::SPECIFICS);
           CHECK(specifics.has_encrypted());
           const bool can_decrypt = crypto->CanDecrypt(specifics.encrypted());
           const bool agreement = encrypted_types.Has(type);
           if (!agreement && !can_decrypt) {
             syncer::SyncError error;
             error.Reset(FROM_HERE,
                         "Failed to load encrypted entry, missing key and "
                         "nigori mismatch for " + type_str + ".",
@@ skipping 49 matching lines @@
                                                           error.message());
       NOTREACHED();
       LOG(ERROR) << "Unset sync change.";
       return error;
     }
   }
   return syncer::SyncError();
 }
 
 bool GenericChangeProcessor::SyncModelHasUserCreatedNodes(
-    syncable::ModelType type,
+    syncer::ModelType type,
     bool* has_nodes) {
   DCHECK(CalledOnValidThread());
   DCHECK(has_nodes);
-  DCHECK_NE(type, syncable::UNSPECIFIED);
-  std::string type_name = syncable::ModelTypeToString(type);
+  DCHECK_NE(type, syncer::UNSPECIFIED);
+  std::string type_name = syncer::ModelTypeToString(type);
   std::string err_str = "Server did not create the top-level " + type_name +
       " node. We might be running against an out-of-date server.";
   *has_nodes = false;
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
   syncer::ReadNode type_root_node(&trans);
-  if (type_root_node.InitByTagLookup(syncable::ModelTypeToRootTag(type)) !=
+  if (type_root_node.InitByTagLookup(syncer::ModelTypeToRootTag(type)) !=
           syncer::BaseNode::INIT_OK) {
     LOG(ERROR) << err_str;
     return false;
   }
 
   // The sync model has user created nodes if the type's root node has any
   // children.
   *has_nodes = type_root_node.HasChildren();
   return true;
 }
 
-bool GenericChangeProcessor::CryptoReadyIfNecessary(syncable::ModelType type) {
+bool GenericChangeProcessor::CryptoReadyIfNecessary(syncer::ModelType type) {
   DCHECK(CalledOnValidThread());
-  DCHECK_NE(type, syncable::UNSPECIFIED);
+  DCHECK_NE(type, syncer::UNSPECIFIED);
   // We only access the cryptographer while holding a transaction.
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
-  const syncable::ModelTypeSet encrypted_types = GetEncryptedTypes(&trans);
+  const syncer::ModelTypeSet encrypted_types = GetEncryptedTypes(&trans);
   return !encrypted_types.Has(type) ||
          trans.GetCryptographer()->is_ready();
 }
 
 void GenericChangeProcessor::StartImpl(Profile* profile) {
   DCHECK(CalledOnValidThread());
 }
 
 void GenericChangeProcessor::StopImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync