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

chrome/browser/sync/profile_sync_service.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_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #pragma once
 
 #include <list>
 #include <string>
@@ skipping 248 matching lines @@
   virtual void OnSyncCycleCompleted() OVERRIDE;
   virtual void OnSyncConfigureRetry() OVERRIDE;
   virtual void OnConnectionStatusChange(
       syncer::ConnectionStatus status) OVERRIDE;
   virtual void OnStopSyncingPermanently() OVERRIDE;
   virtual void OnPassphraseRequired(
       syncer::PassphraseRequiredReason reason,
       const sync_pb::EncryptedData& pending_keys) OVERRIDE;
   virtual void OnPassphraseAccepted() OVERRIDE;
   virtual void OnEncryptedTypesChanged(
-      syncable::ModelTypeSet encrypted_types,
+      syncer::ModelTypeSet encrypted_types,
       bool encrypt_everything) OVERRIDE;
   virtual void OnEncryptionComplete() OVERRIDE;
   virtual void OnMigrationNeededForTypes(
-      syncable::ModelTypeSet types) OVERRIDE;
+      syncer::ModelTypeSet types) OVERRIDE;
   virtual void OnExperimentsChanged(
       const syncer::Experiments& experiments) OVERRIDE;
   virtual void OnActionableError(
       const syncer::SyncProtocolError& error) OVERRIDE;
 
   // Update the last auth error and notify observers of error state.
   void UpdateAuthErrorState(const GoogleServiceAuthError& error);
 
   // Called when a user chooses which data types to sync as part of the sync
   // setup wizard.  |sync_everything| represents whether they chose the
   // "keep everything synced" option; if true, |chosen_types| will be ignored
   // and all data types will be synced.  |sync_everything| means "sync all
   // current and future data types."
   virtual void OnUserChoseDatatypes(bool sync_everything,
-      syncable::ModelTypeSet chosen_types);
+      syncer::ModelTypeSet chosen_types);
 
   // Get various information for displaying in the user interface.
   std::string QuerySyncStatusSummary();
   virtual browser_sync::SyncBackendHost::Status QueryDetailedSyncStatus();
 
   virtual const GoogleServiceAuthError& GetAuthError() const;
 
   // Returns true if initial sync setup is in progress (does not return true
   // if the user is customizing sync after already completing setup once).
   // ProfileSyncService uses this to determine if it's OK to start syncing, or
@@ skipping 71 matching lines @@
   bool IsManaged() const;
 
   // syncer::UnrecoverableErrorHandler implementation.
   virtual void OnUnrecoverableError(
       const tracked_objects::Location& from_here,
       const std::string& message) OVERRIDE;
 
   // Called when a datatype wishes to disable itself due to having hit an
   // unrecoverable error.
   virtual void DisableBrokenDatatype(
-      syncable::ModelType type,
+      syncer::ModelType type,
       const tracked_objects::Location& from_here,
       std::string message);
 
   // The functions below (until ActivateDataType()) should only be
   // called if sync_initialized() is true.
 
   // TODO(akalin): This is called mostly by ModelAssociators and
   // tests.  Figure out how to pass the handle to the ModelAssociators
   // directly, figure out how to expose this to tests, and remove this
   // function.
@@ skipping 26 matching lines @@
   // dpending on the type's current status.
   //
   // This function is used by sync_ui_util.cc to help populate the about:sync
   // page.  It returns a ListValue rather than a DictionaryValye in part to make
   // it easier to iterate over its elements when constructing that page.
   Value* GetTypeStatusMap() const;
 
   // Overridden by tests.
   // TODO(zea): Remove these and have the dtc's call directly into the SBH.
   virtual void ActivateDataType(
-      syncable::ModelType type, syncer::ModelSafeGroup group,
+      syncer::ModelType type, syncer::ModelSafeGroup group,
       browser_sync::ChangeProcessor* change_processor);
-  virtual void DeactivateDataType(syncable::ModelType type);
+  virtual void DeactivateDataType(syncer::ModelType type);
 
   // SyncPrefObserver implementation.
   virtual void OnSyncManagedPrefChange(bool is_sync_managed) OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Changes which data types we're going to be syncing to |preferred_types|.
   // If it is running, the DataTypeManager will be instructed to reconfigure
   // the sync backend so that exactly these datatypes are actively synced.  See
   // class comment for more on what it means for a datatype to be Preferred.
   virtual void ChangePreferredDataTypes(
-      syncable::ModelTypeSet preferred_types);
+      syncer::ModelTypeSet preferred_types);
 
   // Get the set of currently enabled data types (as chosen or configured by
   // the user).  See class comment for more on what it means for a datatype
   // to be Preferred.
-  virtual syncable::ModelTypeSet GetPreferredDataTypes() const;
+  virtual syncer::ModelTypeSet GetPreferredDataTypes() const;
 
   // Gets the set of all data types that could be allowed (the set that
   // should be advertised to the user).  These will typically only change
   // via a command-line option.  See class comment for more on what it means
   // for a datatype to be Registered.
-  virtual syncable::ModelTypeSet GetRegisteredDataTypes() const;
+  virtual syncer::ModelTypeSet GetRegisteredDataTypes() const;
 
   // Checks whether the Cryptographer is ready to encrypt and decrypt updates
   // for sensitive data types. Caller must be holding a
   // syncapi::BaseTransaction to ensure thread safety.
   virtual bool IsCryptographerReady(
       const syncer::BaseTransaction* trans) const;
 
   // Returns true if a secondary passphrase is being used. It is not legal
   // to call this method before the backend is initialized.
   virtual bool IsUsingSecondaryPassphrase() const;
@@ skipping 24 matching lines @@
   virtual void EnableEncryptEverything();
 
   // Returns true if we are currently set to encrypt all the sync data. Note:
   // this is based on the cryptographer's settings, so if the user has recently
   // requested encryption to be turned on, this may not be true yet. For that,
   // encryption_pending() must be checked.
   virtual bool EncryptEverythingEnabled() const;
 
   // Fills |encrypted_types| with the set of currently encrypted types. Does
   // not account for types pending encryption.
-  virtual syncable::ModelTypeSet GetEncryptedDataTypes() const;
+  virtual syncer::ModelTypeSet GetEncryptedDataTypes() const;
 
   // Returns true if the syncer is waiting for new datatypes to be encrypted.
   virtual bool encryption_pending() const;
 
   // Returns whether processing changes is allowed.  Check this before doing
   // any model-modifying operations.
   bool ShouldPushChanges();
 
   const GURL& sync_service_url() const { return sync_service_url_; }
   bool auto_start_enabled() const { return auto_start_enabled_; }
@@ skipping 127 matching lines @@
 
   void NotifyObservers();
 
   void ClearStaleErrors();
 
   void ClearUnrecoverableError();
 
   // About-flags experiment names for datatypes that aren't enabled by default
   // yet.
   static std::string GetExperimentNameForDataType(
-      syncable::ModelType data_type);
+      syncer::ModelType data_type);
 
   // Create and register a new datatype controller.
-  void RegisterNewDataType(syncable::ModelType data_type);
+  void RegisterNewDataType(syncer::ModelType data_type);
 
   // Helper method to process SyncConfigureDone after unwinding the stack that
   // originally posted this SyncConfigureDone.
   void OnSyncConfigureDone(
       browser_sync::DataTypeManager::ConfigureResult result);
 
   // Reconfigures the data type manager with the latest enabled types.
   // Note: Does not initialize the backend if it is not already initialized.
   // This function needs to be called only after sync has been initialized
   // (i.e.,only for reconfigurations). The reason we don't initialize the
   // backend is because if we had encountered an unrecoverable error we don't
   // want to startup once more.
   virtual void ReconfigureDatatypeManager();
 
   // Called when the user changes the sync configuration, to update the UMA
   // stats.
   void UpdateSelectedTypesHistogram(
       bool sync_everything,
-      const syncable::ModelTypeSet chosen_types) const;
+      const syncer::ModelTypeSet chosen_types) const;
 
 #if defined(OS_CHROMEOS)
   // Refresh spare sync bootstrap token for re-enabling the sync service.
   // Called on successful sign-in notifications.
   void RefreshSpareBootstrapToken(const std::string& passphrase);
 #endif
 
   // Internal unrecoverable error handler. Used to track error reason via
   // Sync.UnrecoverableErrors histogram.
   void OnInternalUnrecoverableError(const tracked_objects::Location& from_here,
@@ skipping 65 matching lines @@
   bool expect_sync_configuration_aborted_;
 
   // Sometimes we need to temporarily hold on to a passphrase because we don't
   // yet have a backend to send it to.  This happens during initialization as
   // we don't StartUp until we have a valid token, which happens after valid
   // credentials were provided.
   std::string cached_passphrase_;
 
   // The current set of encrypted types.  Always a superset of
   // syncer::Cryptographer::SensitiveTypes().
-  syncable::ModelTypeSet encrypted_types_;
+  syncer::ModelTypeSet encrypted_types_;
 
   // Whether we want to encrypt everything.
   bool encrypt_everything_;
 
   // Whether we're waiting for an attempt to encryption all sync data to
   // complete. We track this at this layer in order to allow the user to cancel
   // if they e.g. don't remember their explicit passphrase.
   bool encryption_pending_;
 
   // If true, we want to automatically start sync signin whenever we have
@@ skipping 27 matching lines @@
   syncer::Experiments current_experiments;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_