[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/glue/sync_backend_host.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_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 85 matching lines @@
   // below).
   //
   // |encrypted_types| will always be a superset of
   // 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 Cryptographer::SensitiveTypes() and that
   // the encrypt everything flag is false.
   virtual void OnEncryptedTypesChanged(
-      syncable::ModelEnumSet encrypted_types,
+      syncable::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::ModelEnumSet types) = 0;
+      syncable::ModelTypeSet types) = 0;
 
   // Inform the Frontend that new datatypes are available for registration.
-  virtual void OnDataTypesChanged(syncable::ModelEnumSet to_add) = 0;
+  virtual void OnDataTypesChanged(syncable::ModelTypeSet to_add) = 0;
 
   // Called when the sync cycle returns there is an user actionable error.
   virtual void OnActionableError(
       const browser_sync::SyncProtocolError& error) = 0;
 
  protected:
   // Don't delete through SyncFrontend interface.
   virtual ~SyncFrontend() {
   }
  private:
@@ skipping 21 matching lines @@
   SyncBackendHost();
   virtual ~SyncBackendHost();
 
   // 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).
   void Initialize(SyncFrontend* frontend,
                   const WeakHandle<JsEventHandler>& event_handler,
                   const GURL& service_url,
-                  syncable::ModelEnumSet initial_types,
+                  syncable::ModelTypeSet initial_types,
                   const sync_api::SyncCredentials& credentials,
                   bool delete_sync_data_folder);
 
   // Called from |frontend_loop| to update SyncCredentials.
   void UpdateCredentials(const sync_api::SyncCredentials& credentials);
 
   // This starts the SyncerThread running a Syncer object to communicate with
   // sync servers.  Until this is called, no changes will leave or enter this
   // browser from the cloud / sync servers.
   // Called on |frontend_loop_|.
@@ skipping 15 matching lines @@
   // |sync_disabled| indicates if syncing is being disabled or not.
   // 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(
-      syncable::ModelEnumSet types_to_add,
-      syncable::ModelEnumSet types_to_remove,
+      syncable::ModelTypeSet types_to_add,
+      syncable::ModelTypeSet types_to_remove,
       sync_api::ConfigureReason reason,
-      base::Callback<void(syncable::ModelEnumSet)> ready_task,
+      base::Callback<void(syncable::ModelTypeSet)> ready_task,
       bool enable_nigori);
 
   // 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
@@ skipping 78 matching lines @@
         const GoogleServiceAuthError& auth_error) OVERRIDE;
     virtual void OnPassphraseRequired(
         sync_api::PassphraseRequiredReason reason) OVERRIDE;
     virtual void OnPassphraseAccepted(
         const std::string& bootstrap_token) OVERRIDE;
     virtual void OnStopSyncingPermanently() OVERRIDE;
     virtual void OnUpdatedToken(const std::string& token) OVERRIDE;
     virtual void OnClearServerDataFailed() OVERRIDE;
     virtual void OnClearServerDataSucceeded() OVERRIDE;
     virtual void OnEncryptedTypesChanged(
-        syncable::ModelEnumSet encrypted_types,
+        syncable::ModelTypeSet encrypted_types,
         bool encrypt_everything) OVERRIDE;
     virtual void OnEncryptionComplete() OVERRIDE;
     virtual void OnActionableError(
         const browser_sync::SyncProtocolError& sync_error) OVERRIDE;
 
     struct DoInitializeOptions {
       DoInitializeOptions(
           MessageLoop* sync_loop,
           SyncBackendRegistrar* registrar,
           const WeakHandle<JsEventHandler>& event_handler,
@@ skipping 70 matching lines @@
     //    a blocking call). This causes syncapi thread-exit handlers
     //    to run and make use of cached pointers to various components
     //    owned implicitly by us.
     // 3) Destroy this Core. That will delete syncapi components in a
     //    safe order because the thread that was using them has exited
     //    (in step 2).
     void DoStopSyncManagerForShutdown(const base::Closure& closure);
     void DoShutdown(bool stopping_sync);
 
     virtual void DoRequestConfig(
-        syncable::ModelEnumSet types_to_config,
+        syncable::ModelTypeSet types_to_config,
         sync_api::ConfigureReason reason);
 
     // Start the configuration mode.  |callback| is called on the sync
     // thread.
     virtual void DoStartConfiguration(const base::Closure& callback);
 
     // Set the base request context to use when making HTTP calls.
     // This method will add a reference to the context to persist it
     // on the IO thread. Must be removed from IO thread.
 
@@ skipping 10 matching lines @@
     // Called to handle updating frontend thread components whenever we may
     // need to alert the frontend that the backend is intialized.
     void HandleInitializationCompletedOnFrontendLoop(
         const WeakHandle<JsBackend>& js_backend,
         bool success);
 
     // Called when configuration of the Nigori node has completed as
     // part of the initialization process.
     void HandleNigoriConfigurationCompletedOnFrontendLoop(
         const WeakHandle<JsBackend>& js_backend,
-        syncable::ModelEnumSet failed_configuration_types);
+        syncable::ModelTypeSet failed_configuration_types);
 
    private:
     friend class base::RefCountedThreadSafe<SyncBackendHost::Core>;
     friend class SyncBackendHostForProfileSyncTest;
 
     virtual ~Core();
 
     // Invoked when initialization of syncapi is complete and we can start
     // our timer.
     // This must be called from the thread on which SaveChanges is intended to
@@ skipping 23 matching lines @@
 
     // Invoked when the passphrase provided by the user has been accepted.
     void NotifyPassphraseAccepted(const std::string& bootstrap_token);
 
     // 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::ModelEnumSet encrypted_types,
+        syncable::ModelTypeSet encrypted_types,
         bool encrypt_everything);
 
     // Invoked when sync finishes encrypting new datatypes.
     void NotifyEncryptionComplete();
 
     // Called from Core::OnSyncCycleCompleted to handle updating frontend
     // thread components.
     void HandleSyncCycleCompletedOnFrontendLoop(
         sessions::SyncSessionSnapshot* snapshot);
 
@@ skipping 64 matching lines @@
   InitializationState initialization_state_;
 
  private:
   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::ModelEnumSet)> ready_task;
+    base::Callback<void(syncable::ModelTypeSet)> ready_task;
 
     // The set of types that we are waiting to be initially synced in a
     // configuration cycle.
-    syncable::ModelEnumSet types_to_add;
+    syncable::ModelTypeSet types_to_add;
 
     // Additional details about which types were added.
-    syncable::ModelEnumSet added_types;
+    syncable::ModelTypeSet added_types;
     sync_api::ConfigureReason reason;
   };
 
   // For convenience, checks if initialization state is INITIALIZED.
   bool initialized() const { return initialization_state_ == INITIALIZED; }
 
   // Must be called on |frontend_loop_|.  |done_callback| is called on
   // |frontend_loop_|.
   void RefreshEncryption(const base::Closure& done_callback);
 
@@ skipping 33 matching lines @@
 
   // UI-thread cache of the last SyncSessionSnapshot received from syncapi.
   scoped_ptr<sessions::SyncSessionSnapshot> last_snapshot_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_