PyAuto hooks for Sync in TestingAutomationProvider

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/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"
@@ skipping 66 matching lines @@
   }
 }
 
 bool StateChangeTimeoutEvent::Abort() {
   aborted_ = true;
   caller_ = NULL;
   return !did_timeout_;
 }
 
 ProfileSyncServiceHarness::ProfileSyncServiceHarness(
-    Profile* p,
+    Profile* profile,
     const std::string& username,
     const std::string& password,
     int id)
-    : wait_state_(WAITING_FOR_ON_BACKEND_INITIALIZED),
-      profile_(p),
+    : wait_state_(INITIAL_WAIT_STATE),
+      profile_(profile),
       service_(NULL),
       last_timestamp_(0),
       min_timestamp_needed_(kMinTimestampNeededNone),
       username_(username),
       password_(password),
-      id_(id) {}
+      id_(id) {
+  if (IsSyncAlreadySetup()) {
+    service_ = profile_->GetProfileSyncService();
+    service_->AddObserver(this);
+    wait_state_ = FULLY_SYNCED;
+  }
+}
+
+// static
+ProfileSyncServiceHarness* ProfileSyncServiceHarness::CreateAndAttach(
+    Profile* profile) {
+  if (!profile->HasProfileSyncService()) {
+    NOTREACHED() << "Profile has never signed into sync.";
+    return NULL;
+  }
+  return new ProfileSyncServiceHarness(profile, "", "", 0);
+}
+
+void ProfileSyncServiceHarness::SetCredentials(const std::string& username,
+                                               const std::string& password) {
+  username_ = username;
+  password_ = password;
+}
+
+bool ProfileSyncServiceHarness::IsSyncAlreadySetup() {
+  return profile_->HasProfileSyncService();
+}
 
 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);
 }
 
 bool ProfileSyncServiceHarness::SetupSync(
     const syncable::ModelTypeSet& synced_datatypes) {
   // Initialize the sync client's profile sync service object.
-  service_ = profile_->GetProfileSyncService("");
+  service_ = profile_->GetProfileSyncService();
   if (service_ == NULL) {
     LOG(ERROR) << "SetupSync(): service_ is null.";
     return false;
   }
 
   // Subscribe sync client to notifications from the profile sync service.
   if (!service_->HasObserver(this))
     service_->AddObserver(this);
 
   // Authenticate sync client using GAIA credentials.
   service_->signin()->StartSignIn(username_, password_, "", "");
 
   // Wait for the OnBackendInitialized() callback.
-  DCHECK_EQ(wait_state_, WAITING_FOR_ON_BACKEND_INITIALIZED);
+  wait_state_ = WAITING_FOR_ON_BACKEND_INITIALIZED;
   if (!AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
       "Waiting for OnBackendInitialized().")) {
     LOG(ERROR) << "OnBackendInitialized() not seen after "
                << kLiveSyncOperationTimeoutMs / 1000
                << " seconds.";
     return false;
   }
 
   // Choose the datatypes to be synced. If all datatypes are to be synced,
   // set sync_everything to true; otherwise, set it to false.
   bool sync_everything = (synced_datatypes.size() ==
       (syncable::MODEL_TYPE_COUNT - syncable::FIRST_REAL_MODEL_TYPE));
   service()->OnUserChoseDatatypes(sync_everything, synced_datatypes);
 
   // Wait for initial sync cycle to complete.
   DCHECK_EQ(wait_state_, WAITING_FOR_INITIAL_SYNC);
   if (!AwaitStatusChangeWithTimeout(kLiveSyncOperationTimeoutMs,
       "Waiting for initial sync cycle to complete.")) {
     LOG(ERROR) << "Initial sync cycle did not complete after "
                << kLiveSyncOperationTimeoutMs / 1000
                << " seconds.";
     return false;
   }
 
+  // Indicate to the browser that sync setup is complete.
+  service()->SetSyncSetupCompleted();
+
   return true;
 }
 
 void ProfileSyncServiceHarness::SignalStateCompleteWithNextState(
     WaitState next_state) {
   wait_state_ = next_state;
   SignalStateComplete();
 }
 
+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. Start waiting for the first sync
         // cycle to complete.
         SignalStateCompleteWithNextState(WAITING_FOR_INITIAL_SYNC);
       }
@@ skipping 176 matching lines @@
 bool ProfileSyncServiceHarness::AwaitStatusChangeWithTimeout(
     int timeout_milliseconds,
     const std::string& reason) {
   LogClientInfo("AwaitStatusChangeWithTimeout");
   if (wait_state_ == SYNC_DISABLED) {
     LOG(ERROR) << "Sync disabled for Client " << id_ << ".";
     return false;
   }
   scoped_refptr<StateChangeTimeoutEvent> timeout_signal(
       new StateChangeTimeoutEvent(this, reason));
-  MessageLoopForUI* loop = MessageLoopForUI::current();
+  MessageLoop* loop = MessageLoop::current();
+  bool did_allow_nestable_tasks = loop->NestableTasksAllowed();
+  loop->SetNestableTasksAllowed(true);
   loop->PostDelayedTask(
       FROM_HERE,
       NewRunnableMethod(timeout_signal.get(),
                         &StateChangeTimeoutEvent::Callback),
       timeout_milliseconds);
-  AwaitStatusChange();
+  loop->Run();
+  loop->SetNestableTasksAllowed(did_allow_nestable_tasks);
   LogClientInfo("AwaitStatusChangeWithTimeout succeeded");
   return timeout_signal->Abort();
 }
 
 ProfileSyncService::Status ProfileSyncServiceHarness::GetStatus() {
   DCHECK(service() != NULL) << "GetStatus(): service() is NULL.";
   return service()->QueryDetailedSyncStatus();
 }
 
 bool ProfileSyncServiceHarness::IsSynced() {
+  if (service() == NULL)
+    return false;
   const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
   // TODO(rsimha): Remove additional checks of snap->has_more_to_sync and
   // snap->unsynced_count once http://crbug.com/48989 is fixed.
-  return (service() &&
-          snap &&
+  return (snap &&
           ServiceIsPushingChanges() &&
           GetStatus().notifications_enabled &&
           !service()->backend()->HasUnsyncedItems() &&
           !snap->has_more_to_sync &&
           snap->unsynced_count == 0);
 }
 
 const SyncSessionSnapshot*
     ProfileSyncServiceHarness::GetLastSessionSnapshot() const {
   DCHECK(service_ != NULL) << "Sync service has not yet been set up.";
@@ skipping 83 matching lines @@
 
 int64 ProfileSyncServiceHarness::GetUpdatedTimestamp() {
   const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
   DCHECK(snap != NULL) << "GetUpdatedTimestamp(): Sync snapshot is NULL.";
   DCHECK_LE(last_timestamp_, snap->max_local_timestamp);
   last_timestamp_ = snap->max_local_timestamp;
   return last_timestamp_;
 }
 
 void ProfileSyncServiceHarness::LogClientInfo(std::string message) {
-  const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
-  if (snap) {
-    VLOG(1) << "Client " << id_ << ": " << message
-            << ": max_local_timestamp: " << snap->max_local_timestamp
-            << ", has_more_to_sync: " << snap->has_more_to_sync
-            << ", unsynced_count: " << snap->unsynced_count
-            << ", has_unsynced_items: "
-            << service()->backend()->HasUnsyncedItems()
-            << ", notifications_enabled: "
-            << GetStatus().notifications_enabled
-            << ", service_is_pushing_changes: " << ServiceIsPushingChanges();
+  if (service()) {
+    const SyncSessionSnapshot* snap = GetLastSessionSnapshot();
+    if (snap) {
+      VLOG(1) << "Client " << id_ << ": " << message
+              << ": max_local_timestamp: " << snap->max_local_timestamp
+              << ", has_more_to_sync: " << snap->has_more_to_sync
+              << ", unsynced_count: " << snap->unsynced_count
+              << ", has_unsynced_items: "
+              << service()->backend()->HasUnsyncedItems()
+              << ", notifications_enabled: "
+              << GetStatus().notifications_enabled
+              << ", service_is_pushing_changes: " << ServiceIsPushingChanges();
+    } else {
+      VLOG(1) << "Client " << id_ << ": " << message
+              << ": Sync session snapshot not available.";
+    }
   } else {
     VLOG(1) << "Client " << id_ << ": " << message
-            << ": Sync session snapshot not available.";
+            << ": Sync service not available.";
   }
 }