[Sync] Make all ModelTypeStore write methods go through WriteBatch.

components/sync/device_info/device_info_sync_bridge_unittest.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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 354 matching lines @@
   EntitySpecifics entity_specifics;
   entity_specifics.mutable_device_info();
   EntityData entity_data;
   entity_data.specifics = entity_specifics;
   EXPECT_EQ(CacheGuidToTag(""), bridge()->GetClientTag(entity_data));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, TestWithLocalData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics = CreateSpecifics(1);
-  store()->WriteData(batch.get(), specifics.cache_guid(),
-                     specifics.SerializeAsString());
+  batch->WriteData(specifics.cache_guid(), specifics.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
   ASSERT_EQ(2u, bridge()->GetAllDeviceInfo().size());
   VerifyEqual(specifics,
               *bridge()->GetDeviceInfo(specifics.cache_guid()).get());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, TestWithLocalMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
-  store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
+  batch->GetMetadataChangeList()->UpdateModelTypeState(state);
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&VerifyResultIsSuccess));
   InitializeAndPump();
   DeviceInfoList devices = bridge()->GetAllDeviceInfo();
   ASSERT_EQ(1u, devices.size());
   EXPECT_TRUE(local_device()->GetLocalDeviceInfo()->Equals(*devices[0]));
   EXPECT_EQ(1u, processor()->put_multimap().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, TestWithLocalDataAndMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics = CreateSpecifics(1);
-  store()->WriteData(batch.get(), specifics.cache_guid(),
-                     specifics.SerializeAsString());
+  batch->WriteData(specifics.cache_guid(), specifics.SerializeAsString());
   ModelTypeState state;
   state.set_encryption_key_name("ekn");
-  store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
+  batch->GetMetadataChangeList()->UpdateModelTypeState(state);
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
   ASSERT_EQ(2u, bridge()->GetAllDeviceInfo().size());
   VerifyEqual(specifics,
               *bridge()->GetDeviceInfo(specifics.cache_guid()).get());
   EXPECT_TRUE(processor()->metadata());
   EXPECT_EQ(state.encryption_key_name(),
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, GetData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1 = CreateSpecifics(1);
   DeviceInfoSpecifics specifics2 = CreateSpecifics(2);
   DeviceInfoSpecifics specifics3 = CreateSpecifics(3);
-  store()->WriteData(batch.get(), specifics1.cache_guid(),
-                     specifics1.SerializeAsString());
-  store()->WriteData(batch.get(), specifics2.cache_guid(),
-                     specifics2.SerializeAsString());
-  store()->WriteData(batch.get(), specifics3.cache_guid(),
-                     specifics3.SerializeAsString());
+  batch->WriteData(specifics1.cache_guid(), specifics1.SerializeAsString());
+  batch->WriteData(specifics2.cache_guid(), specifics2.SerializeAsString());
+  batch->WriteData(specifics3.cache_guid(), specifics3.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
   std::map<std::string, DeviceInfoSpecifics> expected{
       {specifics1.cache_guid(), specifics1},
       {specifics3.cache_guid(), specifics3}};
   bridge()->GetData({specifics1.cache_guid(), specifics3.cache_guid()},
                     base::Bind(&VerifyDataBatch, expected));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, GetDataMissing) {
   InitializeAndPump();
   bridge()->GetData({"does_not_exist"},
                     base::Bind(&VerifyDataBatch,
                                std::map<std::string, DeviceInfoSpecifics>()));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, GetAllData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1 = CreateSpecifics(1);
   DeviceInfoSpecifics specifics2 = CreateSpecifics(2);
   const std::string& guid1 = specifics1.cache_guid();
   const std::string& guid2 = specifics2.cache_guid();
-  store()->WriteData(batch.get(), specifics1.cache_guid(),
-                     specifics1.SerializeAsString());
-  store()->WriteData(batch.get(), specifics2.cache_guid(),
-                     specifics2.SerializeAsString());
+  batch->WriteData(specifics1.cache_guid(), specifics1.SerializeAsString());
+  batch->WriteData(specifics2.cache_guid(), specifics2.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
   std::map<std::string, DeviceInfoSpecifics> expected{{guid1, specifics1},
                                                       {guid2, specifics2}};
   bridge()->GetData({guid1, guid2}, base::Bind(&VerifyDataBatch, expected));
 }
 
@@ skipping 120 matching lines @@
   const DeviceInfoSpecifics unique_local = CreateSpecifics(1);
   DeviceInfoSpecifics conflict_local = CreateSpecifics(2);
   DeviceInfoSpecifics conflict_remote = CreateSpecifics(3);
   const DeviceInfoSpecifics unique_remote = CreateSpecifics(4);
 
   const std::string conflict_guid = "conflict_guid";
   conflict_local.set_cache_guid(conflict_guid);
   conflict_remote.set_cache_guid(conflict_guid);
 
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  store()->WriteData(batch.get(), unique_local.cache_guid(),
-                     unique_local.SerializeAsString());
-  store()->WriteData(batch.get(), conflict_local.cache_guid(),
-                     conflict_local.SerializeAsString());
+  batch->WriteData(unique_local.cache_guid(), unique_local.SerializeAsString());
+  batch->WriteData(conflict_local.cache_guid(),
+                   conflict_local.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
   EntityDataMap remote_input;
   remote_input[conflict_remote.cache_guid()] =
       SpecificsToEntity(conflict_remote);
   remote_input[unique_remote.cache_guid()] = SpecificsToEntity(unique_remote);
@@ skipping 30 matching lines @@
             processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MergeLocalGuid) {
   const DeviceInfo* provider_info = local_device()->GetLocalDeviceInfo();
   auto specifics = base::MakeUnique<DeviceInfoSpecifics>(CreateSpecifics(0));
   specifics->set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
   const std::string guid = provider_info->guid();
 
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  store()->WriteData(batch.get(), guid, specifics->SerializeAsString());
+  batch->WriteData(guid, specifics->SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&VerifyResultIsSuccess));
 
   InitializeAndPump();
 
   EntityDataMap remote_input;
   remote_input[guid] = SpecificsToEntity(*specifics);
 
   const SyncError error = bridge()->MergeSyncData(
       bridge()->CreateMetadataChangeList(), remote_input);
@@ skipping 85 matching lines @@
 
   // Reloading from storage shouldn't contain remote data.
   RestartBridge();
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(4, change_count());
 }
 
 }  // namespace
 
 }  // namespace syncer