Refactor the wait code in ProfileSyncServiceTestHarness.

chrome/test/live_sync/profile_sync_service_test_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/browser.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/sessions/session_state.h"
@@ skipping 66 matching lines @@
 }
 
 bool StateChangeTimeoutEvent::Abort() {
   aborted_ = true;
   caller_ = NULL;
   return !did_timeout_;
 }
 
 ProfileSyncServiceTestHarness::ProfileSyncServiceTestHarness(
     Profile* p, const std::string& username, const std::string& password)
-    : wait_state_(WAITING_FOR_INITIAL_CALLBACK), profile_(p), service_(NULL),
+    : wait_state_(WAITING_FOR_ON_AUTH_ERROR), profile_(p), service_(NULL),
       last_status_(kInvalidStatus),
       last_timestamp_(0),
       min_timestamp_needed_(kMinTimestampNeededNone),
       username_(username), password_(password) {
   // Ensure the profile has enough prefs registered for use by sync.
   if (!p->GetPrefs()->FindPreference(prefs::kAcceptLanguages))
     TabContents::RegisterUserPrefs(p->GetPrefs());
 }
 
 bool ProfileSyncServiceTestHarness::SetupSync() {
+  syncable::ModelTypeSet set;
+  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
+      i < syncable::MODEL_TYPE_COUNT; ++i) {
+    set.insert(syncable::ModelTypeFromInt(i));
+  }
+
   service_ = profile_->GetProfileSyncService();
-  service_->SetSyncSetupCompleted();
-  service_->EnableForUser();
-
-  // Needed to avoid showing the login dialog. Well aware this is egregious.
-  service_->expecting_first_run_auth_needed_event_ = false;
+  service_->StartUp();
+  service_->OnUserChoseDatatypes(true, set);
   service_->AddObserver(this);
   return WaitForServiceInit();
 }
 
 void ProfileSyncServiceTestHarness::SignalStateCompleteWithNextState(
     WaitState next_state) {
 
   wait_state_ = next_state;
   SignalStateComplete();
 }
 
 void ProfileSyncServiceTestHarness::SignalStateComplete() {
   MessageLoopForUI::current()->Quit();
 }
 
 bool ProfileSyncServiceTestHarness::RunStateChangeMachine() {
   WaitState state = wait_state_;
   ProfileSyncService::Status status(service_->QueryDetailedSyncStatus());
   switch (wait_state_) {
-    case WAITING_FOR_INITIAL_CALLBACK:
-      SignalStateCompleteWithNextState(WAITING_FOR_READY_TO_PROCESS_CHANGES);
+    case WAITING_FOR_ON_AUTH_ERROR: {
+      SignalStateCompleteWithNextState(WAITING_FOR_NOTIFICATIONS_ENABLED);
       break;
-    case WAITING_FOR_READY_TO_PROCESS_CHANGES:
-      if (service_->ShouldPushChanges()) {
-        SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
+    }
+    case WAITING_FOR_NOTIFICATIONS_ENABLED: {
+      if (status.notifications_enabled) {
+        SignalStateCompleteWithNextState(FULLY_SYNCED);
       }
       break;
+    }
     case WAITING_FOR_SYNC_TO_FINISH: {
       const SyncSessionSnapshot* snap =
           service_->backend()->GetLastSessionSnapshot();
       DCHECK(snap) << "Should have been at least one sync session by now";
       if (snap->has_more_to_sync)
         break;
 
       EXPECT_LE(last_timestamp_, snap->max_local_timestamp);
       last_timestamp_ = snap->max_local_timestamp;
-      SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
+      SignalStateCompleteWithNextState(FULLY_SYNCED);
       break;
     }
     case WAITING_FOR_UPDATES: {
       const SyncSessionSnapshot* snap =
           service_->backend()->GetLastSessionSnapshot();
       DCHECK(snap) << "Should have been at least one sync session by now";
       if (snap->max_local_timestamp < min_timestamp_needed_)
         break;
 
-      SignalStateCompleteWithNextState(WAITING_FOR_NOTHING);
+      SignalStateCompleteWithNextState(FULLY_SYNCED);
       break;
     }
-    case WAITING_FOR_NOTHING:
+    case FULLY_SYNCED:
     default:
       // Invalid state during observer callback which may be triggered by other
       // classes using the the UI message loop.  Defer to their handling.
       break;
   }
   last_status_ = status;
   return state != wait_state_;
 }
 
 void ProfileSyncServiceTestHarness::OnStateChanged() {
@@ skipping 32 matching lines @@
   loop->PostDelayedTask(
       FROM_HERE,
       NewRunnableMethod(timeout_signal.get(),
                         &StateChangeTimeoutEvent::Callback),
       1000 * timeout_seconds);
   ui_test_utils::RunMessageLoop();
   return timeout_signal->Abort();
 }
 
 bool ProfileSyncServiceTestHarness::WaitForServiceInit() {
-  // Wait for the initial (auth needed) callback.
-  EXPECT_EQ(wait_state_, WAITING_FOR_INITIAL_CALLBACK);
-  if (!AwaitStatusChangeWithTimeout(30, "Waiting for authwatcher calback.")) {
+  // Wait for the OnAuthError() callback.
+  EXPECT_EQ(wait_state_, WAITING_FOR_ON_AUTH_ERROR);
+  if (!AwaitStatusChangeWithTimeout(30,
+      "Waiting for the OnAuthError() callback.")) {
     return false;
   }
 
-  // Wait for the OnBackendInitialized callback.
+  // Enter GAIA credentials and wait for notifications_enabled to be set to
+  // true.
   service_->backend()->Authenticate(username_, password_, std::string());
-  EXPECT_EQ(wait_state_, WAITING_FOR_READY_TO_PROCESS_CHANGES);
-  if (!AwaitStatusChangeWithTimeout(30, "Waiting on backend initialization.")) {
+  EXPECT_EQ(wait_state_, WAITING_FOR_NOTIFICATIONS_ENABLED);
+  if (!AwaitStatusChangeWithTimeout(30,
+      "Waiting for notifications_enabled to be set to true.")) {
     return false;
   }
+
   return service_->sync_initialized();
 }