[Sync] Make BackendMigrator not wait for full sync cycles

chrome/browser/sync/profile_sync_service_harness.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_HARNESS_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_HARNESS_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "chrome/browser/sync/backend_migrator.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_observer.h"
 #include "chrome/browser/sync/retry_verifier.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 
 class Profile;
 
 namespace browser_sync {
   namespace sessions {
     struct SyncSessionSnapshot;
   }
 }
 
 // An instance of this class is basically our notion of a "sync client" for
 // automation purposes. It harnesses the ProfileSyncService member of the
 // profile passed to it on construction and automates certain things like setup
 // and authentication. It provides ways to "wait" adequate periods of time for
 // several clients to get to the same state.
-class ProfileSyncServiceHarness : public ProfileSyncServiceObserver {
+class ProfileSyncServiceHarness
+    : public ProfileSyncServiceObserver,
+      public browser_sync::MigrationObserver {
  public:
   ProfileSyncServiceHarness(Profile* profile,
                             const std::string& username,
                             const std::string& password);
 
   virtual ~ProfileSyncServiceHarness();
 
   // Creates a ProfileSyncServiceHarness object and attaches it to |profile|, a
   // profile that is assumed to have been signed into sync in the past. Caller
   // takes ownership.
   static ProfileSyncServiceHarness* CreateAndAttach(Profile* profile);
 
   // Sets the GAIA credentials with which to sign in to sync.
   void SetCredentials(const std::string& username, const std::string& password);
 
   // Returns true if sync has been enabled on |profile_|.
   bool IsSyncAlreadySetup();
 
   // Creates a ProfileSyncService for the profile passed at construction and
   // enables sync for all available datatypes. Returns true only after sync has
   // been fully initialized and authenticated, and we are ready to process
   // changes.
   bool SetupSync();
 
   // Same as the above method, but enables sync only for the datatypes contained
   // in |synced_datatypes|.
   bool SetupSync(const syncable::ModelTypeSet& synced_datatypes);
 
   // ProfileSyncServiceObserver implementation.
-  virtual void OnStateChanged();
+  virtual void OnStateChanged() OVERRIDE;
+
+  // MigrationObserver implementation.
+  virtual void OnMigrationStateChange() OVERRIDE;
 
   // Blocks the caller until the sync backend host associated with this harness
   // has been initialized.  Returns true if the wait was successful.
   bool AwaitBackendInitialized();
 
   // Blocks the caller until the datatype manager is configured and sync has
   // been initialized (for example, after a browser restart).  Returns true if
   // the wait was successful.
   bool AwaitSyncRestart();
 
   // Blocks the caller until this harness has completed a single sync cycle
   // since the previous one.  Returns true if a sync cycle has completed.
   bool AwaitSyncCycleCompletion(const std::string& reason);
 
-  // Blocks the caller until this harness has completed a single sync
-  // cycle, even if we're already synced.  Returns true if a sync
-  // cycle has completed.
-  //
-  // TODO(akalin): This is only used by some migration tests, pending
-  // the fix for http://crbug.com/92928.  Remove this once that is
-  // fixed.
-  bool AwaitNextSyncCycleCompletion(const std::string& reason);
-
   // Blocks the caller until the sync has been disabled for this client. Returns
   // true if sync is disabled.
   bool AwaitSyncDisabled(const std::string& reason);
 
   // Blocks the caller until exponential backoff has been verified to happen.
   bool AwaitExponentialBackoffVerification();
 
+  // Blocks until the given set of data types are migrated.
+  bool AwaitMigration(const syncable::ModelTypeSet& expected_migrated_types);
+
   // Blocks the caller until this harness has observed that the sync engine
   // has downloaded all the changes seen by the |partner| harness's client.
   bool WaitUntilTimestampMatches(
       ProfileSyncServiceHarness* partner, const std::string& reason);
 
   // Calling this acts as a barrier and blocks the caller until |this| and
   // |partner| have both completed a sync cycle.  When calling this method,
   // the |partner| should be the passive responder who responds to the actions
   // of |this|.  This method relies upon the synchronization of callbacks
   // from the message queue. Returns true if two sync cycles have completed.
@@ skipping 104 matching lines @@
     // full sync cycle is not expected to occur.
     WAITING_FOR_SYNC_CONFIGURATION,
 
     // The sync client is waiting for the sync to be disabled for this client.
     WAITING_FOR_SYNC_DISABLED,
 
     // The sync client is in the exponential backoff mode. Verify that
     // backoffs are triggered correctly.
     WAITING_FOR_EXPONENTIAL_BACKOFF_VERIFICATION,
 
+    // The sync client is waiting for migration to start.
+    WAITING_FOR_MIGRATION_TO_START,
+
+    // The sync client is waiting for migration to finish.
+    WAITING_FOR_MIGRATION_TO_FINISH,
+
     // The client verification is complete. We don't care about the state of
     // the syncer any more.
     WAITING_FOR_NOTHING,
 
     // The sync client needs a passphrase in order to decrypt data.
     SET_PASSPHRASE_FAILED,
 
     // The sync client cannot reach the server.
     SERVER_UNREACHABLE,
 
     // The sync client is fully synced and there are no pending updates.
     FULLY_SYNCED,
 
     // Syncing is disabled for the client.
     SYNC_DISABLED,
 
     NUMBER_OF_STATES,
   };
 
+  // Listen to migration events if the migrator has been initialized
+  // and we're not already listening.  Returns true if we started
+  // listening.
+  bool TryListeningToMigrationEvents();
+
   // Called from the observer when the current wait state has been completed.
   void SignalStateCompleteWithNextState(WaitState next_state);
 
   // Indicates that the operation being waited on is complete.
   void SignalStateComplete();
 
   // Finite state machine for controlling state.  Returns true only if a state
   // change has taken place.
   bool RunStateChangeMachine();
 
   // Returns true if a status change took place, false on timeout.
   bool AwaitStatusChangeWithTimeout(int timeout_milliseconds,
                                     const std::string& reason);
 
-  // Used by AwaitSyncCycleCompletion() and
-  // AwaitNextSyncCycleCompletion().
-  bool AwaitSyncCycleCompletionHelper(const std::string& reason);
-
   // Returns true if the sync client has no unsynced items.
   bool IsSynced();
 
+  // Returns true if there is a backend migration in progress.
+  bool HasPendingBackendMigration();
+
   // Returns true if this client has downloaded all the items that the
   // other client has.
   bool MatchesOtherClient(ProfileSyncServiceHarness* partner);
 
   // Returns a string with relevant info about client's sync state (if
   // available), annotated with |message|. Useful for logging.
   std::string GetClientInfoString(const std::string& message);
 
   // Gets the current progress indicator of the current sync session
   // for a particular datatype.
@@ skipping 17 matching lines @@
   ProfileSyncService* service_;
 
   // The harness of the client whose update progress marker we're expecting
   // eventually match.
   ProfileSyncServiceHarness* timestamp_match_partner_;
 
   // Credentials used for GAIA authentication.
   std::string username_;
   std::string password_;
 
+  // The current set of data types pending migration.  Used by
+  // AwaitMigration().
+  syncable::ModelTypeSet pending_migration_types_;
+
+  // The set of data types that have undergone migration.  Used by
+  // AwaitMigration().
+  syncable::ModelTypeSet migrated_types_;
+
   // Used for logging.
   const std::string profile_debug_name_;
 
   // Keeps track of the number of attempts at exponential backoff and its
   // related bookkeeping information for verification.
   browser_sync::RetryVerifier retry_verifier_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceHarness);
 };
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_HARNESS_H_