[Sync] Convert NonBlockingDataTypeController to be single-thread.

components/sync/device_info/device_info_service.cc

 // Copyright 2015 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/device_info/device_info_service.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 34 matching lines @@
 using Record = ModelTypeStore::Record;
 using RecordList = ModelTypeStore::RecordList;
 using Result = ModelTypeStore::Result;
 using WriteBatch = ModelTypeStore::WriteBatch;
 
 DeviceInfoService::DeviceInfoService(
     sync_driver::LocalDeviceInfoProvider* local_device_info_provider,
     const StoreFactoryFunction& callback,
     const ChangeProcessorFactory& change_processor_factory)
     : ModelTypeService(change_processor_factory, syncer::DEVICE_INFO),
-      local_device_info_provider_(local_device_info_provider),
-      weak_factory_(this) {
+      local_device_info_provider_(local_device_info_provider) {
   DCHECK(local_device_info_provider);
 
   // This is not threadsafe, but presuably the provider initializes on the same
   // thread as us so we're okay.
   if (local_device_info_provider->GetLocalDeviceInfo()) {
     OnProviderInitialized();
   } else {
     subscription_ =
         local_device_info_provider->RegisterOnInitializedCallback(base::Bind(
             &DeviceInfoService::OnProviderInitialized, base::Unretained(this)));
   }
 
-  callback.Run(base::Bind(&DeviceInfoService::OnStoreCreated,
-                          weak_factory_.GetWeakPtr()));
+  callback.Run(
+      base::Bind(&DeviceInfoService::OnStoreCreated, base::AsWeakPtr(this)));
 }
 
 DeviceInfoService::~DeviceInfoService() {}
 
 std::unique_ptr<MetadataChangeList>
 DeviceInfoService::CreateMetadataChangeList() {
   return base::WrapUnique(new SimpleMetadataChangeList());
 }
 
 SyncError DeviceInfoService::MergeSyncData(
@@ skipping 235 matching lines @@
 
 void DeviceInfoService::OnProviderInitialized() {
   has_provider_initialized_ = true;
   LoadMetadataIfReady();
 }
 
 void DeviceInfoService::OnStoreCreated(Result result,
                                        std::unique_ptr<ModelTypeStore> store) {
   if (result == Result::SUCCESS) {
     std::swap(store_, store);
-    store_->ReadAllData(base::Bind(&DeviceInfoService::OnReadAllData,
-                                   weak_factory_.GetWeakPtr()));
+    store_->ReadAllData(
+        base::Bind(&DeviceInfoService::OnReadAllData, base::AsWeakPtr(this)));
   } else {
     ReportStartupErrorToSync("ModelTypeStore creation failed.");
     // TODO(skym, crbug.com/582460): Handle unrecoverable initialization
     // failure.
   }
 }
 
 void DeviceInfoService::OnReadAllData(Result result,
                                       std::unique_ptr<RecordList> record_list) {
   if (result != Result::SUCCESS) {
@@ skipping 15 matching lines @@
     }
   }
 
   has_data_loaded_ = true;
   LoadMetadataIfReady();
 }
 
 void DeviceInfoService::LoadMetadataIfReady() {
   if (has_data_loaded_ && has_provider_initialized_) {
     store_->ReadAllMetadata(base::Bind(&DeviceInfoService::OnReadAllMetadata,
-                                       weak_factory_.GetWeakPtr()));
+                                       base::AsWeakPtr(this)));
   }
 }
 
 void DeviceInfoService::OnReadAllMetadata(
     Result result,
     std::unique_ptr<RecordList> metadata_records,
     const std::string& global_metadata) {
   DCHECK(!has_metadata_loaded_);
 
   if (result != Result::SUCCESS) {
@@ skipping 118 matching lines @@
 }
 
 void DeviceInfoService::CommitAndNotify(
     std::unique_ptr<WriteBatch> batch,
     std::unique_ptr<MetadataChangeList> metadata_change_list,
     bool should_notify) {
   static_cast<SimpleMetadataChangeList*>(metadata_change_list.get())
       ->TransferChanges(store_.get(), batch.get());
   store_->CommitWriteBatch(
       std::move(batch),
-      base::Bind(&DeviceInfoService::OnCommit, weak_factory_.GetWeakPtr()));
+      base::Bind(&DeviceInfoService::OnCommit, base::AsWeakPtr(this)));
   if (should_notify) {
     NotifyObservers();
   }
 }
 
 int DeviceInfoService::CountActiveDevices(const Time now) const {
   return std::count_if(all_data_.begin(), all_data_.end(),
                        [now](ClientIdToSpecifics::const_reference pair) {
                          return DeviceInfoUtil::IsActive(
                              GetLastUpdateTime(*pair.second), now);
@@ skipping 16 matching lines @@
 Time DeviceInfoService::GetLastUpdateTime(
     const DeviceInfoSpecifics& specifics) {
   if (specifics.has_last_updated_timestamp()) {
     return syncer::ProtoTimeToTime(specifics.last_updated_timestamp());
   } else {
     return Time();
   }
 }
 
 }  // namespace sync_driver_v2