sync: Specialize functions that fetch type root

components/sync_driver/generic_change_processor.cc

 // Copyright 2014 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 "components/sync_driver/generic_change_processor.h"
 
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sync_driver/sync_api_component_factory.h"
@@ skipping 205 matching lines @@
   trans.UpdateEntriesWithAttachmentId(attachment_id);
 }
 
 syncer::SyncError GenericChangeProcessor::GetAllSyncDataReturnError(
     syncer::ModelType type,
     syncer::SyncDataList* current_sync_data) const {
   DCHECK(CalledOnValidThread());
   std::string type_name = syncer::ModelTypeToString(type);
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
   syncer::ReadNode root(&trans);
-  if (root.InitByTagLookup(syncer::ModelTypeToRootTag(type)) !=
-          syncer::BaseNode::INIT_OK) {
+  if (root.InitTypeRoot(type) != syncer::BaseNode::INIT_OK) {
     syncer::SyncError error(FROM_HERE,
                             syncer::SyncError::DATATYPE_ERROR,
                             "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.
@@ skipping 31 matching lines @@
   DCHECK_EQ(type,
             syncer::GetModelTypeFromSpecificsFieldNumber(
                 context_proto.data_type_id()));
   *context = context_proto.context();
   return true;
 }
 
 int GenericChangeProcessor::GetSyncCountForType(syncer::ModelType type) {
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
   syncer::ReadNode root(&trans);
-  if (root.InitByTagLookup(syncer::ModelTypeToRootTag(type)) !=
-      syncer::BaseNode::INIT_OK)
+  if (root.InitTypeRoot(type) != syncer::BaseNode::INIT_OK)
     return 0;
 
   // Subtract one to account for type's root node.
   return root.GetTotalNodeCount() - 1;
 }
 
 namespace {
 
 // TODO(isherman): Investigating http://crbug.com/121592
 // WARNING: this code is sensitive to compiler optimizations. Be careful
@@ skipping 197 matching lines @@
     const syncer::SyncChange& change,
     const std::string& type_str,
     const syncer::ModelType& type,
     const syncer::WriteTransaction& trans,
     syncer::WriteNode* sync_node,
     syncer::AttachmentList* new_attachments) {
   // TODO(sync): Handle other types of creation (custom parents, folders,
   // etc.).
   syncer::ReadNode root_node(&trans);
   const syncer::SyncDataLocal sync_data_local(change.sync_data());
-  if (root_node.InitByTagLookup(syncer::ModelTypeToRootTag(
-          sync_data_local.GetDataType())) != syncer::BaseNode::INIT_OK) {
+  if (root_node.InitTypeRoot(sync_data_local.GetDataType()) !=
+      syncer::BaseNode::INIT_OK) {
     syncer::SyncError error(FROM_HERE,
                             syncer::SyncError::DATATYPE_ERROR,
                             "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 187 matching lines @@
     bool* has_nodes) {
   DCHECK(CalledOnValidThread());
   DCHECK(has_nodes);
   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(syncer::ModelTypeToRootTag(type)) !=
-          syncer::BaseNode::INIT_OK) {
+  if (type_root_node.InitTypeRoot(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(syncer::ModelType type) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(type, syncer::UNSPECIFIED);
   // We only access the cryptographer while holding a transaction.
   syncer::ReadTransaction trans(FROM_HERE, share_handle());
   const syncer::ModelTypeSet encrypted_types = trans.GetEncryptedTypes();
   return !encrypted_types.Has(type) ||
          trans.GetCryptographer()->is_ready();
 }
 
 void GenericChangeProcessor::StartImpl() {
 }
 
 syncer::UserShare* GenericChangeProcessor::share_handle() const {
   DCHECK(CalledOnValidThread());
   return share_handle_;
 }
 
 }  // namespace browser_sync