Simple offline startup integration test.

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/google_service_auth_error.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"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/live_sync/profile_sync_service_test_harness.h"
 #include "chrome/test/ui_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 72 matching lines @@
       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() {
   service_ = profile_->GetProfileSyncService();
   service_->StartUp();
   service_->AddObserver(this);
-  return WaitForServiceInit();
+  return WaitForServiceInit(false);
+}
+
+bool ProfileSyncServiceTestHarness::RetryAuthentication() {
+  wait_state_ = WAITING_FOR_ON_BACKEND_INITIALIZED;
+  return WaitForServiceInit(true);
 }
 
 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_ON_AUTH_ERROR: {
       SignalStateCompleteWithNextState(WAITING_FOR_ON_BACKEND_INITIALIZED);
       break;
     }
     case WAITING_FOR_ON_BACKEND_INITIALIZED: {
+      if (service_->GetAuthError().state() != GoogleServiceAuthError::NONE) {
+        SignalStateCompleteWithNextState(AUTH_ERROR);
+      }
       if (service_->sync_initialized()) {
         SignalStateCompleteWithNextState(WAITING_FOR_NOTIFICATIONS_ENABLED);
       }
       break;
     }
     case WAITING_FOR_NOTIFICATIONS_ENABLED: {
       if (status.notifications_enabled) {
         SignalStateCompleteWithNextState(FULLY_SYNCED);
       }
       break;
@@ skipping 117 matching lines @@
   MessageLoopForUI* loop = MessageLoopForUI::current();
   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 OnAuthError() callback.
-  EXPECT_EQ(wait_state_, WAITING_FOR_ON_AUTH_ERROR);
-  EXPECT_TRUE(AwaitStatusChangeWithTimeout(30,
-      "Waiting for the OnAuthError() callback.")) <<
-      "OnAuthError() not seen after 30 seconds.";
+bool ProfileSyncServiceTestHarness::WaitForServiceInit(bool is_auth_retry) {
+  if (!is_auth_retry) {
+    // Wait for the OnAuthError() callback.
+    EXPECT_EQ(wait_state_, WAITING_FOR_ON_AUTH_ERROR);
+    EXPECT_TRUE(AwaitStatusChangeWithTimeout(30,
+        "Waiting for the OnAuthError() callback.")) <<
+        "OnAuthError() not seen after 30 seconds.";
+  }
 
   // Enter GAIA credentials and wait for the OnBackendInitialized() callback.
   service_->backend()->Authenticate(username_, password_, std::string());
   EXPECT_EQ(wait_state_, WAITING_FOR_ON_BACKEND_INITIALIZED);
   EXPECT_TRUE(AwaitStatusChangeWithTimeout(30,
       "Waiting for OnBackendInitialized().")) <<
       "OnBackendInitialized() not seen after 30 seconds.";
 
+  if (wait_state_ == AUTH_ERROR) {
+    return false;
+  }
+
   // Choose datatypes to be synced and wait for notifications_enabled to be set
   // to true.
   syncable::ModelTypeSet set;
   for (int i = syncable::FIRST_REAL_MODEL_TYPE;
       i < syncable::MODEL_TYPE_COUNT; ++i) {
     set.insert(syncable::ModelTypeFromInt(i));
   }
   service_->OnUserChoseDatatypes(true, set);
   EXPECT_EQ(wait_state_, WAITING_FOR_NOTIFICATIONS_ENABLED);
   EXPECT_TRUE(AwaitStatusChangeWithTimeout(30,
       "Waiting for notifications_enabled to be set to true.")) <<
       "notifications_enabled not set to true after 30 seconds.";
 
   return true;
 }
 
 const SyncSessionSnapshot*
     ProfileSyncServiceTestHarness::GetLastSessionSnapshot() const {
   EXPECT_FALSE(service_ == NULL) << "Sync service has not yet been set up.";
   return service_->backend()->GetLastSessionSnapshot();
 }