Make use of InvalidationService

chrome/browser/sync/profile_sync_service_harness.h

 // Copyright (c) 2012 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_
 
 #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 "sync/internal_api/public/base/model_type.h"
 
 class Profile;
 
+namespace invalidation{
+class P2PInvalidationService;
+}
+
 namespace browser_sync {
 namespace sessions {
 class 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,
       public browser_sync::MigrationObserver {
  public:
-  ProfileSyncServiceHarness(Profile* profile,
-                            const std::string& username,
-                            const std::string& password);
+  static ProfileSyncServiceHarness* Create(
+      Profile* profile,
+      const std::string& username,
+      const std::string& password);
+
+  static ProfileSyncServiceHarness* CreateForIntegrationTest(
+      Profile* profile,
+      const std::string& username,
+      const std::string& password,
+      invalidation::P2PInvalidationService* invalidation_service);
 
   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(syncer::ModelTypeSet synced_datatypes);
 
   // ProfileSyncServiceObserver implementation.
   virtual void OnStateChanged() OVERRIDE;
+  virtual void OnSyncCycleCompleted() 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 this harness has completed a single sync cycle
   // since the previous one.  Returns true if a sync cycle has completed.
@@ skipping 188 matching lines @@
 
     // 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,
   };
 
+  ProfileSyncServiceHarness(
+      Profile* profile,
+      const std::string& username,
+      const std::string& password,
+      invalidation::P2PInvalidationService* invalidation_service);
+
   // 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();
@@ skipping 44 matching lines @@
   // The WaitState in which the sync client currently is. Helps determine what
   // action to take when RunStateChangeMachine() is called.
   WaitState wait_state_;
 
   // Sync profile associated with this sync client.
   Profile* profile_;
 
   // ProfileSyncService object associated with |profile_|.
   ProfileSyncService* service_;
 
+  // P2PInvalidationService associated with |profile_|.
+  invalidation::P2PInvalidationService* p2p_invalidation_service_;
+
   // The harness of the client whose update progress marker we're expecting
   // eventually match.
   ProfileSyncServiceHarness* progress_marker_partner_;
 
   // Credentials used for GAIA authentication.
   std::string username_;
   std::string password_;
 
   // The current set of data types pending migration.  Used by
   // AwaitMigration().
@@ skipping 12 matching lines @@
 
   // Flag set to true when we're waiting for a status change to happen. Used to
   // avoid triggering internal state machine logic on unexpected sync observer
   // callbacks.
   bool waiting_for_status_change_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceHarness);
 };
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_HARNESS_H_