[Sync] Update local device info when re-enabled.

components/sync/device_info/device_info_sync_bridge.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_sync_bridge.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 98 matching lines @@
 DeviceInfoSyncBridge::~DeviceInfoSyncBridge() {}
 
 std::unique_ptr<MetadataChangeList>
 DeviceInfoSyncBridge::CreateMetadataChangeList() {
   return WriteBatch::CreateMetadataChangeList();
 }
 
 SyncError DeviceInfoSyncBridge::MergeSyncData(
     std::unique_ptr<MetadataChangeList> metadata_change_list,
     EntityDataMap entity_data_map) {
-  DCHECK(has_provider_initialized_);
   DCHECK(change_processor()->IsTrackingMetadata());
   const DeviceInfo* local_info =
       local_device_info_provider_->GetLocalDeviceInfo();
   // If our dependency was yanked out from beneath us, we cannot correctly
   // handle this request, and all our data will be deleted soon.
   if (local_info == nullptr) {
     return SyncError();
   }
 
   // Local data should typically be near empty, with the only possible value
@@ skipping 33 matching lines @@
   }
 
   batch->TransferMetadataChanges(std::move(metadata_change_list));
   CommitAndNotify(std::move(batch), has_changes);
   return SyncError();
 }
 
 SyncError DeviceInfoSyncBridge::ApplySyncChanges(
     std::unique_ptr<MetadataChangeList> metadata_change_list,
     EntityChangeList entity_changes) {
-  DCHECK(has_provider_initialized_);
   const DeviceInfo* local_info =
       local_device_info_provider_->GetLocalDeviceInfo();
   // If our dependency was yanked out from beneath us, we cannot correctly
   // handle this request, and all our data will be deleted soon.
   if (local_info == nullptr) {
     return SyncError();
   }
 
   std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
   bool has_changes = false;
@@ skipping 132 matching lines @@
   if (iter != all_data_.end()) {
     batch->DeleteData(guid);
     all_data_.erase(iter);
     return true;
   } else {
     return false;
   }
 }
 
 void DeviceInfoSyncBridge::OnProviderInitialized() {
+  DCHECK(local_device_info_provider_->GetLocalDeviceInfo() != nullptr);
   // Now that the provider has initialized, remove the subscription. The bridge
   // should only need to give the processor metadata upon initialization. If
   // sync is disabled and enabled, our provider will try to retrigger this
   // event, but we do not want to send any more metadata to the processor.
   // TODO(skym, crbug.com/672600): Handle re-initialization and start the pulse
   // timer.
   subscription_.reset();
-
-  has_provider_initialized_ = true;
   LoadMetadataIfReady();
 }
 
 void DeviceInfoSyncBridge::OnStoreCreated(
     Result result,
     std::unique_ptr<ModelTypeStore> store) {
   if (result == Result::SUCCESS) {
     std::swap(store_, store);
     store_->ReadAllData(base::Bind(&DeviceInfoSyncBridge::OnReadAllData,
                                    base::AsWeakPtr(this)));
@@ skipping 18 matching lines @@
     } else {
       ReportStartupErrorToSync("Failed to deserialize specifics.");
     }
   }
 
   has_data_loaded_ = true;
   LoadMetadataIfReady();
 }
 
 void DeviceInfoSyncBridge::LoadMetadataIfReady() {
-  if (has_data_loaded_ && has_provider_initialized_) {
+  if (has_data_loaded_ &&
+      local_device_info_provider_->GetLocalDeviceInfo() != nullptr) {
     store_->ReadAllMetadata(base::Bind(&DeviceInfoSyncBridge::OnReadAllMetadata,
                                        base::AsWeakPtr(this)));
   }
 }
 
 void DeviceInfoSyncBridge::OnReadAllMetadata(
     SyncError error,
     std::unique_ptr<MetadataBatch> metadata_batch) {
   change_processor()->OnMetadataLoaded(error, std::move(metadata_batch));
   ReconcileLocalAndStored();
 }
 
 void DeviceInfoSyncBridge::OnCommit(Result result) {
   if (result != Result::SUCCESS) {
     change_processor()->CreateAndUploadError(FROM_HERE,
                                              "Failed a write to store.");
   }
 }
 
 void DeviceInfoSyncBridge::ReconcileLocalAndStored() {
-  // On initial syncing we will have a change processor here, but it will not be
-  // tracking changes. We need to persist a copy of our local device info to
-  // disk, but the Put call to the processor will be ignored. That should be
-  // fine however, as the discrepancy will be picked up later in merge. We don't
-  // bother trying to track this case and act intelligently because simply not
-  // much of a benefit in doing so.
-  DCHECK(has_provider_initialized_);
-
   const DeviceInfo* current_info =
       local_device_info_provider_->GetLocalDeviceInfo();
   // Must ensure |pulse_timer_| is started even if sync is in the process of
   // being disabled. TODO(skym, crbug.com/672600): Remove this timer Start(), as
   // it should be started when the provider re-initializes instead.
   if (current_info == nullptr) {
     pulse_timer_.Start(FROM_HERE, DeviceInfoUtil::kPulseInterval,
                        base::Bind(&DeviceInfoSyncBridge::SendLocalData,
                                   base::Unretained(this)));
     return;
   }
   auto iter = all_data_.find(current_info->guid());
 
   // Convert to DeviceInfo for Equals function.
   if (iter != all_data_.end() &&
       current_info->Equals(*SpecificsToModel(*iter->second))) {
     const TimeDelta pulse_delay(DeviceInfoUtil::CalculatePulseDelay(
         GetLastUpdateTime(*iter->second), Time::Now()));
     if (!pulse_delay.is_zero()) {
       pulse_timer_.Start(FROM_HERE, pulse_delay,
                          base::Bind(&DeviceInfoSyncBridge::SendLocalData,
                                     base::Unretained(this)));
       return;
     }
   }
   SendLocalData();
 }
 
 void DeviceInfoSyncBridge::SendLocalData() {
-  DCHECK(has_provider_initialized_);
-
   // It is possible that the provider no longer has data for us, such as when
   // the user signs out. No-op this pulse, but keep the timer going in case sync
   // is enabled later.
   if (local_device_info_provider_->GetLocalDeviceInfo() != nullptr) {
     std::unique_ptr<DeviceInfoSpecifics> specifics =
         ModelToSpecifics(*local_device_info_provider_->GetLocalDeviceInfo(),
                          TimeToProtoTime(Time::Now()));
     std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
 
     if (change_processor()->IsTrackingMetadata()) {
@@ skipping 30 matching lines @@
 }
 
 void DeviceInfoSyncBridge::ReportStartupErrorToSync(const std::string& msg) {
   // TODO(skym): Shouldn't need to log this here, reporting should always log.
   LOG(WARNING) << msg;
   change_processor()->OnMetadataLoaded(
       change_processor()->CreateAndUploadError(FROM_HERE, msg), nullptr);
 }
 
 }  // namespace syncer