[Sync] Improve MetadataChangeList usage for types using ModelTypeStore.

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 92 matching lines @@
   }
 
   callback.Run(
       base::Bind(&DeviceInfoSyncBridge::OnStoreCreated, base::AsWeakPtr(this)));
 }
 
 DeviceInfoSyncBridge::~DeviceInfoSyncBridge() {}
 
 std::unique_ptr<MetadataChangeList>
 DeviceInfoSyncBridge::CreateMetadataChangeList() {
-  return base::MakeUnique<SimpleMetadataChangeList>();
+  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());
 
   // Local data should typically be near empty, with the only possible value
   // corresponding to this device. This is because on signout all device info
@@ skipping 31 matching lines @@
       StoreSpecifics(base::MakeUnique<DeviceInfoSpecifics>(specifics),
                      batch.get());
     }
   }
 
   for (const std::string& guid : local_guids_to_put) {
     change_processor()->Put(guid, CopyToEntityData(*all_data_[guid]),
                             metadata_change_list.get());
   }
 
-  CommitAndNotify(std::move(batch), std::move(metadata_change_list),
-                  has_changes);
+  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_);
 
   std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
   bool has_changes = false;
@@ skipping 10 matching lines @@
     } else {
       const DeviceInfoSpecifics& specifics =
           change.data().specifics.device_info();
       DCHECK(guid == specifics.cache_guid());
       StoreSpecifics(base::MakeUnique<DeviceInfoSpecifics>(specifics),
                      batch.get());
       has_changes = true;
     }
   }
 
-  CommitAndNotify(std::move(batch), std::move(metadata_change_list),
-                  has_changes);
+  batch->TransferMetadataChanges(std::move(metadata_change_list));
+  CommitAndNotify(std::move(batch), has_changes);
   return SyncError();
 }
 
 void DeviceInfoSyncBridge::GetData(StorageKeyList storage_keys,
                                    DataCallback callback) {
   auto batch = base::MakeUnique<MutableDataBatch>();
   for (const auto& key : storage_keys) {
     const auto& iter = all_data_.find(key);
     if (iter != all_data_.end()) {
       DCHECK_EQ(key, iter->second->cache_guid());
@@ skipping 227 matching lines @@
 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<MetadataChangeList> metadata_change_list =
-        CreateMetadataChangeList();
+    std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
+
     if (change_processor()->IsTrackingMetadata()) {
       change_processor()->Put(specifics->cache_guid(),
                               CopyToEntityData(*specifics),
-                              metadata_change_list.get());
+                              batch->GetMetadataChangeList());
     }
 
-    std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
     StoreSpecifics(std::move(specifics), batch.get());
-    CommitAndNotify(std::move(batch), std::move(metadata_change_list), true);
+    CommitAndNotify(std::move(batch), true);
   }
 
   pulse_timer_.Start(
       FROM_HERE, DeviceInfoUtil::kPulseInterval,
       base::Bind(&DeviceInfoSyncBridge::SendLocalData, base::Unretained(this)));
 }
 
-void DeviceInfoSyncBridge::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());
+void DeviceInfoSyncBridge::CommitAndNotify(std::unique_ptr<WriteBatch> batch,
+                                           bool should_notify) {
   store_->CommitWriteBatch(
       std::move(batch),
       base::Bind(&DeviceInfoSyncBridge::OnCommit, base::AsWeakPtr(this)));
   if (should_notify) {
     NotifyObservers();
   }
 }
 
 int DeviceInfoSyncBridge::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);
                        });
 }
 
 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