New authorization framework for sync. ...

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/defaults.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
+#include "chrome/browser/net/gaia/token_service.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/net/gaia/gaia_constants.h"
 #include "chrome/common/net/gaia/google_service_auth_error.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"
 
 // The default value for min_timestamp_needed_ when we're not in the
 // WAITING_FOR_UPDATES state.
 static const int kMinTimestampNeededNone = -1;
 
@@ skipping 54 matching lines @@
 }
 
 bool StateChangeTimeoutEvent::Abort() {
   aborted_ = true;
   caller_ = NULL;
   return !did_timeout_;
 }
 
 ProfileSyncServiceTestHarness::ProfileSyncServiceTestHarness(Profile* p,
     const std::string& username, const std::string& password, int id)
-    : wait_state_(WAITING_FOR_ON_AUTH_ERROR), profile_(p), service_(NULL),
+    : wait_state_(WAITING_FOR_ON_BACKEND_INITIALIZED),
+      profile_(p), service_(NULL),
       last_status_(kInvalidStatus),
       last_timestamp_(0),
       min_timestamp_needed_(kMinTimestampNeededNone),
       username_(username), password_(password), id_(id) {
   // 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_ = profile_->GetProfileSyncService("");
   service_->AddObserver(this);
-  return WaitForServiceInit(false);
-}
+  service_->signin_.StartSignIn(username_, password_, "", "");
 
-bool ProfileSyncServiceTestHarness::RetryAuthentication() {
-  wait_state_ = WAITING_FOR_ON_BACKEND_INITIALIZED;
-  return WaitForServiceInit(true);
+  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_ON_AUTH_ERROR: {
-      LogClientInfo("WAITING_FOR_ON_AUTH_ERROR");
-      SignalStateCompleteWithNextState(WAITING_FOR_ON_BACKEND_INITIALIZED);
-      break;
-    }
     case WAITING_FOR_ON_BACKEND_INITIALIZED: {
       LogClientInfo("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: {
       LogClientInfo("WAITING_FOR_NOTIFICATIONS_ENABLED");
       if (status.notifications_enabled) {
         SignalStateCompleteWithNextState(FULLY_SYNCED);
       }
       break;
     }
+    case WAITING_FOR_SERVER_REACHABLE: {
+      LogClientInfo("WAITING_FOR_SERVER_REACHABLE");
+      const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
+      if (!status.server_reachable) {
+        break;
+      }
+      if (service()->backend()->HasUnsyncedItems() ||
+          snap->has_more_to_sync || snap->unsynced_count != 0) {
+        SignalStateCompleteWithNextState(WAITING_FOR_SYNC_TO_FINISH);
+        break;
+      }
+      last_timestamp_ = snap->max_local_timestamp;
+      SignalStateCompleteWithNextState(FULLY_SYNCED);
+      break;
+    }
     case WAITING_FOR_SYNC_TO_FINISH: {
       LogClientInfo("WAITING_FOR_SYNC_TO_FINISH");
       const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
       DCHECK(snap) << "Should have been at least one sync session by now";
       // TODO(rsimha): In an ideal world, snap->has_more_to_sync == false should
       // be a sufficient condition for sync to have completed. However, the
       // additional check of snap->unsynced_count is required due to
       // http://crbug.com/48989.
-      if (snap->has_more_to_sync || snap->unsynced_count != 0) {
+      if (service()->backend()->HasUnsyncedItems() ||
+          snap->has_more_to_sync || snap->unsynced_count != 0) {
+        if (!status.server_reachable)
+          SignalStateCompleteWithNextState(WAITING_FOR_SERVER_REACHABLE);
         break;
       }
       EXPECT_LE(last_timestamp_, snap->max_local_timestamp);
       last_timestamp_ = snap->max_local_timestamp;
       SignalStateCompleteWithNextState(FULLY_SYNCED);
       break;
     }
     case WAITING_FOR_UPDATES: {
       LogClientInfo("WAITING_FOR_UPDATES");
       const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
@@ skipping 114 matching lines @@
       FROM_HERE,
       NewRunnableMethod(timeout_signal.get(),
                         &StateChangeTimeoutEvent::Callback),
       1000 * timeout_seconds);
   LogClientInfo("Before RunMessageLoop");
   ui_test_utils::RunMessageLoop();
   LogClientInfo("After RunMessageLoop");
   return timeout_signal->Abort();
 }
 
-bool ProfileSyncServiceTestHarness::WaitForServiceInit(bool is_auth_retry) {
+bool ProfileSyncServiceTestHarness::WaitForServiceInit() {
   LogClientInfo("WaitForServiceInit");
-  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());
+  // Wait for the OnBackendInitialized() callback.
   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. Note: This is unnecessary on Chrome OS.
-  if (!browser_defaults::kBootstrapSyncAuthentication) {
-    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);
+  // Choose datatypes to be synced.
+  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);
 
   // Wait for notifications_enabled to be set to true.
   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();
+  if (service_->backend()) {
+    return service_->backend()->GetLastSessionSnapshot();
+  }
+  return NULL;
 }
 
 void ProfileSyncServiceTestHarness::LogClientInfo(std::string message) {
   const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
   if (snap) {
     LOG(INFO) << "Client " << id_ << ": " << message << ": "
         << "has_more_to_sync: " << snap->has_more_to_sync
         << ", max_local_timestamp: " << snap->max_local_timestamp
         << ", unsynced_count: " << snap->unsynced_count
         << ", has_unsynced_items: " << service()->backend()->HasUnsyncedItems()
         << ".";
   } else {
     LOG(INFO) << "Client " << id_ << ": " << message << ": "
         << "Snap not available.";
   }
 }