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

chrome/browser/sync/glue/sync_backend_host.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_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #pragma once
 
 #include <string>
 
@@ skipping 90 matching lines @@
   // below).
   //
   // |encrypted_types| will always be a superset of
   // syncer::Cryptographer::SensitiveTypes().  If |encrypt_everything| is
   // true, |encrypted_types| will be the set of all known types.
   //
   // Until this function is called, observers can assume that the set
   // of encrypted types is syncer::Cryptographer::SensitiveTypes() and that
   // the encrypt everything flag is false.
   virtual void OnEncryptedTypesChanged(
-      syncable::ModelTypeSet encrypted_types,
+      syncer::ModelTypeSet encrypted_types,
       bool encrypt_everything) = 0;
 
   // Called after we finish encrypting the current set of encrypted
   // types.
   virtual void OnEncryptionComplete() = 0;
 
   // Called to perform migration of |types|.
-  virtual void OnMigrationNeededForTypes(
-      syncable::ModelTypeSet types) = 0;
+  virtual void OnMigrationNeededForTypes(syncer::ModelTypeSet types) = 0;
 
   // Inform the Frontend that new datatypes are available for registration.
   virtual void OnExperimentsChanged(
       const syncer::Experiments& experiments) = 0;
 
   // Called when the sync cycle returns there is an user actionable error.
-  virtual void OnActionableError(
-      const syncer::SyncProtocolError& error) = 0;
+  virtual void OnActionableError(const syncer::SyncProtocolError& error) = 0;
 
  protected:
   // Don't delete through SyncFrontend interface.
   virtual ~SyncFrontend() {
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(SyncFrontend);
 };
 
 // A UI-thread safe API into the sync backend that "hosts" the top-level
@@ skipping 23 matching lines @@
   // Called on |frontend_loop_| to kick off asynchronous initialization.
   // As a fallback when no cached auth information is available, try to
   // bootstrap authentication using |lsid|, if it isn't empty.
   // Optionally delete the Sync Data folder (if it's corrupt).
   // |report_unrecoverable_error_function| can be NULL.
   // Note: |unrecoverable_error_handler| may be invoked from any thread.
   void Initialize(
       SyncFrontend* frontend,
       const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
       const GURL& service_url,
-      syncable::ModelTypeSet initial_types,
+      syncer::ModelTypeSet initial_types,
       const syncer::SyncCredentials& credentials,
       bool delete_sync_data_folder,
       syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
       syncer::ReportUnrecoverableErrorFunction
           report_unrecoverable_error_function);
 
   // Called from |frontend_loop| to update SyncCredentials.
   void UpdateCredentials(const syncer::SyncCredentials& credentials);
 
   // This starts the SyncerThread running a Syncer object to communicate with
@@ skipping 34 matching lines @@
   // See the implementation and Core::DoShutdown for details.
   // Must be called *after* StopSyncingForShutdown.
   void Shutdown(bool sync_disabled);
 
   // Changes the set of data types that are currently being synced.
   // The ready_task will be run when configuration is done with the
   // set of all types that failed configuration (i.e., if its argument
   // is non-empty, then an error was encountered).
   virtual void ConfigureDataTypes(
       syncer::ConfigureReason reason,
-      syncable::ModelTypeSet types_to_add,
-      syncable::ModelTypeSet types_to_remove,
+      syncer::ModelTypeSet types_to_add,
+      syncer::ModelTypeSet types_to_remove,
       NigoriState nigori_state,
-      base::Callback<void(syncable::ModelTypeSet)> ready_task,
+      base::Callback<void(syncer::ModelTypeSet)> ready_task,
       base::Callback<void()> retry_callback) OVERRIDE;
 
   // Makes an asynchronous call to syncer to switch to config mode. When done
   // syncer will call us back on FinishConfigureDataTypes.
   virtual void StartConfiguration(const base::Closure& callback);
 
   // Turns on encryption of all present and future sync data.
   virtual void EnableEncryptEverything();
 
   // Activates change processing for the given data type.  This must
   // be called synchronously with the data type's model association so
   // no changes are dropped between model association and change
   // processor activation.
   void ActivateDataType(
-      syncable::ModelType type, syncer::ModelSafeGroup group,
+      syncer::ModelType type, syncer::ModelSafeGroup group,
       ChangeProcessor* change_processor);
 
   // Deactivates change processing for the given data type.
-  void DeactivateDataType(syncable::ModelType type);
+  void DeactivateDataType(syncer::ModelType type);
 
   // Called on |frontend_loop_| to obtain a handle to the UserShare needed
   // for creating transactions.
   syncer::UserShare* GetUserShare() const;
 
   // Called from any thread to obtain current status information in detailed or
   // summarized form.
   Status GetDetailedStatus();
   syncer::sessions::SyncSessionSnapshot GetLastSessionSnapshot() const;
 
@@ skipping 41 matching lines @@
         bool delete_sync_data_folder,
         const std::string& restored_key_for_bootstrapping,
         syncer::SyncManager::TestingMode testing_mode,
         syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
         syncer::ReportUnrecoverableErrorFunction
             report_unrecoverable_error_function);
     ~DoInitializeOptions();
 
     MessageLoop* sync_loop;
     SyncBackendRegistrar* registrar;
-   syncer::ModelSafeRoutingInfo routing_info;
+    syncer::ModelSafeRoutingInfo routing_info;
     std::vector<syncer::ModelSafeWorker*> workers;
     syncer::ExtensionsActivityMonitor* extensions_activity_monitor;
     syncer::WeakHandle<syncer::JsEventHandler> event_handler;
     GURL service_url;
     // Overridden by tests.
     MakeHttpBridgeFactoryFn make_http_bridge_factory_fn;
     syncer::SyncCredentials credentials;
     ChromeSyncNotificationBridge* const chrome_sync_notification_bridge;
     syncer::SyncNotifierFactory* const sync_notifier_factory;
     std::string lsid;
@@ skipping 40 matching lines @@
     INITIALIZED,            // Initialization is complete.
   };
 
   struct PendingConfigureDataTypesState {
     PendingConfigureDataTypesState();
     ~PendingConfigureDataTypesState();
 
     // The ready_task will be run when configuration is done with the
     // set of all types that failed configuration (i.e., if its
     // argument is non-empty, then an error was encountered).
-    base::Callback<void(syncable::ModelTypeSet)> ready_task;
+    base::Callback<void(syncer::ModelTypeSet)> ready_task;
 
     // The retry callback will be run when the download failed due to a
     // transient error. This is to notify DTM so it can apropriately inform
     // the UI. Note: The retry_callback will be run only once and after
     // that we will not notify DTM until the sync is successful or in a
     // permanent error state.
     base::Callback<void()> retry_callback;
 
     // The set of types that we are waiting to be initially synced in a
     // configuration cycle.
-    syncable::ModelTypeSet types_to_add;
+    syncer::ModelTypeSet types_to_add;
 
     // Additional details about which types were added.
-    syncable::ModelTypeSet added_types;
+    syncer::ModelTypeSet added_types;
     syncer::ConfigureReason reason;
     bool retry_in_progress;
   };
 
   // Checks if we have received a notice to turn on experimental datatypes
   // (via the nigori node) and informs the frontend if that is the case.
   // Note: it is illegal to call this before the backend is initialized.
   void AddExperimentalTypes();
 
   // Downloading of nigori failed and will be retried.
@@ skipping 37 matching lines @@
 
   // Invoked when the passphrase provided by the user has been accepted.
   void NotifyPassphraseAccepted();
 
   // Invoked when an updated token is available from the sync server.
   void NotifyUpdatedToken(const std::string& token);
 
   // Invoked when the set of encrypted types or the encrypt
   // everything flag changes.
   void NotifyEncryptedTypesChanged(
-      syncable::ModelTypeSet encrypted_types,
+      syncer::ModelTypeSet encrypted_types,
       bool encrypt_everything);
 
   // Invoked when sync finishes encrypting new datatypes.
   void NotifyEncryptionComplete();
 
   void HandleStopSyncingPermanentlyOnFrontendLoop();
 
   // Dispatched to from OnConnectionStatusChange to handle updating
   // frontend UI components.
   void HandleConnectionStatusChangeOnFrontendLoop(
       syncer::ConnectionStatus status);
 
   // Called when configuration of the Nigori node has completed as
   // part of the initialization process.
   void HandleNigoriConfigurationCompletedOnFrontendLoop(
       const syncer::WeakHandle<syncer::JsBackend>& js_backend,
-      syncable::ModelTypeSet failed_configuration_types);
+      syncer::ModelTypeSet failed_configuration_types);
 
   // Must be called on |frontend_loop_|.  |done_callback| is called on
   // |frontend_loop_|.
   void RefreshNigori(const base::Closure& done_callback);
 
   // Handles stopping the core's SyncManager, accounting for whether
   // initialization is done yet.
   void StopSyncManagerForShutdown(const base::Closure& closure);
 
   base::WeakPtrFactory<SyncBackendHost> weak_ptr_factory_;
@@ skipping 45 matching lines @@
 
   // UI-thread cache of the last SyncSessionSnapshot received from syncapi.
   syncer::sessions::SyncSessionSnapshot last_snapshot_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_