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

chrome/browser/sync/glue/model_association_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 CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATION_MANAGER_H__
 #define CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATION_MANAGER_H__
 #pragma once
 
 #include <list>
 
@@ skipping 30 matching lines @@
 class ModelAssociationManager {
  public:
   ModelAssociationManager(const DataTypeController::TypeMap* controllers,
                           ModelAssociationResultProcessor* processor);
   virtual ~ModelAssociationManager();
 
   // Initializes the state to do the model association in future. This
   // should be called before communicating with sync server. A subsequent call
   // of Initialize is only allowed if the ModelAssociationManager has invoked
   // |OnModelAssociationDone| on the |ModelAssociationResultProcessor|.
-  void Initialize(syncable::ModelTypeSet desired_types);
+  void Initialize(syncer::ModelTypeSet desired_types);
 
   // Can be called at any time. Synchronously stops all datatypes.
   void Stop();
 
   // Should only be called after Initialize.
   // Starts the actual association. When this is completed
   // |OnModelAssociationDone| would be called invoked.
   void StartAssociationAsync();
 
   // It is valid to call this only when we are initialized to configure
@@ skipping 32 matching lines @@
   bool GetControllersNeedingStart(
       std::vector<DataTypeController*>* needs_start);
 
   // Callback passed to each data type controller on starting association. This
   // callback will be invoked when the model association is done.
   void TypeStartCallback(DataTypeController::StartResult result,
                          const syncer::SyncError& error);
 
   // Callback that will be invoked when the models finish loading. This callback
   // will be passed to |LoadModels| function.
-  void ModelLoadCallback(syncable::ModelType type, syncer::SyncError error);
+  void ModelLoadCallback(syncer::ModelType type, syncer::SyncError error);
 
   // Calls the |LoadModels| method on the next controller waiting to start.
   void LoadModelForNextType();
 
   // Calls |StartAssociating| on the next available controller whose models are
   // loaded.
   void StartAssociatingNextType();
 
   // When a type fails to load or fails associating this method is invoked to
   // do the book keeping and do the UMA reporting.
   void AppendToFailedDatatypesAndLogError(
       DataTypeController::StartResult result,
       const syncer::SyncError& error);
 
-  syncable::ModelTypeSet GetTypesWaitingToLoad();
+  syncer::ModelTypeSet GetTypesWaitingToLoad();
 
 
   State state_;
-  syncable::ModelTypeSet desired_types_;
+  syncer::ModelTypeSet desired_types_;
   std::list<syncer::SyncError> failed_datatypes_info_;
-  std::map<syncable::ModelType, int> start_order_;
+  std::map<syncer::ModelType, int> start_order_;
 
   // This illustration explains the movement of one DTC through various lists.
   // Consider a dataype, say, BOOKMARKS which is NOT_RUNNING and will be
   // configured now.
   // Initially all lists are empty. BOOKMARKS is in the |controllers_|
   // map. Here is how the controller moves to various list
   // (indicated by arrows). The first column is the method that causes the
   // transition.
   // Step 1 : |Initialize| - |controllers_| -> |needs_start_|
   // Step 2 : |LoadModelForNextType| - |needs_start_| -> |pending_model_load_|
@@ skipping 24 matching lines @@
 
   // Set of all registered controllers.
   const DataTypeController::TypeMap* controllers_;
   ModelAssociationResultProcessor* result_processor_;
   base::WeakPtrFactory<ModelAssociationManager> weak_ptr_factory_;
   base::OneShotTimer<ModelAssociationManager> timer_;
   DISALLOW_COPY_AND_ASSIGN(ModelAssociationManager);
 };
 }  // namespace browser_sync
 #endif  // CHROME_BROWSER_SYNC_GLUE_MODEL_ASSOCIATION_MANAGER_H__