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

chrome/browser/sync/glue/model_association_manager.cc

 // 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.
 
 #include <algorithm>
 #include <functional>
 
 #include "base/debug/trace_event.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 
 #include "chrome/browser/sync/glue/model_association_manager.h"
 
-#include "content/public/browser/browser_thread.h"
 #include <algorithm>
 #include <functional>
+#include "content/public/browser/browser_thread.h"
 
 #include "base/debug/trace_event.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 
 
 using content::BrowserThread;
-using syncable::ModelTypeSet;
+using syncer::ModelTypeSet;
 
 namespace browser_sync {
 // The amount of time we wait for a datatype to load. If the type has
 // not finished loading we move on to the next type. Once this type
 // finishes loading we will do a configure to associate this type. Note
 // that in most cases types finish loading before this timeout.
 const int64 kDataTypeLoadWaitTimeInSeconds = 120;
 namespace {
 
-static const syncable::ModelType kStartOrder[] = {
-  syncable::NIGORI,               //  Listed for completeness.
-  syncable::BOOKMARKS,            //  UI thread datatypes.
-  syncable::PREFERENCES,
-  syncable::EXTENSIONS,
-  syncable::APPS,
-  syncable::THEMES,
-  syncable::SEARCH_ENGINES,
-  syncable::SESSIONS,
-  syncable::APP_NOTIFICATIONS,
-  syncable::AUTOFILL,             // Non-UI thread datatypes.
-  syncable::AUTOFILL_PROFILE,
-  syncable::EXTENSION_SETTINGS,
-  syncable::APP_SETTINGS,
-  syncable::TYPED_URLS,
-  syncable::PASSWORDS,
+static const syncer::ModelType kStartOrder[] = {
+  syncer::NIGORI,               //  Listed for completeness.
+  syncer::BOOKMARKS,            //  UI thread datatypes.
+  syncer::PREFERENCES,
+  syncer::EXTENSIONS,
+  syncer::APPS,
+  syncer::THEMES,
+  syncer::SEARCH_ENGINES,
+  syncer::SESSIONS,
+  syncer::APP_NOTIFICATIONS,
+  syncer::AUTOFILL,             // Non-UI thread datatypes.
+  syncer::AUTOFILL_PROFILE,
+  syncer::EXTENSION_SETTINGS,
+  syncer::APP_SETTINGS,
+  syncer::TYPED_URLS,
+  syncer::PASSWORDS,
 };
 
 COMPILE_ASSERT(arraysize(kStartOrder) ==
-               syncable::MODEL_TYPE_COUNT - syncable::FIRST_REAL_MODEL_TYPE,
+               syncer::MODEL_TYPE_COUNT - syncer::FIRST_REAL_MODEL_TYPE,
                kStartOrder_IncorrectSize);
 
 // Comparator used when sorting data type controllers.
 class SortComparator : public std::binary_function<DataTypeController*,
                                                    DataTypeController*,
                                                    bool> {
  public:
-  explicit SortComparator(std::map<syncable::ModelType, int>* order)
+  explicit SortComparator(std::map<syncer::ModelType, int>* order)
       : order_(order) { }
 
   // Returns true if lhs precedes rhs.
   bool operator() (DataTypeController* lhs, DataTypeController* rhs) {
     return (*order_)[lhs->type()] < (*order_)[rhs->type()];
   }
 
  private:
-  std::map<syncable::ModelType, int>* order_;
+  std::map<syncer::ModelType, int>* order_;
 };
 
 }  // namespace
 
 ModelAssociationManager::ModelAssociationManager(
     const DataTypeController::TypeMap* controllers,
     ModelAssociationResultProcessor* processor)
     : state_(IDLE),
       currently_associating_(NULL),
       controllers_(controllers),
       result_processor_(processor),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 
   // Ensure all data type controllers are stopped.
   for (DataTypeController::TypeMap::const_iterator it = controllers_->begin();
        it != controllers_->end(); ++it) {
     DCHECK_EQ(DataTypeController::NOT_RUNNING, (*it).second->state());
   }
 
   // Build a ModelType -> order map for sorting.
   for (int i = 0; i < static_cast<int>(arraysize(kStartOrder)); i++)
     start_order_[kStartOrder[i]] = i;
 }
 
 ModelAssociationManager::~ModelAssociationManager() {
 }
 
-void ModelAssociationManager::Initialize(
-    syncable::ModelTypeSet desired_types) {
+void ModelAssociationManager::Initialize(syncer::ModelTypeSet desired_types) {
   // TODO(tim): Bug 134550.  CHECKing to ensure no reentrancy on dev channel.
   // Remove this.
   CHECK_EQ(state_, IDLE);
   needs_start_.clear();
   needs_stop_.clear();
   failed_datatypes_info_.clear();
   desired_types_ = desired_types;
   state_ = INITIALIZED_TO_CONFIGURE;
 
   DVLOG(1) << "ModelAssociationManager: Initializing";
@@ skipping 108 matching lines @@
       dtc->Stop();
       DVLOG(1) << "ModelAssociationManager: Stopped " << dtc->name();
     }
   }
 
   if (need_to_call_model_association_done) {
     DVLOG(1) << "ModelAssociationManager: Calling OnModelAssociationDone";
     DataTypeManager::ConfigureResult result(DataTypeManager::ABORTED,
                                             desired_types_,
                                             failed_datatypes_info_,
-                                            syncable::ModelTypeSet());
+                                            syncer::ModelTypeSet());
     result_processor_->OnModelAssociationDone(result);
   }
 
   failed_datatypes_info_.clear();
 }
 
 bool ModelAssociationManager::GetControllersNeedingStart(
     std::vector<DataTypeController*>* needs_start) {
   DVLOG(1) << "ModelAssociationManager: GetControllersNeedingStart";
   // Add any data type controllers into the needs_start_ list that are
   // currently NOT_RUNNING or STOPPING.
   bool found_any = false;
   for (ModelTypeSet::Iterator it = desired_types_.First();
        it.Good(); it.Inc()) {
     DataTypeController::TypeMap::const_iterator dtc =
         controllers_->find(it.Get());
     if (dtc != controllers_->end() &&
         (dtc->second->state() == DataTypeController::NOT_RUNNING ||
          dtc->second->state() == DataTypeController::STOPPING)) {
       found_any = true;
       if (needs_start)
         needs_start->push_back(dtc->second.get());
       if (dtc->second->state() == DataTypeController::DISABLED) {
         DVLOG(1) << "ModelAssociationManager: Found "\
-                << syncable::ModelTypeToString(dtc->second->type())
+                << syncer::ModelTypeToString(dtc->second->type())
                  << " in disabled state.";
       }
     }
   }
   return found_any;
 }
 
 void ModelAssociationManager::AppendToFailedDatatypesAndLogError(
     DataTypeController::StartResult result,
     const syncer::SyncError& error) {
   failed_datatypes_info_.push_back(error);
   LOG(ERROR) << "Failed to associate models for "
-             << syncable::ModelTypeToString(error.type());
+             << syncer::ModelTypeToString(error.type());
   UMA_HISTOGRAM_ENUMERATION("Sync.ConfigureFailed",
                             error.type(),
-                            syncable::MODEL_TYPE_COUNT);
+                            syncer::MODEL_TYPE_COUNT);
 }
 
 void ModelAssociationManager::TypeStartCallback(
     DataTypeController::StartResult result,
     const syncer::SyncError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT_END0("sync", "ModelAssociation");
 
   DVLOG(1) << "ModelAssociationManager: TypeStartCallback";
   if (state_ == ABORTED) {
@@ skipping 50 matching lines @@
 
   std::list<syncer::SyncError> errors;
   errors.push_back(error);
 
   // Put our state to idle.
   state_ = IDLE;
 
   DataTypeManager::ConfigureResult configure_result(configure_status,
                                                     desired_types_,
                                                     errors,
-                                                    syncable::ModelTypeSet());
+                                                    syncer::ModelTypeSet());
   result_processor_->OnModelAssociationDone(configure_result);
 }
 
 void ModelAssociationManager::LoadModelForNextType() {
   DVLOG(1) << "ModelAssociationManager: LoadModelForNextType";
   if (!needs_start_.empty()) {
     DVLOG(1) << "ModelAssociationManager: Starting " << needs_start_[0]->name();
 
     DataTypeController* dtc = needs_start_[0];
     needs_start_.erase(needs_start_.begin());
@@ skipping 12 matching lines @@
 
   DVLOG(1) << "ModelAssociationManager: All types have models loaded."
           << "Moving on to StartAssociatingNextType.";
 
   // If all controllers have their |LoadModels| invoked then pass onto
   // |StartAssociatingNextType|.
   StartAssociatingNextType();
 }
 
 void ModelAssociationManager::ModelLoadCallback(
-    syncable::ModelType type, syncer::SyncError error) {
+    syncer::ModelType type, syncer::SyncError error) {
   DVLOG(1) << "ModelAssociationManager: ModelLoadCallback for "
-          << syncable::ModelTypeToString(type);
+          << syncer::ModelTypeToString(type);
   if (state_ == CONFIGURING) {
     DVLOG(1) << "ModelAssociationManager: ModelLoadCallback while configuring";
     for (std::vector<DataTypeController*>::iterator it =
              pending_model_load_.begin();
           it != pending_model_load_.end();
           ++it) {
       if ((*it)->type() == type) {
         // Each type is given |kDataTypeLoadWaitTimeInSeconds| time to load
         // (as controlled by the timer.). If the type does not load in that
         // time we move on to the next type. However if the type does
@@ skipping 70 matching lines @@
   // things like encryption, which may still need to be sorted out before we
   // can announce we're "Done" configuration entirely.
   if (GetControllersNeedingStart(NULL)) {
     DVLOG(1) << "ModelAssociationManager: GetControllersNeedingStart"
              << " returned true. Blocking DataTypeManager";
 
     DataTypeManager::ConfigureResult configure_result(
         DataTypeManager::CONFIGURE_BLOCKED,
         desired_types_,
         failed_datatypes_info_,
-        syncable::ModelTypeSet());
+        syncer::ModelTypeSet());
     state_ = IDLE;
     result_processor_->OnModelAssociationDone(configure_result);
     return;
   }
 
   DataTypeManager::ConfigureStatus configure_status = DataTypeManager::OK;
 
   if (!failed_datatypes_info_.empty() ||
       !GetTypesWaitingToLoad().Empty()) {
     // We have not configured all types that we have been asked to configure.
     // Either we have failed types or types that have not completed loading
     // yet.
     DVLOG(1) << "ModelAssociationManager: setting partial success";
     configure_status = DataTypeManager::PARTIAL_SUCCESS;
   }
 
   DataTypeManager::ConfigureResult result(configure_status,
                                           desired_types_,
                                           failed_datatypes_info_,
                                           GetTypesWaitingToLoad());
   result_processor_->OnModelAssociationDone(result);
   return;
 }
 
-syncable::ModelTypeSet ModelAssociationManager::GetTypesWaitingToLoad() {
-  syncable::ModelTypeSet result;
+syncer::ModelTypeSet ModelAssociationManager::GetTypesWaitingToLoad() {
+  syncer::ModelTypeSet result;
   for (std::vector<DataTypeController*>::const_iterator it =
            pending_model_load_.begin();
        it != pending_model_load_.end();
        ++it) {
     result.Put((*it)->type());
   }
   return result;
 }
 
 base::OneShotTimer<ModelAssociationManager>*
     ModelAssociationManager::GetTimerForTesting() {
   return &timer_;
 }
 
 }  // namespace browser_sync