Fix passphrase initialization flow in ProfileSyncServiceHarness

chrome/browser/sync/profile_sync_service_harness.cc

 // Copyright (c) 2010 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 "base/message_loop.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/net/gaia/token_service.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
@@ skipping 77 matching lines @@
     const std::string& username,
     const std::string& password,
     int id)
     : wait_state_(INITIAL_WAIT_STATE),
       profile_(profile),
       service_(NULL),
       last_timestamp_(0),
       min_timestamp_needed_(kMinTimestampNeededNone),
       username_(username),
       password_(password),
-      passphrase_acceptance_counter_(0),
       id_(id) {
   if (IsSyncAlreadySetup()) {
     service_ = profile_->GetProfileSyncService();
     service_->AddObserver(this);
     wait_state_ = FULLY_SYNCED;
   }
 }
 
 // static
 ProfileSyncServiceHarness* ProfileSyncServiceHarness::CreateAndAttach(
@@ skipping 17 matching lines @@
 
 bool ProfileSyncServiceHarness::SetupSync() {
   syncable::ModelTypeSet synced_datatypes;
   for (int i = syncable::FIRST_REAL_MODEL_TYPE;
       i < syncable::MODEL_TYPE_COUNT; ++i) {
     synced_datatypes.insert(syncable::ModelTypeFromInt(i));
   }
   return SetupSync(synced_datatypes);
 }
 
-void ProfileSyncServiceHarness::StartObservingPassphraseEvents() {
-  // Prime the counter to account for the implicit set passphrase due to
-  // gaia login.
-  passphrase_acceptance_counter_--;
-  registrar_.Add(this, NotificationType::SYNC_PASSPHRASE_ACCEPTED,
-      Source<browser_sync::SyncBackendHost>(service_->backend()));
-  registrar_.Add(this, NotificationType::SYNC_PASSPHRASE_REQUIRED,
-      Source<browser_sync::SyncBackendHost>(service_->backend()));
-}
-
 bool ProfileSyncServiceHarness::SetupSync(
     const syncable::ModelTypeSet& synced_datatypes) {
   // Initialize the sync client's profile sync service object.
   service_ = profile_->GetProfileSyncService();
   if (service_ == NULL) {
     LOG(ERROR) << "SetupSync(): service_ is null.";
     return false;
   }
 
   // Subscribe sync client to notifications from the profile sync service.
@@ skipping 22 matching lines @@
   // Wait for a passphrase to be required.
   DCHECK_EQ(wait_state_, WAITING_FOR_PASSPHRASE_REQUIRED);
   if (!AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
       "Waiting for Passphrase required.")) {
     LOG(ERROR) << "Passphrase required not seen after "
                << kLiveSyncOperationTimeoutMs / 1000
                << " seconds.";
     return false;
   }
 
-  DCHECK(service()->observed_passphrase_required());
-  if (id_ == 0)
-    DCHECK(!service()->passphrase_required_for_decryption());
-
   // Wait for initial gaia passphrase to be accepted.
   DCHECK_EQ(wait_state_, WAITING_FOR_PASSPHRASE_ACCEPTED);
   if (!AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
       "Waiting for Passphrase accept.")) {
     LOG(ERROR) << "Passphrase accept not seen after "
                << kLiveSyncOperationTimeoutMs / 1000
                << " seconds.";
     return false;
   }
 
@@ skipping 22 matching lines @@
 void ProfileSyncServiceHarness::SignalStateComplete() {
   MessageLoop::current()->Quit();
 }
 
 bool ProfileSyncServiceHarness::RunStateChangeMachine() {
   WaitState original_wait_state = wait_state_;
   switch (wait_state_) {
     case WAITING_FOR_ON_BACKEND_INITIALIZED: {
       LogClientInfo("WAITING_FOR_ON_BACKEND_INITIALIZED");
       if (service()->sync_initialized()) {
-        // The sync backend is initialized.  Watch for passphrase events.
-        StartObservingPassphraseEvents();
+        // The sync backend is initialized. We now wait for passphrase events.
         SignalStateCompleteWithNextState(WAITING_FOR_PASSPHRASE_REQUIRED);
       }
       break;
     }
     case WAITING_FOR_PASSPHRASE_REQUIRED: {
       LogClientInfo("WAITING_FOR_PASSPHRASE_REQUIRED");
-      if (service_->observed_passphrase_required())
+      if (service()->observed_passphrase_required()) {
+        // Special case when the first client signs in to sync.
+        if (id_ == 0)
+          DCHECK(!service()->passphrase_required_for_decryption());
+        // The SYNC_PASSPHRASE_REQUIRED notification has been seen.
         SignalStateCompleteWithNextState(WAITING_FOR_PASSPHRASE_ACCEPTED);
+      }
       break;
     }
     case WAITING_FOR_PASSPHRASE_ACCEPTED: {
       LogClientInfo("WAITING_FOR_PASSPHRASE_ACCEPTED");
-      if (passphrase_acceptance_counter_ >= 0)
+      if (service()->ShouldPushChanges())
+        // The SYNC_PASSPHRASE_ACCEPTED notification has been seen.
         SignalStateCompleteWithNextState(WAITING_FOR_INITIAL_SYNC);
       break;
     }
     case WAITING_FOR_INITIAL_SYNC: {
       LogClientInfo("WAITING_FOR_INITIAL_SYNC");
       if (IsSynced()) {
         // The first sync cycle is now complete. We can start running tests.
         SignalStateCompleteWithNextState(FULLY_SYNCED);
       }
       break;
@@ skipping 53 matching lines @@
 void ProfileSyncServiceHarness::OnStateChanged() {
   RunStateChangeMachine();
 }
 
 bool ProfileSyncServiceHarness::AwaitPassphraseAccepted() {
   LogClientInfo("AwaitPassphraseAccepted");
   if (wait_state_ == SYNC_DISABLED) {
     LOG(ERROR) << "Sync disabled for Client " << id_ << ".";
     return false;
   }
-  passphrase_acceptance_counter_--;
-  if (passphrase_acceptance_counter_ >= 0)
-    return true;
   wait_state_ = WAITING_FOR_PASSPHRASE_ACCEPTED;
   return AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
                                       "Waiting for passphrase accepted.");
 }
 
-void ProfileSyncServiceHarness::Observe(NotificationType type,
-                                        const NotificationSource& source,
-                                        const NotificationDetails& details) {
-  if (NotificationType::SYNC_PASSPHRASE_ACCEPTED == type.value) {
-    passphrase_acceptance_counter_++;
-    RunStateChangeMachine();
-  } else if (NotificationType::SYNC_PASSPHRASE_REQUIRED == type.value) {
-    RunStateChangeMachine();
-  }
-}
-
 bool ProfileSyncServiceHarness::AwaitSyncCycleCompletion(
     const std::string& reason) {
   LogClientInfo("AwaitSyncCycleCompletion");
   if (wait_state_ == SYNC_DISABLED) {
     LOG(ERROR) << "Sync disabled for Client " << id_ << ".";
     return false;
   }
   if (!IsSynced()) {
     if (wait_state_ == SERVER_UNREACHABLE) {
       // Client was offline; wait for it to go online, and then wait for sync.
@@ skipping 236 matching lines @@
               << ", service_is_pushing_changes: " << ServiceIsPushingChanges();
     } else {
       VLOG(1) << "Client " << id_ << ": " << message
               << ": Sync session snapshot not available.";
     }
   } else {
     VLOG(1) << "Client " << id_ << ": " << message
             << ": Sync service not available.";
   }
 }