Home | History | Annotate | Download | only in sync_driver 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/sync_driver/data_type_manager_impl.h"
      6 
      7 #include <algorithm>
      8 #include <functional>
      9 
     10 #include "base/bind.h"
     11 #include "base/bind_helpers.h"
     12 #include "base/callback.h"
     13 #include "base/compiler_specific.h"
     14 #include "base/debug/trace_event.h"
     15 #include "base/logging.h"
     16 #include "base/metrics/histogram.h"
     17 #include "base/strings/stringprintf.h"
     18 #include "components/sync_driver/data_type_controller.h"
     19 #include "components/sync_driver/data_type_encryption_handler.h"
     20 #include "components/sync_driver/data_type_manager_observer.h"
     21 #include "components/sync_driver/failed_data_types_handler.h"
     22 #include "sync/internal_api/public/data_type_debug_info_listener.h"
     23 
     24 namespace browser_sync {
     25 
     26 namespace {
     27 
     28 FailedDataTypesHandler::TypeErrorMap
     29 GenerateCryptoErrorsForTypes(syncer::ModelTypeSet encrypted_types) {
     30   FailedDataTypesHandler::TypeErrorMap crypto_errors;
     31   for (syncer::ModelTypeSet::Iterator iter = encrypted_types.First();
     32          iter.Good(); iter.Inc()) {
     33     crypto_errors[iter.Get()] = syncer::SyncError(
     34         FROM_HERE,
     35         syncer::SyncError::CRYPTO_ERROR,
     36         "",
     37         iter.Get());
     38   }
     39   return crypto_errors;
     40 }
     41 
     42 }  // namespace
     43 
     44 DataTypeManagerImpl::AssociationTypesInfo::AssociationTypesInfo() {}
     45 DataTypeManagerImpl::AssociationTypesInfo::~AssociationTypesInfo() {}
     46 
     47 DataTypeManagerImpl::DataTypeManagerImpl(
     48     const base::Closure& unrecoverable_error_method,
     49     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
     50         debug_info_listener,
     51     const DataTypeController::TypeMap* controllers,
     52     const browser_sync::DataTypeEncryptionHandler* encryption_handler,
     53     BackendDataTypeConfigurer* configurer,
     54     DataTypeManagerObserver* observer,
     55     browser_sync::FailedDataTypesHandler* failed_data_types_handler)
     56     : configurer_(configurer),
     57       controllers_(controllers),
     58       state_(DataTypeManager::STOPPED),
     59       needs_reconfigure_(false),
     60       last_configure_reason_(syncer::CONFIGURE_REASON_UNKNOWN),
     61       debug_info_listener_(debug_info_listener),
     62       model_association_manager_(controllers, this),
     63       observer_(observer),
     64       failed_data_types_handler_(failed_data_types_handler),
     65       encryption_handler_(encryption_handler),
     66       unrecoverable_error_method_(unrecoverable_error_method),
     67       weak_ptr_factory_(this) {
     68   DCHECK(failed_data_types_handler_);
     69   DCHECK(configurer_);
     70   DCHECK(observer_);
     71 }
     72 
     73 DataTypeManagerImpl::~DataTypeManagerImpl() {}
     74 
     75 void DataTypeManagerImpl::Configure(syncer::ModelTypeSet desired_types,
     76                                     syncer::ConfigureReason reason) {
     77   if (reason == syncer::CONFIGURE_REASON_BACKUP_ROLLBACK)
     78     desired_types.PutAll(syncer::ControlTypes());
     79   else
     80     desired_types.PutAll(syncer::CoreTypes());
     81 
     82   // Only allow control types and types that have controllers.
     83   syncer::ModelTypeSet filtered_desired_types;
     84   for (syncer::ModelTypeSet::Iterator type = desired_types.First();
     85       type.Good(); type.Inc()) {
     86     DataTypeController::TypeMap::const_iterator iter =
     87         controllers_->find(type.Get());
     88     if (syncer::IsControlType(type.Get()) ||
     89         iter != controllers_->end()) {
     90       if (iter != controllers_->end()) {
     91         if (!iter->second->ReadyForStart()) {
     92           // Add the type to the unready types set to prevent purging it. It's
     93           // up to the datatype controller to, if necessary, explicitly
     94           // mark the type as broken to trigger a purge.
     95           syncer::SyncError error(FROM_HERE,
     96                                   syncer::SyncError::UNREADY_ERROR,
     97                                   "Datatype not ready at config time.",
     98                                   type.Get());
     99           std::map<syncer::ModelType, syncer::SyncError> errors;
    100           errors[type.Get()] = error;
    101           failed_data_types_handler_->UpdateFailedDataTypes(errors);
    102         } else {
    103           failed_data_types_handler_->ResetUnreadyErrorFor(type.Get());
    104         }
    105       }
    106       filtered_desired_types.Put(type.Get());
    107     }
    108   }
    109   ConfigureImpl(filtered_desired_types, reason);
    110 }
    111 
    112 void DataTypeManagerImpl::PurgeForMigration(
    113     syncer::ModelTypeSet undesired_types,
    114     syncer::ConfigureReason reason) {
    115   syncer::ModelTypeSet remainder = Difference(last_requested_types_,
    116                                               undesired_types);
    117   ConfigureImpl(remainder, reason);
    118 }
    119 
    120 void DataTypeManagerImpl::ConfigureImpl(
    121     syncer::ModelTypeSet desired_types,
    122     syncer::ConfigureReason reason) {
    123   DCHECK_NE(reason, syncer::CONFIGURE_REASON_UNKNOWN);
    124   DVLOG(1) << "Configuring for " << syncer::ModelTypeSetToString(desired_types)
    125            << " with reason " << reason;
    126   if (state_ == STOPPING) {
    127     // You can not set a configuration while stopping.
    128     LOG(ERROR) << "Configuration set while stopping.";
    129     return;
    130   }
    131 
    132   // TODO(zea): consider not performing a full configuration once there's a
    133   // reliable way to determine if the requested set of enabled types matches the
    134   // current set.
    135 
    136   last_requested_types_ = desired_types;
    137   last_configure_reason_ = reason;
    138   // Only proceed if we're in a steady state or retrying.
    139   if (state_ != STOPPED && state_ != CONFIGURED && state_ != RETRYING) {
    140     DVLOG(1) << "Received configure request while configuration in flight. "
    141              << "Postponing until current configuration complete.";
    142     needs_reconfigure_ = true;
    143     return;
    144   }
    145 
    146   Restart(reason);
    147 }
    148 
    149 BackendDataTypeConfigurer::DataTypeConfigStateMap
    150 DataTypeManagerImpl::BuildDataTypeConfigStateMap(
    151     const syncer::ModelTypeSet& types_being_configured) const {
    152   // 1. Get the failed types (due to fatal, crypto, and unready errors).
    153   // 2. Add the difference between last_requested_types_ and the failed types
    154   //    as CONFIGURE_INACTIVE.
    155   // 3. Flip |types_being_configured| to CONFIGURE_ACTIVE.
    156   // 4. Set non-enabled user types as DISABLED.
    157   // 5. Set the fatal, crypto, and unready types to their respective states.
    158   syncer::ModelTypeSet error_types =
    159       failed_data_types_handler_->GetFailedTypes();
    160   syncer::ModelTypeSet fatal_types =
    161       failed_data_types_handler_->GetFatalErrorTypes();
    162   syncer::ModelTypeSet crypto_types =
    163       failed_data_types_handler_->GetCryptoErrorTypes();
    164   syncer::ModelTypeSet unready_types=
    165       failed_data_types_handler_->GetUnreadyErrorTypes();
    166 
    167   // Types with persistence errors are only purged/resynced when they're
    168   // actively being configured.
    169   syncer::ModelTypeSet persistence_types =
    170       failed_data_types_handler_->GetPersistenceErrorTypes();
    171   persistence_types.RetainAll(types_being_configured);
    172 
    173   // Types with unready errors do not count as unready if they've been disabled.
    174   unready_types.RetainAll(last_requested_types_);
    175 
    176   syncer::ModelTypeSet enabled_types = last_requested_types_;
    177   enabled_types.RemoveAll(error_types);
    178   syncer::ModelTypeSet disabled_types =
    179       syncer::Difference(
    180           syncer::Union(syncer::UserTypes(), syncer::ControlTypes()),
    181           enabled_types);
    182   syncer::ModelTypeSet to_configure = syncer::Intersection(
    183       enabled_types, types_being_configured);
    184   DVLOG(1) << "Enabling: " << syncer::ModelTypeSetToString(enabled_types);
    185   DVLOG(1) << "Configuring: " << syncer::ModelTypeSetToString(to_configure);
    186   DVLOG(1) << "Disabling: " << syncer::ModelTypeSetToString(disabled_types);
    187 
    188   BackendDataTypeConfigurer::DataTypeConfigStateMap config_state_map;
    189   BackendDataTypeConfigurer::SetDataTypesState(
    190       BackendDataTypeConfigurer::CONFIGURE_INACTIVE, enabled_types,
    191       &config_state_map);
    192   BackendDataTypeConfigurer::SetDataTypesState(
    193       BackendDataTypeConfigurer::CONFIGURE_ACTIVE, to_configure,
    194       &config_state_map);
    195   BackendDataTypeConfigurer::SetDataTypesState(
    196       BackendDataTypeConfigurer::CONFIGURE_CLEAN, persistence_types,
    197         &config_state_map);
    198   BackendDataTypeConfigurer::SetDataTypesState(
    199       BackendDataTypeConfigurer::DISABLED, disabled_types,
    200       &config_state_map);
    201   BackendDataTypeConfigurer::SetDataTypesState(
    202       BackendDataTypeConfigurer::FATAL, fatal_types,
    203       &config_state_map);
    204   BackendDataTypeConfigurer::SetDataTypesState(
    205       BackendDataTypeConfigurer::CRYPTO, crypto_types,
    206         &config_state_map);
    207   BackendDataTypeConfigurer::SetDataTypesState(
    208       BackendDataTypeConfigurer::UNREADY, unready_types,
    209         &config_state_map);
    210   return config_state_map;
    211 }
    212 
    213 void DataTypeManagerImpl::Restart(syncer::ConfigureReason reason) {
    214   DVLOG(1) << "Restarting...";
    215 
    216   // Check for new or resolved data type crypto errors.
    217   if (encryption_handler_->IsPassphraseRequired()) {
    218     syncer::ModelTypeSet encrypted_types =
    219         encryption_handler_->GetEncryptedDataTypes();
    220     encrypted_types.RetainAll(last_requested_types_);
    221     encrypted_types.RemoveAll(
    222         failed_data_types_handler_->GetCryptoErrorTypes());
    223     FailedDataTypesHandler::TypeErrorMap crypto_errors =
    224         GenerateCryptoErrorsForTypes(encrypted_types);
    225     failed_data_types_handler_->UpdateFailedDataTypes(crypto_errors);
    226   } else {
    227     failed_data_types_handler_->ResetCryptoErrors();
    228   }
    229 
    230   syncer::ModelTypeSet failed_types =
    231       failed_data_types_handler_->GetFailedTypes();
    232   syncer::ModelTypeSet enabled_types =
    233       syncer::Difference(last_requested_types_, failed_types);
    234 
    235   last_restart_time_ = base::Time::Now();
    236   configuration_stats_.clear();
    237 
    238   DCHECK(state_ == STOPPED || state_ == CONFIGURED || state_ == RETRYING);
    239 
    240   // Starting from a "steady state" (stopped or configured) state
    241   // should send a start notification.
    242   if (state_ == STOPPED || state_ == CONFIGURED)
    243     NotifyStart();
    244 
    245   model_association_manager_.Initialize(enabled_types);
    246 
    247   download_types_queue_ = PrioritizeTypes(enabled_types);
    248   association_types_queue_ = std::queue<AssociationTypesInfo>();
    249 
    250   // Tell the backend about the new set of data types we wish to sync.
    251   // The task will be invoked when updates are downloaded.
    252   state_ = DOWNLOAD_PENDING;
    253   configurer_->ConfigureDataTypes(
    254       reason,
    255       BuildDataTypeConfigStateMap(download_types_queue_.front()),
    256       base::Bind(&DataTypeManagerImpl::DownloadReady,
    257                  weak_ptr_factory_.GetWeakPtr(),
    258                  base::Time::Now(),
    259                  download_types_queue_.front(),
    260                  syncer::ModelTypeSet()),
    261       base::Bind(&DataTypeManagerImpl::OnDownloadRetry,
    262                  weak_ptr_factory_.GetWeakPtr()));
    263 }
    264 
    265 syncer::ModelTypeSet DataTypeManagerImpl::GetPriorityTypes() const {
    266   syncer::ModelTypeSet high_priority_types;
    267   high_priority_types.PutAll(syncer::PriorityCoreTypes());
    268   high_priority_types.PutAll(syncer::PriorityUserTypes());
    269   return high_priority_types;
    270 }
    271 
    272 TypeSetPriorityList DataTypeManagerImpl::PrioritizeTypes(
    273     const syncer::ModelTypeSet& types) {
    274   syncer::ModelTypeSet high_priority_types = GetPriorityTypes();
    275   high_priority_types.RetainAll(types);
    276 
    277   syncer::ModelTypeSet low_priority_types =
    278       syncer::Difference(types, high_priority_types);
    279 
    280   TypeSetPriorityList result;
    281   if (!high_priority_types.Empty())
    282     result.push(high_priority_types);
    283   if (!low_priority_types.Empty())
    284     result.push(low_priority_types);
    285 
    286   // Could be empty in case of purging for migration, sync nothing, etc.
    287   // Configure empty set to purge data from backend.
    288   if (result.empty())
    289     result.push(syncer::ModelTypeSet());
    290 
    291   return result;
    292 }
    293 
    294 void DataTypeManagerImpl::ProcessReconfigure() {
    295   DCHECK(needs_reconfigure_);
    296 
    297   // Wait for current download and association to finish.
    298   if (!(download_types_queue_.empty() && association_types_queue_.empty()))
    299     return;
    300 
    301   // An attempt was made to reconfigure while we were already configuring.
    302   // This can be because a passphrase was accepted or the user changed the
    303   // set of desired types. Either way, |last_requested_types_| will contain
    304   // the most recent set of desired types, so we just call configure.
    305   // Note: we do this whether or not GetControllersNeedingStart is true,
    306   // because we may need to stop datatypes.
    307   DVLOG(1) << "Reconfiguring due to previous configure attempt occuring while"
    308            << " busy.";
    309 
    310   // Note: ConfigureImpl is called directly, rather than posted, in order to
    311   // ensure that any purging/unapplying/journaling happens while the set of
    312   // failed types is still up to date. If stack unwinding were to be done
    313   // via PostTask, the failed data types may be reset before the purging was
    314   // performed.
    315   state_ = RETRYING;
    316   needs_reconfigure_ = false;
    317   ConfigureImpl(last_requested_types_, last_configure_reason_);
    318 }
    319 
    320 void DataTypeManagerImpl::OnDownloadRetry() {
    321   DCHECK(state_ == DOWNLOAD_PENDING || state_ == CONFIGURING);
    322   observer_->OnConfigureRetry();
    323 }
    324 
    325 void DataTypeManagerImpl::DownloadReady(
    326     base::Time download_start_time,
    327     syncer::ModelTypeSet types_to_download,
    328     syncer::ModelTypeSet high_priority_types_before,
    329     syncer::ModelTypeSet first_sync_types,
    330     syncer::ModelTypeSet failed_configuration_types) {
    331   DCHECK(state_ == DOWNLOAD_PENDING || state_ == CONFIGURING);
    332 
    333   // Persistence errors are reset after each backend configuration attempt
    334   // during which they would have been purged.
    335   failed_data_types_handler_->ResetPersistenceErrorsFrom(types_to_download);
    336 
    337   // Ignore |failed_configuration_types| if we need to reconfigure
    338   // anyway.
    339   if (needs_reconfigure_) {
    340     download_types_queue_ = TypeSetPriorityList();
    341     ProcessReconfigure();
    342     return;
    343   }
    344 
    345   if (!failed_configuration_types.Empty()) {
    346     if (!unrecoverable_error_method_.is_null())
    347       unrecoverable_error_method_.Run();
    348     std::string error_msg =
    349         "Configuration failed for types " +
    350         syncer::ModelTypeSetToString(failed_configuration_types);
    351     syncer::SyncError error(FROM_HERE,
    352                             syncer::SyncError::UNRECOVERABLE_ERROR,
    353                             error_msg,
    354                             failed_configuration_types.First().Get());
    355     Abort(UNRECOVERABLE_ERROR, error);
    356     return;
    357   }
    358 
    359   state_ = CONFIGURING;
    360 
    361   // Pop and associate download-ready types.
    362   syncer::ModelTypeSet ready_types = types_to_download;
    363   download_types_queue_.pop();
    364   syncer::ModelTypeSet new_types_to_download;
    365   if (!download_types_queue_.empty())
    366     new_types_to_download = download_types_queue_.front();
    367 
    368   AssociationTypesInfo association_info;
    369   association_info.types = ready_types;
    370   association_info.first_sync_types = first_sync_types;
    371   association_info.download_start_time = download_start_time;
    372   association_info.download_ready_time = base::Time::Now();
    373   association_info.high_priority_types_before = high_priority_types_before;
    374   association_types_queue_.push(association_info);
    375   if (association_types_queue_.size() == 1u)
    376     StartNextAssociation();
    377 
    378   // Download types of low priority while configuring types of high priority.
    379   if (!new_types_to_download.Empty()) {
    380     configurer_->ConfigureDataTypes(
    381         last_configure_reason_,
    382         BuildDataTypeConfigStateMap(new_types_to_download),
    383         base::Bind(&DataTypeManagerImpl::DownloadReady,
    384                    weak_ptr_factory_.GetWeakPtr(),
    385                    base::Time::Now(),
    386                    new_types_to_download,
    387                    syncer::Union(ready_types, high_priority_types_before)),
    388         base::Bind(&DataTypeManagerImpl::OnDownloadRetry,
    389                    weak_ptr_factory_.GetWeakPtr()));
    390   }
    391 }
    392 
    393 void DataTypeManagerImpl::StartNextAssociation() {
    394   CHECK(!association_types_queue_.empty());
    395 
    396   association_types_queue_.front().association_request_time =
    397       base::Time::Now();
    398   model_association_manager_.StartAssociationAsync(
    399       association_types_queue_.front().types);
    400 }
    401 
    402 void DataTypeManagerImpl::OnSingleDataTypeWillStop(
    403     syncer::ModelType type) {
    404   configurer_->DeactivateDataType(type);
    405 }
    406 
    407 void DataTypeManagerImpl::OnSingleDataTypeAssociationDone(
    408     syncer::ModelType type,
    409     const syncer::DataTypeAssociationStats& association_stats) {
    410   DCHECK(!association_types_queue_.empty());
    411   DataTypeController::TypeMap::const_iterator c_it = controllers_->find(type);
    412   DCHECK(c_it != controllers_->end());
    413   if (c_it->second->state() == DataTypeController::RUNNING) {
    414     // Tell the backend about the change processor for this type so it can
    415     // begin routing changes to it.
    416     configurer_->ActivateDataType(type, c_it->second->model_safe_group(),
    417                                   c_it->second->GetChangeProcessor());
    418   }
    419 
    420   if (!debug_info_listener_.IsInitialized())
    421     return;
    422 
    423   AssociationTypesInfo& info = association_types_queue_.front();
    424   configuration_stats_.push_back(syncer::DataTypeConfigurationStats());
    425   configuration_stats_.back().model_type = type;
    426   configuration_stats_.back().association_stats = association_stats;
    427   if (info.types.Has(type)) {
    428     // Times in |info| only apply to non-slow types.
    429     configuration_stats_.back().download_wait_time =
    430         info.download_start_time - last_restart_time_;
    431     if (info.first_sync_types.Has(type)) {
    432       configuration_stats_.back().download_time =
    433           info.download_ready_time - info.download_start_time;
    434     }
    435     configuration_stats_.back().association_wait_time_for_high_priority =
    436         info.association_request_time - info.download_ready_time;
    437     configuration_stats_.back().high_priority_types_configured_before =
    438         info.high_priority_types_before;
    439     configuration_stats_.back().same_priority_types_configured_before =
    440         info.configured_types;
    441     info.configured_types.Put(type);
    442   }
    443 }
    444 
    445 void DataTypeManagerImpl::OnModelAssociationDone(
    446     const DataTypeManager::ConfigureResult& result) {
    447   DCHECK(state_ == STOPPING || state_ == CONFIGURING);
    448 
    449   if (state_ == STOPPING)
    450     return;
    451 
    452   // Don't reconfigure due to failed data types if we have an unrecoverable
    453   // error or have already aborted.
    454   if (result.status  == PARTIAL_SUCCESS) {
    455     if (!result.needs_crypto.Empty()) {
    456       needs_reconfigure_ = true;
    457       syncer::ModelTypeSet encrypted_types = result.needs_crypto;
    458       encrypted_types.RemoveAll(
    459           failed_data_types_handler_->GetCryptoErrorTypes());
    460       FailedDataTypesHandler::TypeErrorMap crypto_errors =
    461           GenerateCryptoErrorsForTypes(encrypted_types);
    462       failed_data_types_handler_->UpdateFailedDataTypes(crypto_errors);
    463     }
    464     if (!result.failed_data_types.empty()) {
    465       needs_reconfigure_ = true;
    466       failed_data_types_handler_->UpdateFailedDataTypes(
    467           result.failed_data_types);
    468     }
    469   }
    470 
    471   // Ignore abort/unrecoverable error if we need to reconfigure anyways.
    472   if (needs_reconfigure_) {
    473     association_types_queue_ = std::queue<AssociationTypesInfo>();
    474     ProcessReconfigure();
    475     return;
    476   }
    477 
    478   if (result.status == ABORTED || result.status == UNRECOVERABLE_ERROR) {
    479     Abort(result.status, result.failed_data_types.size() >= 1 ?
    480                          result.failed_data_types.begin()->second :
    481                          syncer::SyncError());
    482     return;
    483   }
    484 
    485   DCHECK(result.status == PARTIAL_SUCCESS || result.status == OK);
    486   DCHECK(result.status != OK ||
    487          (result.needs_crypto.Empty() && result.failed_data_types.empty()));
    488 
    489   // It's possible this is a retry to disable failed types, in which case
    490   // the association would be SUCCESS, but the overall configuration should
    491   // still be PARTIAL_SUCCESS.
    492   syncer::ModelTypeSet failed_data_types =
    493       failed_data_types_handler_->GetFailedTypes();
    494   ConfigureStatus status = result.status;
    495   if (!syncer::Intersection(last_requested_types_,
    496                             failed_data_types).Empty() && result.status == OK) {
    497     status = PARTIAL_SUCCESS;
    498   }
    499 
    500   association_types_queue_.pop();
    501   if (!association_types_queue_.empty()) {
    502     StartNextAssociation();
    503   } else if (download_types_queue_.empty()) {
    504     state_ = CONFIGURED;
    505     ConfigureResult configure_result(status,
    506                                      result.requested_types,
    507                                      failed_data_types_handler_->GetAllErrors(),
    508                                      result.unfinished_data_types,
    509                                      result.needs_crypto);
    510     NotifyDone(configure_result);
    511   }
    512 }
    513 
    514 void DataTypeManagerImpl::Stop() {
    515   if (state_ == STOPPED)
    516     return;
    517 
    518   bool need_to_notify =
    519       state_ == DOWNLOAD_PENDING || state_ == CONFIGURING;
    520   StopImpl();
    521 
    522   if (need_to_notify) {
    523     ConfigureResult result(ABORTED,
    524                            last_requested_types_,
    525                            std::map<syncer::ModelType, syncer::SyncError>(),
    526                            syncer::ModelTypeSet(),
    527                            syncer::ModelTypeSet());
    528     NotifyDone(result);
    529   }
    530 }
    531 
    532 void DataTypeManagerImpl::Abort(ConfigureStatus status,
    533                                 const syncer::SyncError& error) {
    534   DCHECK(state_ == DOWNLOAD_PENDING || state_ == CONFIGURING);
    535 
    536   StopImpl();
    537 
    538   DCHECK_NE(OK, status);
    539   std::map<syncer::ModelType, syncer::SyncError> errors;
    540   if (error.IsSet())
    541     errors[error.model_type()] = error;
    542   ConfigureResult result(status,
    543                          last_requested_types_,
    544                          errors,
    545                          syncer::ModelTypeSet(),
    546                          syncer::ModelTypeSet());
    547   NotifyDone(result);
    548 }
    549 
    550 void DataTypeManagerImpl::StopImpl() {
    551   state_ = STOPPING;
    552 
    553   // Invalidate weak pointer to drop download callbacks.
    554   weak_ptr_factory_.InvalidateWeakPtrs();
    555 
    556   // Stop all data types. This may trigger association callback but the
    557   // callback will do nothing because state is set to STOPPING above.
    558   model_association_manager_.Stop();
    559 
    560   state_ = STOPPED;
    561 }
    562 
    563 void DataTypeManagerImpl::NotifyStart() {
    564   observer_->OnConfigureStart();
    565 }
    566 
    567 void DataTypeManagerImpl::NotifyDone(const ConfigureResult& result) {
    568   AddToConfigureTime();
    569 
    570   DVLOG(1) << "Total time spent configuring: "
    571            << configure_time_delta_.InSecondsF() << "s";
    572   switch (result.status) {
    573     case DataTypeManager::OK:
    574       DVLOG(1) << "NotifyDone called with result: OK";
    575       UMA_HISTOGRAM_LONG_TIMES("Sync.ConfigureTime_Long.OK",
    576                                configure_time_delta_);
    577       if (debug_info_listener_.IsInitialized() &&
    578           !configuration_stats_.empty()) {
    579         debug_info_listener_.Call(
    580             FROM_HERE,
    581             &syncer::DataTypeDebugInfoListener::OnDataTypeConfigureComplete,
    582             configuration_stats_);
    583       }
    584       configuration_stats_.clear();
    585       break;
    586     case DataTypeManager::ABORTED:
    587       DVLOG(1) << "NotifyDone called with result: ABORTED";
    588       UMA_HISTOGRAM_LONG_TIMES("Sync.ConfigureTime_Long.ABORTED",
    589                                configure_time_delta_);
    590       break;
    591     case DataTypeManager::UNRECOVERABLE_ERROR:
    592       DVLOG(1) << "NotifyDone called with result: UNRECOVERABLE_ERROR";
    593       UMA_HISTOGRAM_LONG_TIMES("Sync.ConfigureTime_Long.UNRECOVERABLE_ERROR",
    594                                configure_time_delta_);
    595       break;
    596     case DataTypeManager::PARTIAL_SUCCESS:
    597       DVLOG(1) << "NotifyDone called with result: PARTIAL_SUCCESS";
    598       UMA_HISTOGRAM_LONG_TIMES("Sync.ConfigureTime_Long.PARTIAL_SUCCESS",
    599                                configure_time_delta_);
    600       break;
    601     default:
    602       NOTREACHED();
    603       break;
    604   }
    605   observer_->OnConfigureDone(result);
    606 }
    607 
    608 DataTypeManager::State DataTypeManagerImpl::state() const {
    609   return state_;
    610 }
    611 
    612 void DataTypeManagerImpl::AddToConfigureTime() {
    613   DCHECK(!last_restart_time_.is_null());
    614   configure_time_delta_ += (base::Time::Now() - last_restart_time_);
    615 }
    616 
    617 }  // namespace browser_sync
    618