[Sync] Move //components/sync to the syncer namespace.

components/sync/driver/data_type_manager_impl.cc

 // Copyright 2014 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 "components/sync/driver/data_type_manager_impl.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "components/sync/core/data_type_debug_info_listener.h"
 #include "components/sync/driver/data_type_encryption_handler.h"
 #include "components/sync/driver/data_type_manager_observer.h"
 #include "components/sync/driver/data_type_status_table.h"
 
-using syncer::ModelTypeSet;
-
-namespace sync_driver {
+namespace syncer {
 
 namespace {
 
 DataTypeStatusTable::TypeErrorMap GenerateCryptoErrorsForTypes(
     ModelTypeSet encrypted_types) {
   DataTypeStatusTable::TypeErrorMap crypto_errors;
   for (ModelTypeSet::Iterator iter = encrypted_types.First(); iter.Good();
        iter.Inc()) {
-    crypto_errors[iter.Get()] = syncer::SyncError(
-        FROM_HERE, syncer::SyncError::CRYPTO_ERROR, "", iter.Get());
+    crypto_errors[iter.Get()] =
+        SyncError(FROM_HERE, SyncError::CRYPTO_ERROR, "", iter.Get());
   }
   return crypto_errors;
 }
 
 }  // namespace
 
 DataTypeManagerImpl::AssociationTypesInfo::AssociationTypesInfo() {}
 DataTypeManagerImpl::AssociationTypesInfo::AssociationTypesInfo(
     const AssociationTypesInfo& other) = default;
 DataTypeManagerImpl::AssociationTypesInfo::~AssociationTypesInfo() {}
 
 DataTypeManagerImpl::DataTypeManagerImpl(
-    const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
-        debug_info_listener,
+    const WeakHandle<DataTypeDebugInfoListener>& debug_info_listener,
     const DataTypeController::TypeMap* controllers,
     const DataTypeEncryptionHandler* encryption_handler,
     BackendDataTypeConfigurer* configurer,
     DataTypeManagerObserver* observer)
     : configurer_(configurer),
       controllers_(controllers),
       state_(DataTypeManager::STOPPED),
       needs_reconfigure_(false),
-      last_configure_reason_(syncer::CONFIGURE_REASON_UNKNOWN),
+      last_configure_reason_(CONFIGURE_REASON_UNKNOWN),
       debug_info_listener_(debug_info_listener),
       model_association_manager_(controllers, this),
       observer_(observer),
       encryption_handler_(encryption_handler),
       catch_up_in_progress_(false),
       download_started_(false),
       weak_ptr_factory_(this) {
   DCHECK(configurer_);
   DCHECK(observer_);
 }
 
 DataTypeManagerImpl::~DataTypeManagerImpl() {}
 
 void DataTypeManagerImpl::Configure(ModelTypeSet desired_types,
-                                    syncer::ConfigureReason reason) {
+                                    ConfigureReason reason) {
   // Once requested, we will remain in "catch up" mode until we notify the
   // caller (see NotifyDone). We do this to ensure that once started, subsequent
   // calls to Configure won't take us out of "catch up" mode.
-  if (reason == syncer::CONFIGURE_REASON_CATCH_UP)
+  if (reason == CONFIGURE_REASON_CATCH_UP)
     catch_up_in_progress_ = true;
 
-  desired_types.PutAll(syncer::CoreTypes());
+  desired_types.PutAll(CoreTypes());
 
   // Only allow control types and types that have controllers.
   ModelTypeSet filtered_desired_types;
   for (ModelTypeSet::Iterator type = desired_types.First(); type.Good();
        type.Inc()) {
     DataTypeController::TypeMap::const_iterator iter =
         controllers_->find(type.Get());
-    if (syncer::IsControlType(type.Get()) || iter != controllers_->end()) {
+    if (IsControlType(type.Get()) || iter != controllers_->end()) {
       if (iter != controllers_->end()) {
         if (!iter->second->ReadyForStart() &&
             !data_type_status_table_.GetUnreadyErrorTypes().Has(type.Get())) {
           // Add the type to the unready types set to prevent purging it. It's
           // up to the datatype controller to, if necessary, explicitly
           // mark the type as broken to trigger a purge.
-          syncer::SyncError error(FROM_HERE, syncer::SyncError::UNREADY_ERROR,
-                                  "Datatype not ready at config time.",
-                                  type.Get());
-          std::map<syncer::ModelType, syncer::SyncError> errors;
+          SyncError error(FROM_HERE, SyncError::UNREADY_ERROR,
+                          "Datatype not ready at config time.", type.Get());
+          std::map<ModelType, SyncError> errors;
           errors[type.Get()] = error;
           data_type_status_table_.UpdateFailedDataTypes(errors);
         } else if (iter->second->ReadyForStart()) {
           data_type_status_table_.ResetUnreadyErrorFor(type.Get());
         }
       }
       filtered_desired_types.Put(type.Get());
     }
   }
   ConfigureImpl(filtered_desired_types, reason);
 }
 
-void DataTypeManagerImpl::ReenableType(syncer::ModelType type) {
+void DataTypeManagerImpl::ReenableType(ModelType type) {
   // TODO(zea): move the "should we reconfigure" logic into the datatype handler
   // itself.
   // Only reconfigure if the type actually had a data type or unready error.
   if (!data_type_status_table_.ResetDataTypeErrorFor(type) &&
       !data_type_status_table_.ResetUnreadyErrorFor(type)) {
     return;
   }
 
   // Only reconfigure if the type is actually desired.
   if (!last_requested_types_.Has(type))
     return;
 
-  DVLOG(1) << "Reenabling " << syncer::ModelTypeToString(type);
+  DVLOG(1) << "Reenabling " << ModelTypeToString(type);
   needs_reconfigure_ = true;
-  last_configure_reason_ = syncer::CONFIGURE_REASON_PROGRAMMATIC;
+  last_configure_reason_ = CONFIGURE_REASON_PROGRAMMATIC;
   ProcessReconfigure();
 }
 
 void DataTypeManagerImpl::ResetDataTypeErrors() {
   data_type_status_table_.Reset();
 }
 
 void DataTypeManagerImpl::PurgeForMigration(ModelTypeSet undesired_types,
-                                            syncer::ConfigureReason reason) {
+                                            ConfigureReason reason) {
   ModelTypeSet remainder = Difference(last_requested_types_, undesired_types);
   ConfigureImpl(remainder, reason);
 }
 
 void DataTypeManagerImpl::ConfigureImpl(ModelTypeSet desired_types,
-                                        syncer::ConfigureReason reason) {
-  DCHECK_NE(reason, syncer::CONFIGURE_REASON_UNKNOWN);
+                                        ConfigureReason reason) {
+  DCHECK_NE(reason, CONFIGURE_REASON_UNKNOWN);
   DVLOG(1) << "Configuring for " << ModelTypeSetToString(desired_types)
            << " with reason " << reason;
   if (state_ == STOPPING) {
     // You can not set a configuration while stopping.
     LOG(ERROR) << "Configuration set while stopping.";
     return;
   }
 
   // TODO(zea): consider not performing a full configuration once there's a
   // reliable way to determine if the requested set of enabled types matches the
@@ skipping 43 matching lines @@
   // Types with unready errors do not count as unready if they've been disabled.
   unready_types.RetainAll(last_requested_types_);
 
   ModelTypeSet enabled_types = GetEnabledTypes();
 
   // If we're catching up, add all enabled (non-error) types to the clean set to
   // ensure we download and apply them to the model types.
   if (catch_up_in_progress_)
     clean_types.PutAll(enabled_types);
 
-  ModelTypeSet disabled_types = syncer::Difference(
-      syncer::Union(syncer::UserTypes(), syncer::ControlTypes()),
-      enabled_types);
+  ModelTypeSet disabled_types =
+      Difference(Union(UserTypes(), ControlTypes()), enabled_types);
   ModelTypeSet to_configure =
-      syncer::Intersection(enabled_types, types_being_configured);
+      Intersection(enabled_types, types_being_configured);
   DVLOG(1) << "Enabling: " << ModelTypeSetToString(enabled_types);
   DVLOG(1) << "Configuring: " << ModelTypeSetToString(to_configure);
   DVLOG(1) << "Disabling: " << ModelTypeSetToString(disabled_types);
 
   BackendDataTypeConfigurer::DataTypeConfigStateMap config_state_map;
   BackendDataTypeConfigurer::SetDataTypesState(
       BackendDataTypeConfigurer::CONFIGURE_INACTIVE, enabled_types,
       &config_state_map);
   BackendDataTypeConfigurer::SetDataTypesState(
       BackendDataTypeConfigurer::CONFIGURE_ACTIVE, to_configure,
       &config_state_map);
   BackendDataTypeConfigurer::SetDataTypesState(
       BackendDataTypeConfigurer::CONFIGURE_CLEAN, clean_types,
       &config_state_map);
   BackendDataTypeConfigurer::SetDataTypesState(
       BackendDataTypeConfigurer::DISABLED, disabled_types, &config_state_map);
   BackendDataTypeConfigurer::SetDataTypesState(BackendDataTypeConfigurer::FATAL,
                                                fatal_types, &config_state_map);
   BackendDataTypeConfigurer::SetDataTypesState(
       BackendDataTypeConfigurer::CRYPTO, crypto_types, &config_state_map);
   BackendDataTypeConfigurer::SetDataTypesState(
       BackendDataTypeConfigurer::UNREADY, unready_types, &config_state_map);
   return config_state_map;
 }
 
-void DataTypeManagerImpl::Restart(syncer::ConfigureReason reason) {
+void DataTypeManagerImpl::Restart(ConfigureReason reason) {
   DVLOG(1) << "Restarting...";
 
   // Only record the type histograms for user-triggered configurations or
   // restarts.
-  if (reason == syncer::CONFIGURE_REASON_RECONFIGURATION ||
-      reason == syncer::CONFIGURE_REASON_NEW_CLIENT ||
-      reason == syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE) {
+  if (reason == CONFIGURE_REASON_RECONFIGURATION ||
+      reason == CONFIGURE_REASON_NEW_CLIENT ||
+      reason == CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE) {
     for (ModelTypeSet::Iterator iter = last_requested_types_.First();
          iter.Good(); iter.Inc()) {
       UMA_HISTOGRAM_ENUMERATION("Sync.ConfigureDataTypes",
-                                syncer::ModelTypeToHistogramInt(iter.Get()),
-                                syncer::MODEL_TYPE_COUNT);
+                                ModelTypeToHistogramInt(iter.Get()),
+                                MODEL_TYPE_COUNT);
     }
   }
 
   // Check for new or resolved data type crypto errors.
   if (encryption_handler_->IsPassphraseRequired()) {
     ModelTypeSet encrypted_types = encryption_handler_->GetEncryptedDataTypes();
     encrypted_types.RetainAll(last_requested_types_);
     encrypted_types.RemoveAll(data_type_status_table_.GetCryptoErrorTypes());
     DataTypeStatusTable::TypeErrorMap crypto_errors =
         GenerateCryptoErrorsForTypes(encrypted_types);
@@ skipping 37 matching lines @@
                            base::Time::Now() - last_restart_time_);
   // TODO(pavely): By now some of datatypes in |download_types_queue_| could
   // have failed loading and should be excluded from configuration. I need to
   // adjust |download_types_queue_| for such types.
   RegisterTypesWithBackend();
   StartNextDownload(ModelTypeSet());
 }
 
 ModelTypeSet DataTypeManagerImpl::GetPriorityTypes() const {
   ModelTypeSet high_priority_types;
-  high_priority_types.PutAll(syncer::PriorityCoreTypes());
-  high_priority_types.PutAll(syncer::PriorityUserTypes());
+  high_priority_types.PutAll(PriorityCoreTypes());
+  high_priority_types.PutAll(PriorityUserTypes());
   return high_priority_types;
 }
 
 TypeSetPriorityList DataTypeManagerImpl::PrioritizeTypes(
     const ModelTypeSet& types) {
   ModelTypeSet high_priority_types = GetPriorityTypes();
   high_priority_types.RetainAll(types);
 
-  ModelTypeSet low_priority_types =
-      syncer::Difference(types, high_priority_types);
+  ModelTypeSet low_priority_types = Difference(types, high_priority_types);
 
   TypeSetPriorityList result;
   if (!high_priority_types.Empty())
     result.push(high_priority_types);
   if (!low_priority_types.Empty())
     result.push(low_priority_types);
 
   // Could be empty in case of purging for migration, sync nothing, etc.
   // Configure empty set to purge data from backend.
   if (result.empty())
@@ skipping 47 matching lines @@
   DCHECK_EQ(CONFIGURING, state_);
 
   // Persistence errors are reset after each backend configuration attempt
   // during which they would have been purged.
   data_type_status_table_.ResetPersistenceErrorsFrom(types_to_download);
 
   if (!failed_configuration_types.Empty()) {
     DataTypeStatusTable::TypeErrorMap errors;
     for (ModelTypeSet::Iterator iter = failed_configuration_types.First();
          iter.Good(); iter.Inc()) {
-      syncer::SyncError error(FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
-                              "Backend failed to download type.", iter.Get());
+      SyncError error(FROM_HERE, SyncError::DATATYPE_ERROR,
+                      "Backend failed to download type.", iter.Get());
       errors[iter.Get()] = error;
     }
     data_type_status_table_.UpdateFailedDataTypes(errors);
     needs_reconfigure_ = true;
   }
 
   if (needs_reconfigure_) {
     download_types_queue_ = TypeSetPriorityList();
     ProcessReconfigure();
     return;
@@ skipping 79 matching lines @@
     // We request the full set of types here for completeness sake. All types
     // within the READY_AT_CONFIG set will already be started and should be
     // no-ops.
     types_to_associate = association_types_queue_.front().types;
   }
 
   DVLOG(1) << "Associating " << ModelTypeSetToString(types_to_associate);
   model_association_manager_.StartAssociationAsync(types_to_associate);
 }
 
-void DataTypeManagerImpl::OnSingleDataTypeWillStop(
-    syncer::ModelType type,
-    const syncer::SyncError& error) {
+void DataTypeManagerImpl::OnSingleDataTypeWillStop(ModelType type,
+                                                   const SyncError& error) {
   DataTypeController::TypeMap::const_iterator c_it = controllers_->find(type);
   DCHECK(c_it != controllers_->end());
   // Delegate deactivation to the controller.
   c_it->second->DeactivateDataType(configurer_);
 
   if (error.IsSet()) {
     DataTypeStatusTable::TypeErrorMap failed_types;
     failed_types[type] = error;
     data_type_status_table_.UpdateFailedDataTypes(failed_types);
 
     // Unrecoverable errors will shut down the entire backend, so no need to
     // reconfigure.
-    if (error.error_type() != syncer::SyncError::UNRECOVERABLE_ERROR) {
+    if (error.error_type() != SyncError::UNRECOVERABLE_ERROR) {
       needs_reconfigure_ = true;
-      last_configure_reason_ = syncer::CONFIGURE_REASON_PROGRAMMATIC;
+      last_configure_reason_ = CONFIGURE_REASON_PROGRAMMATIC;
       // Do this asynchronously so the ModelAssociationManager has a chance to
       // finish stopping this type, otherwise DeactivateDataType() and Stop()
       // end up getting called twice on the controller.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&DataTypeManagerImpl::ProcessReconfigure,
                                 weak_ptr_factory_.GetWeakPtr()));
     }
   }
 }
 
 void DataTypeManagerImpl::OnSingleDataTypeAssociationDone(
-    syncer::ModelType type,
-    const syncer::DataTypeAssociationStats& association_stats) {
+    ModelType type,
+    const DataTypeAssociationStats& association_stats) {
   DCHECK(!association_types_queue_.empty());
   DataTypeController::TypeMap::const_iterator c_it = controllers_->find(type);
   DCHECK(c_it != controllers_->end());
   if (c_it->second->state() == DataTypeController::RUNNING) {
     // Delegate activation to the controller.
     c_it->second->ActivateDataType(configurer_);
   }
 
   if (!debug_info_listener_.IsInitialized())
     return;
 
   AssociationTypesInfo& info = association_types_queue_.front();
-  configuration_stats_.push_back(syncer::DataTypeConfigurationStats());
+  configuration_stats_.push_back(DataTypeConfigurationStats());
   configuration_stats_.back().model_type = type;
   configuration_stats_.back().association_stats = association_stats;
   if (info.types.Has(type)) {
     // Times in |info| only apply to non-slow types.
     configuration_stats_.back().download_wait_time =
         info.download_start_time - last_restart_time_;
     if (info.first_sync_types.Has(type)) {
       configuration_stats_.back().download_time =
           info.download_ready_time - info.download_start_time;
     }
@@ skipping 104 matching lines @@
   DVLOG(1) << "Total time spent configuring: "
            << configure_time_delta_.InSecondsF() << "s";
   switch (result.status) {
     case DataTypeManager::OK:
       DVLOG(1) << "NotifyDone called with result: OK";
       UMA_HISTOGRAM_LONG_TIMES("Sync.ConfigureTime_Long.OK",
                                configure_time_delta_);
       if (debug_info_listener_.IsInitialized() &&
           !configuration_stats_.empty()) {
         debug_info_listener_.Call(
-            FROM_HERE,
-            &syncer::DataTypeDebugInfoListener::OnDataTypeConfigureComplete,
+            FROM_HERE, &DataTypeDebugInfoListener::OnDataTypeConfigureComplete,
             configuration_stats_);
       }
       configuration_stats_.clear();
       break;
     case DataTypeManager::ABORTED:
       DVLOG(1) << "NotifyDone called with result: ABORTED";
       UMA_HISTOGRAM_LONG_TIMES("Sync.ConfigureTime_Long.ABORTED",
                                configure_time_delta_);
       break;
     case DataTypeManager::UNRECOVERABLE_ERROR:
@@ skipping 11 matching lines @@
 DataTypeManager::State DataTypeManagerImpl::state() const {
   return state_;
 }
 
 void DataTypeManagerImpl::AddToConfigureTime() {
   DCHECK(!last_restart_time_.is_null());
   configure_time_delta_ += (base::Time::Now() - last_restart_time_);
 }
 
 ModelTypeSet DataTypeManagerImpl::GetEnabledTypes() const {
-  return syncer::Difference(last_requested_types_,
-                            data_type_status_table_.GetFailedTypes());
+  return Difference(last_requested_types_,
+                    data_type_status_table_.GetFailedTypes());
 }
 
-}  // namespace sync_driver
+}  // namespace syncer