[Sync] Rename DataTypeState to ModelTypeState.

components/sync/device_info/device_info_service_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_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "components/sync/api/data_batch.h"
 #include "components/sync/api/data_type_error_handler_mock.h"
 #include "components/sync/api/entity_data.h"
 #include "components/sync/api/fake_model_type_change_processor.h"
 #include "components/sync/api/metadata_batch.h"
 #include "components/sync/base/time.h"
 #include "components/sync/core/test/model_type_store_test_util.h"
 #include "components/sync/device_info/local_device_info_provider_mock.h"
-#include "components/sync/protocol/data_type_state.pb.h"
+#include "components/sync/protocol/model_type_state.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 using base::Time;
 using base::TimeDelta;
-using sync_pb::DataTypeState;
 using sync_pb::DeviceInfoSpecifics;
 using sync_pb::EntitySpecifics;
+using sync_pb::ModelTypeState;
 
 using DeviceInfoList = std::vector<std::unique_ptr<DeviceInfo>>;
 using StorageKeyList = ModelTypeService::StorageKeyList;
 using RecordList = ModelTypeStore::RecordList;
 using Result = ModelTypeStore::Result;
 using StartCallback = ModelTypeChangeProcessor::StartCallback;
 using WriteBatch = ModelTypeStore::WriteBatch;
 
 namespace {
 
@@ skipping 360 matching lines @@
 
   DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(1u, all_device_info.size());
   AssertEqual(specifics, *all_device_info[0]);
   AssertEqual(specifics,
               *service()->GetDeviceInfo(specifics.cache_guid()).get());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
-  DataTypeState state;
+  ModelTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
   InitializeAndPump();
   DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(1u, all_device_info.size());
   ASSERT_TRUE(
       local_device()->GetLocalDeviceInfo()->Equals(*all_device_info[0]));
   EXPECT_EQ(1u, processor()->put_map().size());
 }
 
 TEST_F(DeviceInfoServiceTest, TestWithLocalDataAndMetadata) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics(GenerateTestSpecifics());
   store()->WriteData(batch.get(), specifics.cache_guid(),
                      specifics.SerializeAsString());
-  DataTypeState state;
+  ModelTypeState state;
   state.set_encryption_key_name("ekn");
   store()->WriteGlobalMetadata(batch.get(), state.SerializeAsString());
   store()->CommitWriteBatch(std::move(batch),
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPump();
 
   DeviceInfoList all_device_info(service()->GetAllDeviceInfo());
   ASSERT_EQ(2u, all_device_info.size());
   AssertEqual(specifics,
               *service()->GetDeviceInfo(specifics.cache_guid()).get());
   ASSERT_TRUE(processor()->metadata());
   ASSERT_EQ(state.encryption_key_name(),
-            processor()->metadata()->GetDataTypeState().encryption_key_name());
+            processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, GetData) {
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
   DeviceInfoSpecifics specifics1(GenerateTestSpecifics());
   DeviceInfoSpecifics specifics2(GenerateTestSpecifics());
   DeviceInfoSpecifics specifics3(GenerateTestSpecifics());
   store()->WriteData(batch.get(), specifics1.cache_guid(),
                      specifics1.SerializeAsString());
   store()->WriteData(batch.get(), specifics2.cache_guid(),
@@ skipping 82 matching lines @@
   EXPECT_FALSE(service()->GetDeviceInfo(specifics.cache_guid()));
   EXPECT_EQ(2, change_count());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesStore) {
   InitializeAndPump();
 
   DeviceInfoSpecifics specifics = GenerateTestSpecifics();
   EntityChangeList data_changes;
   PushBackEntityChangeAdd(specifics, &data_changes);
-  DataTypeState state;
+  ModelTypeState state;
   state.set_encryption_key_name("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes(
       service()->CreateMetadataChangeList());
-  metadata_changes->UpdateDataTypeState(state);
+  metadata_changes->UpdateModelTypeState(state);
 
   const SyncError error =
       service()->ApplySyncChanges(std::move(metadata_changes), data_changes);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 
   RestartService();
 
   std::unique_ptr<DeviceInfo> info =
       service()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   AssertEqual(specifics, *info.get());
 
   EXPECT_TRUE(processor()->metadata());
   EXPECT_EQ(state.encryption_key_name(),
-            processor()->metadata()->GetDataTypeState().encryption_key_name());
+            processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, ApplySyncChangesWithLocalGuid) {
   InitializeAndPumpAndStart();
 
   // The point of this test is to try to apply remote changes that have the same
   // cache guid as the local device. The service should ignore these changes
   // since only it should be performing writes on its data.
   DeviceInfoSpecifics specifics =
       GenerateTestSpecifics(local_device()->GetLocalDeviceInfo()->guid());
@@ skipping 70 matching lines @@
                             base::Bind(&AssertResultIsSuccess));
 
   InitializeAndPumpAndStart();
   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);
 
-  DataTypeState state;
+  ModelTypeState state;
   state.set_encryption_key_name("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes(
       service()->CreateMetadataChangeList());
-  metadata_changes->UpdateDataTypeState(state);
+  metadata_changes->UpdateModelTypeState(state);
 
   const SyncError error =
       service()->MergeSyncData(std::move(metadata_changes), remote_input);
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, change_count());
 
   // The remote should beat the local in conflict.
   EXPECT_EQ(4u, service()->GetAllDeviceInfo().size());
   AssertEqual(unique_local,
               *service()->GetDeviceInfo(unique_local.cache_guid()).get());
   AssertEqual(unique_remote,
               *service()->GetDeviceInfo(unique_remote.cache_guid()).get());
   AssertEqual(conflict_remote, *service()->GetDeviceInfo(conflict_guid).get());
 
   // Service should have told the processor about the existance of unique_local.
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_EQ(2u, processor()->put_map().size());
   const auto& it = processor()->put_map().find(unique_local.cache_guid());
   ASSERT_NE(processor()->put_map().end(), it);
   AssertEqual(unique_local, it->second->specifics.device_info());
 
   RestartService();
   ASSERT_EQ(state.encryption_key_name(),
-            processor()->metadata()->GetDataTypeState().encryption_key_name());
+            processor()->metadata()->GetModelTypeState().encryption_key_name());
 }
 
 TEST_F(DeviceInfoServiceTest, MergeLocalGuid) {
   const DeviceInfo* local_device_info = local_device()->GetLocalDeviceInfo();
   std::unique_ptr<DeviceInfoSpecifics> specifics(
       CopyToSpecifics(*local_device_info));
   specifics->set_last_updated_timestamp(TimeToProtoTime(Time::Now()));
   const std::string guid = local_device_info->guid();
 
   std::unique_ptr<WriteBatch> batch = store()->CreateWriteBatch();
@@ skipping 49 matching lines @@
   specifics.set_cache_guid("non-local");
   PushBackEntityChangeAdd(specifics, &change_list);
   service()->ApplySyncChanges(service()->CreateMetadataChangeList(),
                               change_list);
   EXPECT_EQ(1, service()->CountActiveDevices());
 }
 
 }  // namespace
 
 }  // namespace syncer