sync: Make BaseNode lookup-related Init functions return specific failures.

chrome/browser/sync/internal_api/sync_manager.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/internal_api/sync_manager.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 1062 matching lines @@
     done_callback.Run();  // Should only happen during first time sync.
     return;
   }
 
   bool success = false;
   {
     WriteTransaction trans(FROM_HERE, GetUserShare());
     Cryptographer* cryptographer = trans.GetCryptographer();
     WriteNode node(&trans);
 
-    if (node.InitByTagLookup(kNigoriTag)) {
+    if (node.InitByTagLookup(kNigoriTag) == sync_api::BaseNode::INIT_OK) {
       sync_pb::NigoriSpecifics nigori(node.GetNigoriSpecifics());
       Cryptographer::UpdateResult result = cryptographer->Update(nigori);
       if (result == Cryptographer::NEEDS_PASSPHRASE) {
         sync_pb::EncryptedData pending_keys;
         if (cryptographer->has_pending_keys())
           pending_keys = cryptographer->GetPendingKeys();
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                           OnPassphraseRequired(sync_api::REASON_DECRYPTION,
                                                pending_keys));
       }
@@ skipping 152 matching lines @@
 }
 
 void SyncManager::SyncInternal::MaybeSetSyncTabsInNigoriNode(
     const ModelTypeSet enabled_types) {
   // The initialized_ check is to ensure that we don't CHECK in GetUserShare
   // when this is called on start-up. It's ok to ignore that case, since
   // presumably this would've run when the user originally enabled sessions.
   if (initialized_ && enabled_types.Has(syncable::SESSIONS)) {
     WriteTransaction trans(FROM_HERE, GetUserShare());
     WriteNode node(&trans);
-    if (!node.InitByTagLookup(kNigoriTag)) {
+    if (node.InitByTagLookup(kNigoriTag) != sync_api::BaseNode::INIT_OK) {
       LOG(WARNING) << "Unable to set 'sync_tabs' bit because Nigori node not "
                    << "found.";
       return;
     }
 
     sync_pb::NigoriSpecifics specifics(node.GetNigoriSpecifics());
     specifics.set_sync_tabs(true);
     node.SetNigoriSpecifics(specifics);
   }
 }
 
 void SyncManager::SyncInternal::SetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   // 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, GetUserShare());
   Cryptographer* cryptographer = trans.GetCryptographer();
   KeyParams key_params = {"localhost", "dummy", passphrase};
   WriteNode node(&trans);
-  if (!node.InitByTagLookup(kNigoriTag)) {
+  if (node.InitByTagLookup(kNigoriTag) != sync_api::BaseNode::INIT_OK) {
     // TODO(albertb): Plumb an UnrecoverableError all the way back to the PSS.
     NOTREACHED();
     return;
   }
 
   bool nigori_has_explicit_passphrase =
       node.GetNigoriSpecifics().using_explicit_passphrase();
   std::string bootstrap_token;
   sync_pb::EncryptedData pending_keys;
   if (cryptographer->has_pending_keys())
@@ skipping 93 matching lines @@
   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, GetUserShare());
   Cryptographer* cryptographer = trans.GetCryptographer();
   KeyParams key_params = {"localhost", "dummy", passphrase};
   WriteNode node(&trans);
-  if (!node.InitByTagLookup(kNigoriTag)) {
+  if (node.InitByTagLookup(kNigoriTag) != sync_api::BaseNode::INIT_OK) {
     // TODO(albertb): Plumb an UnrecoverableError all the way back to the PSS.
     NOTREACHED();
     return;
   }
 
   if (!cryptographer->has_pending_keys()) {
     // Note that this *can* happen in a rare situation where data is
     // re-encrypted on another client while a SetDecryptionPassphrase() call is
     // in-flight on this client. It is rare enough that we choose to do nothing.
     NOTREACHED() << "Attempt to set decryption passphrase failed because there "
@@ skipping 168 matching lines @@
   nigori_node->SetNigoriSpecifics(specifics);
 
   // Does nothing if everything is already encrypted or the cryptographer has
   // pending keys.
   ReEncryptEverything(trans);
 }
 
 bool SyncManager::SyncInternal::IsUsingExplicitPassphrase() {
   ReadTransaction trans(FROM_HERE, &share_);
   ReadNode node(&trans);
-  if (!node.InitByTagLookup(kNigoriTag)) {
+  if (node.InitByTagLookup(kNigoriTag) != sync_api::BaseNode::INIT_OK) {
     // TODO(albertb): Plumb an UnrecoverableError all the way back to the PSS.
     NOTREACHED();
     return false;
   }
 
   return node.GetNigoriSpecifics().using_explicit_passphrase();
 }
 
 void SyncManager::SyncInternal::RefreshEncryption() {
   DCHECK(initialized_);
 
   WriteTransaction trans(FROM_HERE, GetUserShare());
   WriteNode node(&trans);
-  if (!node.InitByTagLookup(kNigoriTag)) {
+  if (node.InitByTagLookup(kNigoriTag) != sync_api::BaseNode::INIT_OK) {
     NOTREACHED() << "Unable to set encrypted datatypes because Nigori node not "
                  << "found.";
     return;
   }
 
   Cryptographer* cryptographer = trans.GetCryptographer();
 
   if (!cryptographer->is_ready()) {
     DVLOG(1) << "Attempting to encrypt datatypes when cryptographer not "
              << "initialized, prompting for passphrase.";
@@ skipping 26 matching lines @@
   registrar_->GetModelSafeRoutingInfo(&routes);
   std::string tag;
   for (syncable::ModelTypeSet::Iterator iter = encrypted_types.First();
        iter.Good(); iter.Inc()) {
     if (iter.Get() == syncable::PASSWORDS ||
         iter.Get() == syncable::NIGORI ||
         routes.count(iter.Get()) == 0)
       continue;
     ReadNode type_root(trans);
     tag = syncable::ModelTypeToRootTag(iter.Get());
-    if (!type_root.InitByTagLookup(tag)) {
+    if (type_root.InitByTagLookup(tag) != sync_api::BaseNode::INIT_OK) {
       // This can happen when we enable a datatype for the first time on restart
       // (for example when we upgrade) and therefore haven't done the initial
       // download for that type at the time we RefreshEncryption. There's
       // nothing we can do for now, so just move on to the next type.
       continue;
     }
 
     // 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)
         continue;
 
       WriteNode child(trans);
-      if (!child.InitByIdLookup(child_id)) {
+      if (child.InitByIdLookup(child_id) != sync_api::BaseNode::INIT_OK) {
         NOTREACHED();
         continue;
       }
       if (child.GetIsFolder()) {
         to_visit.push(child.GetFirstChildId());
       }
       if (child.GetEntry()->Get(syncable::UNIQUE_SERVER_TAG).empty()) {
       // Rewrite the specifics of the node with encrypted data if necessary
       // (only rewrite the non-unique folders).
         child.ResetFromSpecifics();
       }
       to_visit.push(child.GetSuccessorId());
     }
   }
 
   if (routes.count(syncable::PASSWORDS) > 0) {
     // Passwords are encrypted with their own legacy scheme.
     ReadNode passwords_root(trans);
     std::string passwords_tag =
         syncable::ModelTypeToRootTag(syncable::PASSWORDS);
     // It's possible we'll have the password routing info and not the password
     // root if we attempted to set a passphrase before passwords was enabled.
-    if (passwords_root.InitByTagLookup(passwords_tag)) {
+    if (passwords_root.InitByTagLookup(passwords_tag) ==
+            sync_api::BaseNode::INIT_OK) {
       int64 child_id = passwords_root.GetFirstChildId();
       while (child_id != kInvalidId) {
         WriteNode child(trans);
-        if (!child.InitByIdLookup(child_id)) {
+        if (child.InitByIdLookup(child_id) != sync_api::BaseNode::INIT_OK) {
           NOTREACHED();
           return;
         }
         child.SetPasswordSpecifics(child.GetPasswordSpecifics());
         child_id = child.GetSuccessorId();
       }
     }
   }
 
   // NOTE: We notify from within a transaction.
@@ skipping 382 matching lines @@
       LOG(INFO) << "OnSyncCycleCompleted not sent because sync api is not "
                 << "initialized";
       return;
     }
 
     if (!event.snapshot->has_more_to_sync) {
       // To account for a nigori node arriving with stale/bad data, we ensure
       // that the nigori node is up to date at the end of each cycle.
       WriteTransaction trans(FROM_HERE, GetUserShare());
       WriteNode nigori_node(&trans);
-      if (nigori_node.InitByTagLookup(kNigoriTag)) {
+      if (nigori_node.InitByTagLookup(kNigoriTag) ==
+              sync_api::BaseNode::INIT_OK) {
         Cryptographer* cryptographer = trans.GetCryptographer();
         UpdateNigoriEncryptionState(cryptographer, &nigori_node);
       }
 
       DVLOG(1) << "Sending OnSyncCycleCompleted";
       FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                         OnSyncCycleCompleted(event.snapshot));
     }
 
     // This is here for tests, which are still using p2p notifications.
@@ skipping 159 matching lines @@
   ListValue* id_list = NULL;
   ReadTransaction trans(FROM_HERE, user_share);
   if (args.Get().GetList(0, &id_list)) {
     CHECK(id_list);
     for (size_t i = 0; i < id_list->GetSize(); ++i) {
       int64 id = GetId(*id_list, i);
       if (id == kInvalidId) {
         continue;
       }
       ReadNode node(&trans);
-      if (!node.InitByIdLookup(id)) {
+      if (node.InitByIdLookup(id) != sync_api::BaseNode::INIT_OK) {
         continue;
       }
       node_summaries->Append((node.*info_getter)());
     }
   }
   return JsArgList(&return_args);
 }
 
 }  // namespace
 
@@ skipping 187 matching lines @@
 
 syncable::ModelTypeSet SyncManager::GetEncryptedDataTypesForTest() const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   return GetEncryptedTypes(&trans);
 }
 
 bool SyncManager::ReceivedExperimentalTypes(syncable::ModelTypeSet* to_add)
     const {
   ReadTransaction trans(FROM_HERE, GetUserShare());
   ReadNode node(&trans);
-  if (!node.InitByTagLookup(kNigoriTag)) {
+  if (node.InitByTagLookup(kNigoriTag) != sync_api::BaseNode::INIT_OK) {
     DVLOG(1) << "Couldn't find Nigori node.";
     return false;
   }
   if (node.GetNigoriSpecifics().sync_tabs()) {
     to_add->Put(syncable::SESSIONS);
     return true;
   }
   return false;
 }
 
@@ skipping 70 matching lines @@
     share->directory->GetDownloadProgress(i.Get(), &marker);
 
     if (marker.token().empty())
       result.Put(i.Get());
 
   }
   return result;
 }
 
 }  // namespace sync_api