Refactor sync passphrase setup flow and fix passphrase tests

chrome/browser/sync/engine/syncapi.cc

 // Copyright (c) 2011 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/engine/syncapi.h"
 
 #include <algorithm>
 #include <bitset>
 #include <iomanip>
 #include <list>
@@ skipping 153 matching lines @@
                                     std::wstring* out) {
   int length_to_copy = server_name.length();
   if (IsNameServerIllegalAfterTrimming(server_name) &&
       EndsWithSpace(server_name))
     --length_to_copy;
   if (!UTF8ToWide(server_name.c_str(), length_to_copy, out)) {
     NOTREACHED() << "Could not convert server name from UTF8 to wide";
   }
 }
 
+// Helper function that converts a PassphraseRequiredReason value to a string.
+std::string PassphraseRequiredReasonToString(
+    PassphraseRequiredReason reason) {
+  switch (reason) {
+    case REASON_PASSPHRASE_NOT_REQUIRED:
+      return "REASON_PASSPHRASE_NOT_REQUIRED";
+    case REASON_ENCRYPTION:
+      return "REASON_ENCRYPTION";
+    case REASON_DECRYPTION:
+      return "REASON_DECRYPTION";
+    case REASON_SET_PASSPHRASE_FAILED:
+      return "REASON_SET_PASSPHRASE_FAILED";
+    default:
+      NOTREACHED();
+      return "INVALID_REASON";
+  }
+}
+
 UserShare::UserShare() {}
 
 UserShare::~UserShare() {}
 
 ////////////////////////////////////
 // BaseNode member definitions.
 
 BaseNode::BaseNode() {}
 
 BaseNode::~BaseNode() {}
@@ skipping 1599 matching lines @@
       return;
     }
 
     nigori.CopyFrom(node.GetNigoriSpecifics());
     if (!nigori.encrypted().blob().empty()) {
       if (cryptographer->CanDecrypt(nigori.encrypted())) {
         cryptographer->SetKeys(nigori.encrypted());
       } else {
         cryptographer->SetPendingKeys(nigori.encrypted());
         FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                          OnPassphraseRequired(true));
+                          OnPassphraseRequired(sync_api::REASON_DECRYPTION));
       }
     }
   }
 
   // Refresh list of encrypted datatypes.
   syncable::ModelTypeSet encrypted_types =
       syncable::GetEncryptedDataTypesFromNigori(nigori);
 
   // Ensure any datatypes that need encryption are encrypted.
   EncryptDataTypes(encrypted_types);
@@ skipping 141 matching lines @@
     const std::string& passphrase, bool is_explicit) {
   // All accesses to the cryptographer are protected by a transaction.
   WriteTransaction trans(GetUserShare());
   Cryptographer* cryptographer = trans.GetCryptographer();
   KeyParams params = {"localhost", "dummy", passphrase};
 
   if (cryptographer->has_pending_keys()) {
     if (!cryptographer->DecryptPendingKeys(params)) {
       VLOG(1) << "Passphrase failed to decrypt pending keys.";
       FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                        OnPassphraseFailed());
+          OnPassphraseRequired(sync_api::REASON_SET_PASSPHRASE_FAILED));
       return;
     }
 
     // TODO(tim): If this is the first time the user has entered a passphrase
     // since the protocol changed to store passphrase preferences in the cloud,
     // make sure we update this preference. See bug 62103.
     if (is_explicit)
       SetUsingExplicitPassphrasePrefForMigration(&trans);
 
     // Nudge the syncer so that encrypted datatype updates that were waiting for
@@ skipping 521 matching lines @@
           if (!nigori.encrypted().blob().empty()) {
             DCHECK(!cryptographer->CanDecrypt(nigori.encrypted()));
             cryptographer->SetPendingKeys(nigori.encrypted());
           }
         }
 
         // If we've completed a sync cycle and the cryptographer isn't ready
         // yet, prompt the user for a passphrase.
         if (cryptographer->has_pending_keys()) {
           FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                            OnPassphraseRequired(true));
+                            OnPassphraseRequired(sync_api::REASON_DECRYPTION));
         } else if (!cryptographer->is_ready()) {
           FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
-                            OnPassphraseRequired(false));
+                            OnPassphraseRequired(sync_api::REASON_ENCRYPTION));
         } else {
           FOR_EACH_OBSERVER(SyncManager::Observer, observers_,
                             OnEncryptionComplete(encrypted_types));
         }
       }
     }
 
     if (!initialized())
       return;
 
@@ skipping 310 matching lines @@
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 }  // namespace sync_api