[Sync] Adding storage key concept for ModelTypeServices.

components/sync_driver/device_info_service.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_driver/device_info_service.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 84 matching lines @@
   }
 
   bool has_changes = false;
   const DeviceInfo* local_info =
       local_device_info_provider_->GetLocalDeviceInfo();
   std::string local_guid = local_info->guid();
   std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
   for (const auto& kv : entity_data_map) {
     const DeviceInfoSpecifics& specifics =
         kv.second.value().specifics.device_info();
-    DCHECK_EQ(kv.first, DeviceInfoUtil::SpecificsToTag(specifics));
+    DCHECK_EQ(kv.first, specifics.cache_guid());
     if (specifics.cache_guid() == local_guid) {
       // Don't Put local data if it's the same as the remote copy.
       if (local_info->Equals(*CopyToModel(specifics))) {
         local_guids_to_put.erase(local_guid);
       } else {
         // This device is valid right now and this entry is about to be
         // committed, use this as an opportunity to refresh the timestamp.
         all_data_[local_guid]->set_last_updated_timestamp(
             syncer::TimeToProtoTime(Time::Now()));
       }
     } else {
       // Remote data wins conflicts.
       local_guids_to_put.erase(specifics.cache_guid());
       has_changes = true;
       StoreSpecifics(base::WrapUnique(new DeviceInfoSpecifics(specifics)),
                      batch.get());
     }
   }
 
   for (const std::string& guid : local_guids_to_put) {
-    change_processor()->Put(DeviceInfoUtil::SpecificsToTag(*all_data_[guid]),
-                            CopyToEntityData(*all_data_[guid]),
+    change_processor()->Put(guid, CopyToEntityData(*all_data_[guid]),
                             metadata_change_list.get());
   }
 
   CommitAndNotify(std::move(batch), std::move(metadata_change_list),
                   has_changes);
   return SyncError();
 }
 
 SyncError DeviceInfoService::ApplySyncChanges(
     std::unique_ptr<MetadataChangeList> metadata_change_list,
     EntityChangeList entity_changes) {
   DCHECK(has_provider_initialized_);
   DCHECK(has_metadata_loaded_);
 
   std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
   bool has_changes = false;
   for (EntityChange& change : entity_changes) {
-    const std::string guid =
-        DeviceInfoUtil::TagToCacheGuid(change.client_tag());
+    const std::string guid = change.storage_key();
     // Each device is the authoritative source for itself, ignore any remote
     // changes that have our local cache guid.
     if (guid == local_device_info_provider_->GetLocalDeviceInfo()->guid()) {
       continue;
     }
 
     if (change.type() == EntityChange::ACTION_DELETE) {
       has_changes |= DeleteSpecifics(guid, batch.get());
     } else {
       const DeviceInfoSpecifics& specifics =
           change.data().specifics.device_info();
       DCHECK(guid == specifics.cache_guid());
       StoreSpecifics(base::WrapUnique(new DeviceInfoSpecifics(specifics)),
                      batch.get());
       has_changes = true;
     }
   }
 
   CommitAndNotify(std::move(batch), std::move(metadata_change_list),
                   has_changes);
   return SyncError();
 }
 
-void DeviceInfoService::GetData(ClientTagList client_tags,
+void DeviceInfoService::GetData(StorageKeyList storage_keys,
                                 DataCallback callback) {
   DCHECK(has_metadata_loaded_);
 
   std::unique_ptr<DataBatchImpl> batch(new DataBatchImpl());
-  for (const auto& tag : client_tags) {
-    const auto& iter = all_data_.find(DeviceInfoUtil::TagToCacheGuid(tag));
+  for (const auto& key : storage_keys) {
+    const auto& iter = all_data_.find(key);
     if (iter != all_data_.end()) {
-      DCHECK_EQ(tag, DeviceInfoUtil::SpecificsToTag(*iter->second));
-      batch->Put(tag, CopyToEntityData(*iter->second));
+      DCHECK_EQ(key, iter->second->cache_guid());
+      batch->Put(key, CopyToEntityData(*iter->second));
     }
   }
 
   callback.Run(SyncError(), std::move(batch));
 }
 
 void DeviceInfoService::GetAllData(DataCallback callback) {
   DCHECK(has_metadata_loaded_);
 
   std::unique_ptr<DataBatchImpl> batch(new DataBatchImpl());
   for (const auto& kv : all_data_) {
-    batch->Put(DeviceInfoUtil::SpecificsToTag(*kv.second),
-               CopyToEntityData(*kv.second));
+    batch->Put(kv.first, CopyToEntityData(*kv.second));
   }
 
   callback.Run(SyncError(), std::move(batch));
 }
 
 std::string DeviceInfoService::GetClientTag(const EntityData& entity_data) {
   DCHECK(entity_data.specifics.has_device_info());
   return DeviceInfoUtil::SpecificsToTag(entity_data.specifics.device_info());
 }
 
+std::string DeviceInfoService::GetStorageKey(
+    const syncer_v2::EntityData& entity_data) {
+  DCHECK(entity_data.specifics.has_device_info());
+  return entity_data.specifics.device_info().cache_guid();
+}
+
 void DeviceInfoService::OnChangeProcessorSet() {
   // We've recieved a new processor that needs metadata. If we're still in the
   // process of loading data and/or metadata, then |has_metadata_loaded_| is
   // false and we'll wait for those async reads to happen. If we've already
   // loaded metadata and then subsequently we get a new processor, we must not
   // have created the processor ourselves because we had no metadata. So there
   // must not be any metadata on disk.
   if (has_metadata_loaded_) {
     change_processor()->OnMetadataLoaded(SyncError(),
                                          base::WrapUnique(new MetadataBatch()));
@@ skipping 256 matching lines @@
   if (!change_processor()) {
     return;
   }
 
   std::unique_ptr<DeviceInfoSpecifics> specifics =
       CopyToSpecifics(*local_device_info_provider_->GetLocalDeviceInfo());
   specifics->set_last_updated_timestamp(syncer::TimeToProtoTime(Time::Now()));
 
   std::unique_ptr<MetadataChangeList> metadata_change_list =
       CreateMetadataChangeList();
-  change_processor()->Put(DeviceInfoUtil::SpecificsToTag(*specifics),
-                          CopyToEntityData(*specifics),
+  change_processor()->Put(specifics->cache_guid(), CopyToEntityData(*specifics),
                           metadata_change_list.get());
 
   std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
   StoreSpecifics(std::move(specifics), batch.get());
 
   CommitAndNotify(std::move(batch), std::move(metadata_change_list), true);
   pulse_timer_.Start(
       FROM_HERE, DeviceInfoUtil::kPulseInterval,
       base::Bind(&DeviceInfoService::SendLocalData, base::Unretained(this)));
 }
@@ skipping 36 matching lines @@
 Time DeviceInfoService::GetLastUpdateTime(
     const DeviceInfoSpecifics& specifics) {
   if (specifics.has_last_updated_timestamp()) {
     return syncer::ProtoTimeToTime(specifics.last_updated_timestamp());
   } else {
     return Time();
   }
 }
 
 }  // namespace sync_driver_v2