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

sync/internal_api/public/sync_manager.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 SYNC_INTERNAL_API_PUBLIC_SYNC_MANAGER_H_
 #define SYNC_INTERNAL_API_PUBLIC_SYNC_MANAGER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 104 matching lines @@
     // 3. New items with synced parents & predecessors.
     // 4. Items with parents & predecessors in |changes|.
     // 5. Repeat #4 until all items are in |changes|.
     //
     // Thus, an implementation of OnChangesApplied should be able to
     // process the change records in the order without having to worry about
     // forward dependencies.  But since deletions come before reparent
     // operations, a delete may temporarily orphan a node that is
     // updated later in the list.
     virtual void OnChangesApplied(
-        syncable::ModelType model_type,
+        syncer::ModelType model_type,
         const BaseTransaction* trans,
         const ImmutableChangeRecordList& changes) = 0;
 
     // OnChangesComplete gets called when the TransactionComplete event is
     // posted (after OnChangesApplied finishes), after the transaction lock
     // and the change channel mutex are released.
     //
     // The purpose of this function is to support processors that require
     // split-transactions changes. For example, if a model processor wants to
     // perform blocking I/O due to a change, it should calculate the changes
     // while holding the transaction lock (from within OnChangesApplied), buffer
     // those changes, let the transaction fall out of scope, and then commit
     // those changes from within OnChangesComplete (postponing the blocking
     // I/O to when it no longer holds any lock).
-    virtual void OnChangesComplete(syncable::ModelType model_type) = 0;
+    virtual void OnChangesComplete(syncer::ModelType model_type) = 0;
 
    protected:
     virtual ~ChangeDelegate();
   };
 
   // Like ChangeDelegate, except called only on the sync thread and
   // not while a transaction is held.  For objects that want to know
   // when changes happen, but don't need to process them.
   class ChangeObserver {
    public:
     // Ids referred to in |changes| may or may not be in the write
     // transaction specified by |write_transaction_id|.  If they're
     // not, that means that the node didn't actually change, but we
     // marked them as changed for some other reason (e.g., siblings of
     // re-ordered nodes).
     //
     // TODO(sync, long-term): Ideally, ChangeDelegate/Observer would
     // be passed a transformed version of EntryKernelMutation instead
     // of a transaction that would have to be used to look up the
     // changed nodes.  That is, ChangeDelegate::OnChangesApplied()
     // would still be called under the transaction, but all the needed
     // data will be passed down.
     //
     // Even more ideally, we would have sync semantics such that we'd
     // be able to apply changes without being under a transaction.
     // But that's a ways off...
     virtual void OnChangesApplied(
-        syncable::ModelType model_type,
+        syncer::ModelType model_type,
         int64 write_transaction_id,
         const ImmutableChangeRecordList& changes) = 0;
 
-    virtual void OnChangesComplete(syncable::ModelType model_type) = 0;
+    virtual void OnChangesComplete(syncer::ModelType model_type) = 0;
 
    protected:
     virtual ~ChangeObserver();
   };
 
   // An interface the embedding application implements to receive
   // notifications from the SyncManager.  Register an observer via
   // SyncManager::AddObserver.  All methods are called only on the
   // sync thread.
   class Observer {
@@ skipping 134 matching lines @@
     // |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.
     //
     // Called from within a transaction.
     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.
     //
     // Called from within a transaction.
     virtual void OnEncryptionComplete() = 0;
 
     virtual void OnActionableError(
         const syncer::SyncProtocolError& sync_protocol_error) = 0;
@@ skipping 54 matching lines @@
             syncer::UnrecoverableErrorHandler*
                 unrecoverable_error_handler,
             syncer::ReportUnrecoverableErrorFunction
                 report_unrecoverable_error_function);
 
   // Throw an unrecoverable error from a transaction (mostly used for
   // testing).
   void ThrowUnrecoverableError();
 
   // Returns the set of types for which we have stored some sync data.
-  syncable::ModelTypeSet InitialSyncEndedTypes();
+  syncer::ModelTypeSet InitialSyncEndedTypes();
 
   // Update tokens that we're using in Sync. Email must stay the same.
   void UpdateCredentials(const SyncCredentials& credentials);
 
   // Called when the user disables or enables a sync type.
-  void UpdateEnabledTypes(const syncable::ModelTypeSet& enabled_types);
+  void UpdateEnabledTypes(const syncer::ModelTypeSet& enabled_types);
 
   // Put the syncer in normal mode ready to perform nudges and polls.
   void StartSyncingNormally(
       const syncer::ModelSafeRoutingInfo& routing_info);
 
   // Attempts to re-encrypt encrypted data types using the passphrase provided.
   // Notifies observers of the result of the operation via OnPassphraseAccepted
   // or OnPassphraseRequired, updates the nigori node, and does re-encryption as
   // appropriate. If an explicit password has been set previously, we drop
   // subsequent requests to set a passphrase. If the cryptographer has pending
@@ skipping 11 matching lines @@
 
   // Puts the SyncScheduler into a mode where no normal nudge or poll traffic
   // will occur, but calls to RequestConfig will be supported.  If |callback|
   // is provided, it will be invoked (from the internal SyncScheduler) when
   // the thread has changed to configuration mode.
   void StartConfigurationMode(const base::Closure& callback);
 
   // Switches the mode of operation to CONFIGURATION_MODE and
   // schedules a config task to fetch updates for |types|.
   void RequestConfig(const syncer::ModelSafeRoutingInfo& routing_info,
-                     const syncable::ModelTypeSet& types,
+                     const syncer::ModelTypeSet& types,
                      syncer::ConfigureReason reason);
 
   void RequestCleanupDisabledTypes(
       const syncer::ModelSafeRoutingInfo& routing_info);
 
   // Adds a listener to be notified of sync events.
   // NOTE: It is OK (in fact, it's probably a good idea) to call this before
   // having received OnInitializationCompleted.
   void AddObserver(Observer* observer);
 
@@ skipping 53 matching lines @@
   // OnPassphraseRequired(), but otherwise it will trigger
   // OnEncryptionComplete().
   void EnableEncryptEverything();
 
   // Returns true if we are currently encrypting all sync data.  May
   // be called on any thread.
   bool EncryptEverythingEnabledForTest() const;
 
   // Gets the set of encrypted types from the cryptographer
   // Note: opens a transaction.  May be called from any thread.
-  syncable::ModelTypeSet GetEncryptedDataTypesForTest() const;
+  syncer::ModelTypeSet GetEncryptedDataTypesForTest() const;
 
   // Reads the nigori node to determine if any experimental features should
   // be enabled.
   // Note: opens a transaction.  May be called on any thread.
   bool ReceivedExperiment(syncer::Experiments* experiments) const;
 
   // Uses a read-only transaction to determine if the directory being synced has
   // any remaining unsynced items.  May be called on any thread.
   bool HasUnsyncedItems() const;
 
   // Functions used for testing.
 
   void SimulateEnableNotificationsForTest();
 
   void SimulateDisableNotificationsForTest(int reason);
 
   void TriggerOnIncomingNotificationForTest(
-      syncable::ModelTypeSet model_types);
+      syncer::ModelTypeSet model_types);
 
   static const int kDefaultNudgeDelayMilliseconds;
   static const int kPreferencesNudgeDelayMilliseconds;
   static const int kPiggybackNudgeDelay;
 
   static const FilePath::CharType kSyncDatabaseFilename[];
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SyncManagerTest, NudgeDelayTest);
 
   // For unit tests.
-  base::TimeDelta GetNudgeDelayTimeDelta(const syncable::ModelType& model_type);
+  base::TimeDelta GetNudgeDelayTimeDelta(const syncer::ModelType& model_type);
 
   base::ThreadChecker thread_checker_;
 
   // An opaque pointer to the nested private class.
   SyncInternal* data_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncManager);
 };
 
-bool InitialSyncEndedForTypes(syncable::ModelTypeSet types, UserShare* share);
+bool InitialSyncEndedForTypes(syncer::ModelTypeSet types, UserShare* share);
 
-syncable::ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
-    syncable::ModelTypeSet types,
+syncer::ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
+    syncer::ModelTypeSet types,
     syncer::UserShare* share);
 
 const char* ConnectionStatusToString(ConnectionStatus status);
 
 // Returns the string representation of a PassphraseRequiredReason value.
 const char* PassphraseRequiredReasonToString(PassphraseRequiredReason reason);
 
 }  // namespace syncer
 
 #endif  // SYNC_INTERNAL_API_PUBLIC_SYNC_MANAGER_H_