[Sync] Move ModelType and related classes to 'syncer' namespace

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_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 41 matching lines @@
   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(syncable::ModelTypeSet synced_datatypes);
+  bool SetupSync(syncer::ModelTypeSet synced_datatypes);
 
   // ProfileSyncServiceObserver implementation.
   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();
@@ skipping 22 matching lines @@
   bool AwaitSyncDisabled(const std::string& reason);
 
   // Blocks the caller until exponential backoff has been verified to happen.
   bool AwaitExponentialBackoffVerification();
 
   // Blocks the caller until the syncer receives an actionable error.
   // Returns true if the sync client received an actionable error.
   bool AwaitActionableError();
 
   // Blocks until the given set of data types are migrated.
-  bool AwaitMigration(syncable::ModelTypeSet expected_migrated_types);
+  bool AwaitMigration(syncer::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
@@ skipping 26 matching lines @@
   // Returns the ProfileSyncService member of the sync client.
   ProfileSyncService* service() { return service_; }
 
   // Returns the status of the ProfileSyncService member of the sync client.
   ProfileSyncService::Status GetStatus();
 
   // See ProfileSyncService::ShouldPushChanges().
   bool ServiceIsPushingChanges() { return service_->ShouldPushChanges(); }
 
   // Enables sync for a particular sync datatype. Returns true on success.
-  bool EnableSyncForDatatype(syncable::ModelType datatype);
+  bool EnableSyncForDatatype(syncer::ModelType datatype);
 
   // Disables sync for a particular sync datatype. Returns true on success.
-  bool DisableSyncForDatatype(syncable::ModelType datatype);
+  bool DisableSyncForDatatype(syncer::ModelType datatype);
 
   // Enables sync for all sync datatypes. Returns true on success.
   bool EnableSyncForAllDatatypes();
 
   // Disables sync for all sync datatypes. Returns true on success.
   bool DisableSyncForAllDatatypes();
 
   // Returns a snapshot of the current sync session.
   syncer::sessions::SyncSessionSnapshot GetLastSessionSnapshot() const;
 
   // Encrypt the datatype |type|. This method will block while the sync backend
   // host performs the encryption or a timeout is reached.
   // PostCondition:
   //   returns: True if |type| was encrypted and we are fully synced.
   //            False if we timed out.
-  bool EnableEncryptionForType(syncable::ModelType type);
+  bool EnableEncryptionForType(syncer::ModelType type);
 
   // Wait until |type| is encrypted or we time out.
   // PostCondition:
   //   returns: True if |type| is currently encrypted and we are fully synced.
   //            False if we timed out.
-  bool WaitForTypeEncryption(syncable::ModelType type);
+  bool WaitForTypeEncryption(syncer::ModelType type);
 
   // Check if |type| is encrypted.
-  bool IsTypeEncrypted(syncable::ModelType type);
+  bool IsTypeEncrypted(syncer::ModelType type);
 
   // Check if |type| is registered and the controller is running.
-  bool IsTypeRunning(syncable::ModelType type);
+  bool IsTypeRunning(syncer::ModelType type);
 
   // Check if |type| is being synced.
-  bool IsTypePreferred(syncable::ModelType type);
+  bool IsTypePreferred(syncer::ModelType type);
 
   // Get the number of sync entries this client has. This includes all top
   // level or permanent items, and can include recently deleted entries.
   size_t GetNumEntries() const;
 
   // Get the number of sync datatypes registered (ignoring whatever state
   // they're in).
   size_t GetNumDatatypes() const;
 
   // Gets the |auto_start_enabled_| variable from the |service_|.
@@ skipping 113 matching lines @@
   // 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.
-  std::string GetUpdatedTimestamp(syncable::ModelType model_type);
+  std::string GetUpdatedTimestamp(syncer::ModelType model_type);
 
   // Gets detailed status from |service_| in pretty-printable form.
   std::string GetServiceStatus();
 
   // When in WAITING_FOR_ENCRYPTION state, we check to see if this type is now
   // encrypted to determine if we're done.
-  syncable::ModelType waiting_for_encryption_type_;
+  syncer::ModelType waiting_for_encryption_type_;
 
   // 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_;
 
   // 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_;
+  syncer::ModelTypeSet pending_migration_types_;
 
   // The set of data types that have undergone migration.  Used by
   // AwaitMigration().
-  syncable::ModelTypeSet migrated_types_;
+  syncer::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_;
 
   // 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_