Fix use-after-free in HDDDTC shutdown

components/sync_driver/data_type_manager_impl.cc

Index: components/sync_driver/data_type_manager_impl.cc
diff --git a/components/sync_driver/data_type_manager_impl.cc b/components/sync_driver/data_type_manager_impl.cc
index 856722e898f5b9123f5e8d5d27163aa30147b629..092f3625fdf2e0d979f9e4eebbf783a10360bdeb 100644
--- a/components/sync_driver/data_type_manager_impl.cc
+++ b/components/sync_driver/data_type_manager_impl.cc
@@ -51,8 +51,7 @@ DataTypeManagerImpl::DataTypeManagerImpl(
     const DataTypeController::TypeMap* controllers,
     const DataTypeEncryptionHandler* encryption_handler,
     BackendDataTypeConfigurer* configurer,
-    DataTypeManagerObserver* observer,
-    DataTypeStatusTable* data_type_status_table)
+    DataTypeManagerObserver* observer)
     : configurer_(configurer),
       controllers_(controllers),
       state_(DataTypeManager::STOPPED),
@@ -61,11 +60,9 @@ DataTypeManagerImpl::DataTypeManagerImpl(
       debug_info_listener_(debug_info_listener),
       model_association_manager_(controllers, this),
       observer_(observer),
-      data_type_status_table_(data_type_status_table),
       encryption_handler_(encryption_handler),
       unrecoverable_error_method_(unrecoverable_error_method),
       weak_ptr_factory_(this) {
-  DCHECK(data_type_status_table_);
   DCHECK(configurer_);
   DCHECK(observer_);
 }
@@ -89,7 +86,7 @@ void DataTypeManagerImpl::Configure(syncer::ModelTypeSet desired_types,
         iter != controllers_->end()) {
       if (iter != controllers_->end()) {
         if (!iter->second->ReadyForStart() &&
-            !data_type_status_table_->GetUnreadyErrorTypes().Has(
+            !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
@@ -100,9 +97,9 @@ void DataTypeManagerImpl::Configure(syncer::ModelTypeSet desired_types,
                                   type.Get());
           std::map<syncer::ModelType, syncer::SyncError> errors;
           errors[type.Get()] = error;
-          data_type_status_table_->UpdateFailedDataTypes(errors);
+          data_type_status_table_.UpdateFailedDataTypes(errors);
         } else if (iter->second->ReadyForStart()) {
-          data_type_status_table_->ResetUnreadyErrorFor(type.Get());
+          data_type_status_table_.ResetUnreadyErrorFor(type.Get());
         }
       }
       filtered_desired_types.Put(type.Get());
@@ -115,8 +112,8 @@ void DataTypeManagerImpl::ReenableType(syncer::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)) {
+  if (!data_type_status_table_.ResetDataTypeErrorFor(type) &&
+      !data_type_status_table_.ResetUnreadyErrorFor(type)) {
     return;
   }
 
@@ -130,6 +127,11 @@ void DataTypeManagerImpl::ReenableType(syncer::ModelType type) {
   ProcessReconfigure();
 }
 
+void DataTypeManagerImpl::ResetDataTypeErrors() {
+  DCHECK_EQ(state_, CONFIGURED);
+  data_type_status_table_.Reset();
+}
+
 void DataTypeManagerImpl::PurgeForMigration(
     syncer::ModelTypeSet undesired_types,
     syncer::ConfigureReason reason) {
@@ -177,18 +179,18 @@ DataTypeManagerImpl::BuildDataTypeConfigStateMap(
   // 4. Set non-enabled user types as DISABLED.
   // 5. Set the fatal, crypto, and unready types to their respective states.
   syncer::ModelTypeSet error_types =
-      data_type_status_table_->GetFailedTypes();
+      data_type_status_table_.GetFailedTypes();
   syncer::ModelTypeSet fatal_types =
-      data_type_status_table_->GetFatalErrorTypes();
+      data_type_status_table_.GetFatalErrorTypes();
   syncer::ModelTypeSet crypto_types =
-      data_type_status_table_->GetCryptoErrorTypes();
+      data_type_status_table_.GetCryptoErrorTypes();
   syncer::ModelTypeSet unready_types=
-      data_type_status_table_->GetUnreadyErrorTypes();
+      data_type_status_table_.GetUnreadyErrorTypes();
 
   // Types with persistence errors are only purged/resynced when they're
   // actively being configured.
   syncer::ModelTypeSet persistence_types =
-      data_type_status_table_->GetPersistenceErrorTypes();
+      data_type_status_table_.GetPersistenceErrorTypes();
   persistence_types.RetainAll(types_being_configured);
 
   // Types with unready errors do not count as unready if they've been disabled.
@@ -240,16 +242,16 @@ void DataTypeManagerImpl::Restart(syncer::ConfigureReason reason) {
         encryption_handler_->GetEncryptedDataTypes();
     encrypted_types.RetainAll(last_requested_types_);
     encrypted_types.RemoveAll(
-        data_type_status_table_->GetCryptoErrorTypes());
+        data_type_status_table_.GetCryptoErrorTypes());
     DataTypeStatusTable::TypeErrorMap crypto_errors =
         GenerateCryptoErrorsForTypes(encrypted_types);
-    data_type_status_table_->UpdateFailedDataTypes(crypto_errors);
+    data_type_status_table_.UpdateFailedDataTypes(crypto_errors);
   } else {
-    data_type_status_table_->ResetCryptoErrors();
+    data_type_status_table_.ResetCryptoErrors();
   }
 
   syncer::ModelTypeSet failed_types =
-      data_type_status_table_->GetFailedTypes();
+      data_type_status_table_.GetFailedTypes();
   syncer::ModelTypeSet enabled_types =
       syncer::Difference(last_requested_types_, failed_types);
 
@@ -353,7 +355,7 @@ void DataTypeManagerImpl::DownloadReady(
 
   // Persistence errors are reset after each backend configuration attempt
   // during which they would have been purged.
-  data_type_status_table_->ResetPersistenceErrorsFrom(types_to_download);
+  data_type_status_table_.ResetPersistenceErrorsFrom(types_to_download);
 
   // Ignore |failed_configuration_types| if we need to reconfigure
   // anyway.
@@ -376,7 +378,7 @@ void DataTypeManagerImpl::DownloadReady(
           iter.Get());
       errors[iter.Get()] = error;
     }
-    data_type_status_table_->UpdateFailedDataTypes(errors);
+    data_type_status_table_.UpdateFailedDataTypes(errors);
     Abort(UNRECOVERABLE_ERROR);
     return;
   }
@@ -431,7 +433,7 @@ void DataTypeManagerImpl::OnSingleDataTypeWillStop(
   if (error.IsSet()) {
     DataTypeStatusTable::TypeErrorMap failed_types;
     failed_types[type] = error;
-    data_type_status_table_->UpdateFailedDataTypes(
+    data_type_status_table_.UpdateFailedDataTypes(
             failed_types);
 
     // Unrecoverable errors will shut down the entire backend, so no need to
@@ -557,9 +559,12 @@ void DataTypeManagerImpl::NotifyStart() {
   observer_->OnConfigureStart();
 }
 
-void DataTypeManagerImpl::NotifyDone(const ConfigureResult& result) {
+void DataTypeManagerImpl::NotifyDone(const ConfigureResult& raw_result) {
   AddToConfigureTime();
 
+  ConfigureResult result = raw_result;
+  result.data_type_status_table = data_type_status_table_;
+
   DVLOG(1) << "Total time spent configuring: "
            << configure_time_delta_.InSecondsF() << "s";
   switch (result.status) {