[Sync] Rename ModelEnumSet to ModelTypeSet

chrome/browser/sync/syncable/syncable.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_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #pragma once
 
 #include <algorithm>
 #include <bitset>
@@ skipping 755 matching lines @@
     ~PersistedKernelInfo();
 
     // Set the |download_progress| entry for the given model to a
     // "first sync" start point.  When such a value is sent to the server,
     // a full download of all objects of the model will be initiated.
     void reset_download_progress(ModelType model_type);
 
     // Last sync timestamp fetched from the server.
     sync_pb::DataTypeProgressMarker download_progress[MODEL_TYPE_COUNT];
     // true iff we ever reached the end of the changelog.
-    ModelEnumSet initial_sync_ended;
+    ModelTypeSet initial_sync_ended;
     // The store birthday we were given by the server. Contents are opaque to
     // the client.
     std::string store_birthday;
     // The next local ID that has not been used with this cache-GUID.
     int64 next_id;
     // The persisted notification state.
     std::string notification_state;
   };
 
   // What the Directory needs on initialization to create itself and its Kernel.
@@ skipping 177 matching lines @@
   // Get GetUnsyncedMetaHandles should only be called after SaveChanges and
   // before any new entries have been created. The intention is that the
   // syncer should call it from its PerformSyncQueries member.
   typedef std::vector<int64> UnsyncedMetaHandles;
   void GetUnsyncedMetaHandles(BaseTransaction* trans,
                               UnsyncedMetaHandles* result);
 
   // Returns all server types with unapplied updates.  A subset of
   // those types can then be passed into
   // GetUnappliedUpdateMetaHandles() below.
-  FullModelEnumSet GetServerTypesWithUnappliedUpdates(
+  FullModelTypeSet GetServerTypesWithUnappliedUpdates(
       BaseTransaction* trans) const;
 
   // Get all the metahandles for unapplied updates for a given set of
   // server types.
   typedef std::vector<int64> UnappliedUpdateMetaHandles;
   void GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
-                                     FullModelEnumSet server_types,
+                                     FullModelTypeSet server_types,
                                      UnappliedUpdateMetaHandles* result);
 
   // Checks tree metadata consistency.
   // If full_scan is false, the function will avoid pulling any entries from the
   // db and scan entries currently in ram.
   // If full_scan is true, all entries will be pulled from the database.
   // No return value, CHECKs will be triggered if we're given bad
   // information.
   void CheckTreeInvariants(syncable::BaseTransaction* trans,
                            bool full_scan);
 
   void CheckTreeInvariants(syncable::BaseTransaction* trans,
                            const EntryKernelMutationMap& mutations);
 
   void CheckTreeInvariants(syncable::BaseTransaction* trans,
                            const MetahandleSet& handles,
                            const IdFilter& idfilter);
 
   // Purges all data associated with any entries whose ModelType or
   // ServerModelType is found in |types|, from _both_ memory and disk.
   // Only  valid, "real" model types are allowed in |types| (see model_type.h
   // for definitions).  "Purge" is just meant to distinguish from "deleting"
   // entries, which means something different in the syncable namespace.
   // WARNING! This can be real slow, as it iterates over all entries.
   // WARNING! Performs synchronous I/O.
-  virtual void PurgeEntriesWithTypeIn(ModelEnumSet types);
+  virtual void PurgeEntriesWithTypeIn(ModelTypeSet types);
 
  private:
   // Helper to prime ids_index, parent_id_and_names_index, unsynced_metahandles
   // and unapplied_metahandles from metahandles_index.
   void InitializeIndices();
 
   // Constructs a consistent snapshot of the current Directory state and
   // indices (by deep copy) under a ReadTransaction for use in |snapshot|.
   // See SaveChanges() for more information.
   void TakeSnapshotForSaveChanges(SaveChangesSnapshot* snapshot);
@@ skipping 234 matching lines @@
                    WriterTag writer, Directory* directory);
   WriteTransaction(const tracked_objects::Location& from_here,
                    WriterTag writer, const ScopedDirLookup& directory);
 
   virtual ~WriteTransaction();
 
   void SaveOriginal(const EntryKernel* entry);
 
  protected:
   // Overridden by tests.
-  virtual void NotifyTransactionComplete(ModelEnumSet models_with_changes);
+  virtual void NotifyTransactionComplete(ModelTypeSet models_with_changes);
 
  private:
   // Clears |mutations_|.
   ImmutableEntryKernelMutationMap RecordMutations();
 
   void UnlockAndNotify(const ImmutableEntryKernelMutationMap& mutations);
 
-  ModelEnumSet NotifyTransactionChangingAndEnding(
+  ModelTypeSet NotifyTransactionChangingAndEnding(
       const ImmutableEntryKernelMutationMap& mutations);
 
   // Only the original fields are filled in until |RecordMutations()|.
   // We use a mutation map instead of a kernel set to avoid copying.
   EntryKernelMutationMap mutations_;
 
   DISALLOW_COPY_AND_ASSIGN(WriteTransaction);
 };
 
 bool IsLegalNewParent(BaseTransaction* trans, const Id& id, const Id& parentid);
 
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_