[Sync] USS: Implement SimpleMetadataChangeList.

sync/internal_api/public/simple_metadata_change_list.cc

Index: sync/internal_api/public/simple_metadata_change_list.cc
diff --git a/sync/internal_api/public/simple_metadata_change_list.cc b/sync/internal_api/public/simple_metadata_change_list.cc
index 999eda69b578b04b29fab330af0d735b683bc66b..f6f82c6ecf72754a4d4a2f0d8997b89795619387 100644
--- a/sync/internal_api/public/simple_metadata_change_list.cc
+++ b/sync/internal_api/public/simple_metadata_change_list.cc
@@ -12,24 +12,43 @@ SimpleMetadataChangeList::~SimpleMetadataChangeList() {}
 
 void SimpleMetadataChangeList::UpdateDataTypeState(
     const sync_pb::DataTypeState& data_type_state) {
-  // TODO(skym): Implementation.
+  state_change_.reset(new DataTypeStateChange());

[pavely, 2016/02/17 00:56:40]

I think you can use (new DataTypeStateChange{UPDATE, data_type_state}) here.

[maxbogue, 2016/02/17 19:31:41]

Done, and below! Thanks.

[skym, 2016/02/18 16:11:10]

..This is uniform initialization syntax right? Currently banned.

http://chromium-cpp.appspot.com/
https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/GF96FshwHLw

[skym, 2016/02/18 18:25:07]

As Max pointed out to me, uniform initialization syntax is applying this style
to classes, but this is a struct. Initializing structs this way has been a thing
for a very long time. So, disregard my earlier concerns.

+  state_change_->type = UPDATE;
+  state_change_->state = data_type_state;
+}
+
+void SimpleMetadataChangeList::ClearDataTypeState() {
+  state_change_.reset(new DataTypeStateChange());
+  state_change_->type = CLEAR;
 }
 
 void SimpleMetadataChangeList::UpdateMetadata(
     const std::string& client_tag,
     const sync_pb::EntityMetadata& metadata) {
-  // TODO(skym): Implementation.
+  MetadataChange change = {UPDATE, metadata};
+  metadata_changes_[client_tag] = change;
 }
 
-void SimpleMetadataChangeList::ClearDataTypeState() {
-  // TODO(skym): Implementation.
+void SimpleMetadataChangeList::ClearMetadata(const std::string& client_tag) {
+  MetadataChange change = {CLEAR, sync_pb::EntityMetadata()};
+  metadata_changes_[client_tag] = change;
 }
 
-void SimpleMetadataChangeList::ClearMetadata(const std::string& client_tag) {
-  // TODO(skym): Implementation.
+const SimpleMetadataChangeList::MetadataChanges&
+SimpleMetadataChangeList::GetMetadataChanges() const {
+  return metadata_changes_;
+}
+
+bool SimpleMetadataChangeList::HasDataTypeStateChange() const {
+  return state_change_.get() != nullptr;

[Gang Wu, 2016/02/12 18:36:08]

When state_change_->type == CLEAR(set at line 22), it consider as has change?

[maxbogue, 2016/02/12 19:12:45]

Yes. If neither UpdateDataTypeState or ClearDataTypeState is called, there is no
change to its state. if Clear* is called, its state should be cleared.

+}
+
+const SimpleMetadataChangeList::DataTypeStateChange&
+SimpleMetadataChangeList::GetDataTypeStateChange() const {
+  return *state_change_.get();
 }
 
-void SimpleMetadataChangeList::TranfserChanges(
+void SimpleMetadataChangeList::TransferChanges(
     ModelTypeStore* store,
     ModelTypeStore::WriteBatch* write_batch) {
   // TODO(skym): Implementation.