sync: Specialize functions that fetch type root

sync/internal_api/sync_encryption_handler_impl.cc

 // Copyright 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/sync_encryption_handler_impl.h"
 
 #include <queue>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 230 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(observers_.HasObserver(observer));
   observers_.RemoveObserver(observer);
 }
 
 void SyncEncryptionHandlerImpl::Init() {
   DCHECK(thread_checker_.CalledOnValidThread());
   WriteTransaction trans(FROM_HERE, user_share_);
   WriteNode node(&trans);
 
-  if (node.InitByTagLookup(kNigoriTag) != BaseNode::INIT_OK)
+  if (node.InitTypeRoot(NIGORI) != BaseNode::INIT_OK)
     return;
   if (!ApplyNigoriUpdateImpl(node.GetNigoriSpecifics(),
                              trans.GetWrappedTrans())) {
     WriteEncryptionStateToNigori(&trans);
   }
 
   bool has_pending_keys = UnlockVault(
       trans.GetWrappedTrans()).cryptographer.has_pending_keys();
   bool is_ready = UnlockVault(
       trans.GetWrappedTrans()).cryptographer.is_ready();
@@ skipping 63 matching lines @@
   // We do not accept empty passphrases.
   if (passphrase.empty()) {
     NOTREACHED() << "Cannot encrypt with an empty passphrase.";
     return;
   }
 
   // All accesses to the cryptographer are protected by a transaction.
   WriteTransaction trans(FROM_HERE, user_share_);
   KeyParams key_params = {"localhost", "dummy", passphrase};
   WriteNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != BaseNode::INIT_OK) {
+  if (node.InitTypeRoot(NIGORI) != BaseNode::INIT_OK) {
     NOTREACHED();
     return;
   }
 
   Cryptographer* cryptographer =
       &UnlockVaultMutable(trans.GetWrappedTrans())->cryptographer;
 
   // Once we've migrated to keystore, the only way to set a passphrase for
   // encryption is to set a custom passphrase.
   if (IsNigoriMigratedToKeystore(node.GetNigoriSpecifics())) {
@@ skipping 131 matching lines @@
   // We do not accept empty passphrases.
   if (passphrase.empty()) {
     NOTREACHED() << "Cannot decrypt with an empty passphrase.";
     return;
   }
 
   // All accesses to the cryptographer are protected by a transaction.
   WriteTransaction trans(FROM_HERE, user_share_);
   KeyParams key_params = {"localhost", "dummy", passphrase};
   WriteNode node(&trans);
-  if (node.InitByTagLookup(kNigoriTag) != BaseNode::INIT_OK) {
+  if (node.InitTypeRoot(NIGORI) != BaseNode::INIT_OK) {
     NOTREACHED();
     return;
   }
 
   // Once we've migrated to keystore, we're only ever decrypting keys derived
   // from an explicit passphrase. But, for clients without a keystore key yet
   // (either not on by default or failed to download one), we still support
   // decrypting with a gaia passphrase, and therefore bypass the
   // DecryptPendingKeysWithExplicitPassphrase logic.
   if (IsNigoriMigratedToKeystore(node.GetNigoriSpecifics()) &&
@@ skipping 212 matching lines @@
       cryptographer->encryptor());
   DCHECK_EQ(keystore_bootstrap.empty(), keystore_key_.empty());
   FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
                     OnBootstrapTokenUpdated(keystore_bootstrap,
                                             KEYSTORE_BOOTSTRAP_TOKEN));
   DVLOG(1) << "Keystore bootstrap token updated.";
 
   // If this is a first time sync, we get the encryption keys before we process
   // the nigori node. Just return for now, ApplyNigoriUpdate will be invoked
   // once we have the nigori node.
-  syncable::Entry entry(trans, syncable::GET_BY_SERVER_TAG, kNigoriTag);
+  syncable::Entry entry(trans, syncable::GET_TYPE_ROOT, NIGORI);
   if (!entry.good())
     return true;
 
   const sync_pb::NigoriSpecifics& nigori =
       entry.GetSpecifics().nigori();
   if (cryptographer->has_pending_keys() &&
       IsNigoriMigratedToKeystore(nigori) &&
       !nigori.keystore_decryptor_token().blob().empty()) {
     // If the nigori is already migrated and we have pending keys, we might
     // be able to decrypt them using either the keystore decryptor token
@@ skipping 27 matching lines @@
 
 ModelTypeSet SyncEncryptionHandlerImpl::GetEncryptedTypesUnsafe() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return vault_unsafe_.encrypted_types;
 }
 
 bool SyncEncryptionHandlerImpl::MigratedToKeystore() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ReadTransaction trans(FROM_HERE, user_share_);
   ReadNode nigori_node(&trans);
-  if (nigori_node.InitByTagLookup(kNigoriTag) != BaseNode::INIT_OK)
+  if (nigori_node.InitTypeRoot(NIGORI) != BaseNode::INIT_OK)
     return false;
   return IsNigoriMigratedToKeystore(nigori_node.GetNigoriSpecifics());
 }
 
 base::Time SyncEncryptionHandlerImpl::migration_time() const {
   return migration_time_;
 }
 
 base::Time SyncEncryptionHandlerImpl::custom_passphrase_time() const {
   return custom_passphrase_time_;
 }
 
 // This function iterates over all encrypted types.  There are many scenarios in
 // which data for some or all types is not currently available.  In that case,
 // the lookup of the root node will fail and we will skip encryption for that
 // type.
 void SyncEncryptionHandlerImpl::ReEncryptEverything(
     WriteTransaction* trans) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(UnlockVault(trans->GetWrappedTrans()).cryptographer.is_ready());
   for (ModelTypeSet::Iterator iter =
            UnlockVault(trans->GetWrappedTrans()).encrypted_types.First();
        iter.Good(); iter.Inc()) {
     if (iter.Get() == PASSWORDS || IsControlType(iter.Get()))
       continue; // These types handle encryption differently.
 
     ReadNode type_root(trans);
-    std::string tag = ModelTypeToRootTag(iter.Get());
-    if (type_root.InitByTagLookup(tag) != BaseNode::INIT_OK)
+    if (type_root.InitTypeRoot(iter.Get()) != BaseNode::INIT_OK)
       continue; // Don't try to reencrypt if the type's data is unavailable.
 
     // Iterate through all children of this datatype.
     std::queue<int64> to_visit;
     int64 child_id = type_root.GetFirstChildId();
     to_visit.push(child_id);
     while (!to_visit.empty()) {
       child_id = to_visit.front();
       to_visit.pop();
       if (child_id == kInvalidId)
@@ skipping 10 matching lines @@
       // (only rewrite the non-unique folders).
         child.ResetFromSpecifics();
       }
       to_visit.push(child.GetSuccessorId());
     }
   }
 
   // Passwords are encrypted with their own legacy scheme.  Passwords are always
   // encrypted so we don't need to check GetEncryptedTypes() here.
   ReadNode passwords_root(trans);
-  std::string passwords_tag = ModelTypeToRootTag(PASSWORDS);
-  if (passwords_root.InitByTagLookup(passwords_tag) ==
-          BaseNode::INIT_OK) {
+  if (passwords_root.InitTypeRoot(PASSWORDS) == BaseNode::INIT_OK) {
     int64 child_id = passwords_root.GetFirstChildId();
     while (child_id != kInvalidId) {
       WriteNode child(trans);
       if (child.InitByIdLookup(child_id) != BaseNode::INIT_OK) {
         NOTREACHED();
         return;
       }
       child.SetPasswordSpecifics(child.GetPasswordSpecifics());
       child_id = child.GetSuccessorId();
     }
@@ skipping 164 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   WriteTransaction trans(FROM_HERE, user_share_);
   WriteEncryptionStateToNigori(&trans);
 }
 
 void SyncEncryptionHandlerImpl::WriteEncryptionStateToNigori(
     WriteTransaction* trans) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WriteNode nigori_node(trans);
   // This can happen in tests that don't have nigori nodes.
-  if (nigori_node.InitByTagLookup(kNigoriTag) != BaseNode::INIT_OK)
+  if (nigori_node.InitTypeRoot(NIGORI) != BaseNode::INIT_OK)
     return;
 
   sync_pb::NigoriSpecifics nigori = nigori_node.GetNigoriSpecifics();
   const Cryptographer& cryptographer =
       UnlockVault(trans->GetWrappedTrans()).cryptographer;
 
   // Will not do anything if we shouldn't or can't migrate. Otherwise
   // migrates, writing the full encryption state as it does.
   if (!AttemptToMigrateNigoriToKeystore(trans, &nigori_node)) {
     if (cryptographer.is_ready() &&
@@ skipping 615 matching lines @@
 
 base::Time SyncEncryptionHandlerImpl::GetExplicitPassphraseTime() const {
   if (passphrase_type_ == FROZEN_IMPLICIT_PASSPHRASE)
     return migration_time();
   else if (passphrase_type_ == CUSTOM_PASSPHRASE)
     return custom_passphrase_time();
   return base::Time();
 }
 
 }  // namespace browser_sync