Refactor sync passphrase setup flow and fix passphrase tests

chrome/browser/sync/glue/sync_backend_host.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 "build/build_config.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 510 matching lines @@
 bool SyncBackendHost::RequestClearServerData() {
   core_thread_.message_loop()->PostTask(FROM_HERE,
      NewRunnableMethod(core_.get(),
      &SyncBackendHost::Core::DoRequestClearServerData));
   return true;
 }
 
 SyncBackendHost::Core::~Core() {
 }
 
-void SyncBackendHost::Core::NotifyPassphraseRequired(bool for_decryption) {
+void SyncBackendHost::Core::NotifyPassphraseRequired(
+    sync_api::PassphraseRequiredReason reason) {
   if (!host_ || !host_->frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
 
+  // When setting a passphrase fails, unset our waiting flag.
+  if (reason == sync_api::REASON_SET_PASSPHRASE_FAILED)
+    processing_passphrase_ = false;
+
   if (processing_passphrase_) {
     VLOG(1) << "Core received OnPassphraseRequired while processing a "
             << "passphrase. Silently dropping.";
     return;
   }
-  host_->frontend_->OnPassphraseRequired(for_decryption);
-}
 
-void SyncBackendHost::Core::NotifyPassphraseFailed() {
-  if (!host_ || !host_->frontend_)
-    return;
-
-  DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
-
-  // When a passphrase fails, we just unset our waiting flag and trigger a
-  // OnPassphraseRequired(true).
-  processing_passphrase_ = false;
-  host_->frontend_->OnPassphraseRequired(true);
+  host_->frontend_->OnPassphraseRequired(reason);
 }
 
 void SyncBackendHost::Core::NotifyPassphraseAccepted(
     const std::string& bootstrap_token) {
   if (!host_ || !host_->frontend_)
     return;
 
   DCHECK_EQ(MessageLoop::current(), host_->frontend_loop_);
 
   processing_passphrase_ = false;
@@ skipping 400 matching lines @@
   return worker->CurrentThreadIsWorkThread();
 }
 
 void SyncBackendHost::Core::OnAuthError(const AuthError& auth_error) {
   // Post to our core loop so we can modify state. Could be on another thread.
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::HandleAuthErrorEventOnFrontendLoop,
       auth_error));
 }
 
-void SyncBackendHost::Core::OnPassphraseRequired(bool for_decryption) {
+void SyncBackendHost::Core::OnPassphraseRequired(
+    sync_api::PassphraseRequiredReason reason) {
   host_->frontend_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &Core::NotifyPassphraseRequired, for_decryption));
-}
-
-void SyncBackendHost::Core::OnPassphraseFailed() {
-  host_->frontend_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &Core::NotifyPassphraseFailed));
+      NewRunnableMethod(this, &Core::NotifyPassphraseRequired, reason));
 }
 
 void SyncBackendHost::Core::OnPassphraseAccepted(
     const std::string& bootstrap_token) {
   host_->frontend_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &Core::NotifyPassphraseAccepted,
           bootstrap_token));
 }
 
 void SyncBackendHost::Core::OnStopSyncingPermanently() {
@@ skipping 161 matching lines @@
   DCHECK_EQ(MessageLoop::current(), host_->core_thread_.message_loop());
   syncapi_->GetJsBackend()->ProcessMessage(name, args, sender);
 }
 
 void SyncBackendHost::Core::DeferNudgeForCleanup() {
   DCHECK_EQ(MessageLoop::current(), host_->core_thread_.message_loop());
   deferred_nudge_for_cleanup_requested_ = true;
 }
 
 }  // namespace browser_sync