[Sync] DeviceInfo implementation of MergeSyncData.

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>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "sync/api/entity_change.h"
 #include "sync/api/metadata_batch.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/data_batch_impl.h"
 #include "sync/internal_api/public/simple_metadata_change_list.h"
@@ skipping 45 matching lines @@
 
 DeviceInfoService::~DeviceInfoService() {}
 
 scoped_ptr<MetadataChangeList> DeviceInfoService::CreateMetadataChangeList() {
   return make_scoped_ptr(new SimpleMetadataChangeList());
 }
 
 SyncError DeviceInfoService::MergeSyncData(
     scoped_ptr<MetadataChangeList> metadata_change_list,
     EntityDataMap entity_data_map) {
-  // TODO(skym): crbug.com/543406: Implementation.
-  return SyncError();
+  if (!has_provider_initialized_ || !has_data_loaded_ || !change_processor()) {
+    return SyncError(
+        FROM_HERE, SyncError::DATATYPE_ERROR,
+        "Cannot call MergeSyncData without provider, data, and processor.",
+        syncer::DEVICE_INFO);
+  }
+
+  // Local data should typically be near empty, with the only possible value
+  // corresponding to this device. This is because on signout all device info
+  // data is blown away. However, this simplification is being ignored here and
+  // a full difference is going to be calculated to explore what other service
+  // implementations may look like.
+  std::set<std::string> local_only_tags;
+  for (const auto& kv : all_data_) {
+    local_only_tags.insert(kv.first);
+  }
+
+  bool has_changes = false;
+  std::string local_tag =
+      local_device_info_provider_->GetLocalDeviceInfo()->guid();
+  scoped_ptr<WriteBatch> batch = store_->CreateWriteBatch();
+  for (const auto& kv : entity_data_map) {
+    const std::string tag = GetClientTag(kv.second.value());
+    const DeviceInfoSpecifics& specifics =
+        kv.second.value().specifics.device_info();
+
+    // Ignore any remote changes that have our local cache guid.
+    if (tag == local_tag) {
+      continue;
+    }
+
+    // Remote data wins conflicts.
+    local_only_tags.erase(tag);
+    StoreSpecifics(make_scoped_ptr(new DeviceInfoSpecifics(specifics)),
+                   batch.get());
+    has_changes = true;
+  }
+
+  for (const std::string& tag : local_only_tags) {
+    change_processor()->Put(tag, CopyIntoNewEntityData(*all_data_[tag]),
+                            metadata_change_list.get());
+  }
+
+  // Transfer at the end because processor Put calls may update metadata.
+  static_cast<SimpleMetadataChangeList*>(metadata_change_list.get())
+      ->TransferChanges(store_.get(), batch.get());
+  store_->CommitWriteBatch(
+      std::move(batch),
+      base::Bind(&DeviceInfoService::OnCommit, weak_factory_.GetWeakPtr()));
+  if (has_changes) {
+    NotifyObservers();
+  }
+  return syncer::SyncError();
 }
 
 SyncError DeviceInfoService::ApplySyncChanges(
     scoped_ptr<MetadataChangeList> metadata_change_list,
     EntityChangeList entity_changes) {
   if (!has_provider_initialized_ || !has_data_loaded_) {
     return SyncError(
         FROM_HERE, SyncError::DATATYPE_ERROR,
         "Cannot call ApplySyncChanges before provider and data have loaded.",
         syncer::DEVICE_INFO);
@@ skipping 37 matching lines @@
   if (!has_data_loaded_) {
     callback.Run(SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
                            "Cannot call GetData before data has loaded.",
                            syncer::DEVICE_INFO),
                  scoped_ptr<DataBatchImpl>());
     return;
   }
 
   syncer::SyncError error;
   scoped_ptr<DataBatchImpl> batch(new DataBatchImpl());
-  for (auto& tag : client_tags) {
-    auto iter = all_data_.find(tag);
+  for (const auto& tag : client_tags) {
+    const auto iter = all_data_.find(tag);
     if (iter != all_data_.end()) {
       batch->Put(tag, CopyIntoNewEntityData(*iter->second));
     }
   }
   callback.Run(error, std::move(batch));
 }
 
 void DeviceInfoService::GetAllData(DataCallback callback) {
   if (!has_data_loaded_) {
     callback.Run(SyncError(FROM_HERE, SyncError::DATATYPE_ERROR,
                            "Cannot call GetAllData before data has loaded.",
                            syncer::DEVICE_INFO),
                  scoped_ptr<DataBatchImpl>());
     return;
   }
 
   syncer::SyncError error;
   scoped_ptr<DataBatchImpl> batch(new DataBatchImpl());
-  for (auto& kv : all_data_) {
+  for (const auto& kv : all_data_) {
     batch->Put(kv.first, CopyIntoNewEntityData(*kv.second));
   }
   callback.Run(error, std::move(batch));
 }
 
 std::string DeviceInfoService::GetClientTag(const EntityData& entity_data) {
   DCHECK(entity_data.specifics.has_device_info());
   return entity_data.specifics.device_info().cache_guid();
 }
 
 void DeviceInfoService::OnChangeProcessorSet() {
   TryLoadAllMetadata();
 }
 
 bool DeviceInfoService::IsSyncing() const {
   return !all_data_.empty();
 }
 
 scoped_ptr<DeviceInfo> DeviceInfoService::GetDeviceInfo(
     const std::string& client_id) const {
-  ClientIdToSpecifics::const_iterator iter = all_data_.find(client_id);
+  const ClientIdToSpecifics::const_iterator iter = all_data_.find(client_id);
   if (iter == all_data_.end()) {
     return scoped_ptr<DeviceInfo>();
   }
 
   return CreateDeviceInfo(*iter->second);
 }
 
 ScopedVector<DeviceInfo> DeviceInfoService::GetAllDeviceInfo() const {
   ScopedVector<DeviceInfo> list;
 
@@ skipping 181 matching lines @@
 }
 
 void DeviceInfoService::TryLoadAllMetadata() {
   if (has_data_loaded_ && change_processor()) {
     store_->ReadAllMetadata(base::Bind(&DeviceInfoService::OnReadAllMetadata,
                                        weak_factory_.GetWeakPtr()));
   }
 }
 
 }  // namespace sync_driver_v2