[Sync] Introduce ModelError for USS error handling.

components/sync/device_info/device_info_sync_bridge.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 <stdint.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "components/sync/base/time.h"
 #include "components/sync/device_info/device_info_util.h"
 #include "components/sync/model/entity_change.h"
 #include "components/sync/model/metadata_batch.h"
+#include "components/sync/model/model_error.h"
 #include "components/sync/model/mutable_data_batch.h"
-#include "components/sync/model/sync_error.h"
 #include "components/sync/protocol/model_type_state.pb.h"
 #include "components/sync/protocol/sync.pb.h"
 
 namespace syncer {
 
 using base::Time;
 using base::TimeDelta;
 using sync_pb::DeviceInfoSpecifics;
 using sync_pb::EntitySpecifics;
 using sync_pb::ModelTypeState;
@@ skipping 73 matching lines @@
       base::Bind(&DeviceInfoSyncBridge::OnStoreCreated, base::AsWeakPtr(this)));
 }
 
 DeviceInfoSyncBridge::~DeviceInfoSyncBridge() {}
 
 std::unique_ptr<MetadataChangeList>
 DeviceInfoSyncBridge::CreateMetadataChangeList() {
   return WriteBatch::CreateMetadataChangeList();
 }
 
-SyncError DeviceInfoSyncBridge::MergeSyncData(
+ModelError DeviceInfoSyncBridge::MergeSyncData(
     std::unique_ptr<MetadataChangeList> metadata_change_list,
     EntityDataMap entity_data_map) {
   DCHECK(has_provider_initialized_);
   DCHECK(change_processor()->IsTrackingMetadata());
   const DeviceInfo* local_info =
       local_device_info_provider_->GetLocalDeviceInfo();
   // If our dependency was yanked out from beneath us, we cannot correctly
   // handle this request, and all our data will be deleted soon.
   if (local_info == nullptr) {
-    return SyncError();
+    return ModelError();
   }
 
   // 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 bridge
   // implementations may look like.
   std::set<std::string> local_guids_to_put;
   for (const auto& kv : all_data_) {
     local_guids_to_put.insert(kv.first);
@@ skipping 20 matching lines @@
     }
   }
 
   for (const std::string& guid : local_guids_to_put) {
     change_processor()->Put(guid, CopyToEntityData(*all_data_[guid]),
                             metadata_change_list.get());
   }
 
   batch->TransferMetadataChanges(std::move(metadata_change_list));
   CommitAndNotify(std::move(batch), has_changes);
-  return SyncError();
+  return ModelError();
 }
 
-SyncError DeviceInfoSyncBridge::ApplySyncChanges(
+ModelError DeviceInfoSyncBridge::ApplySyncChanges(
     std::unique_ptr<MetadataChangeList> metadata_change_list,
     EntityChangeList entity_changes) {
   DCHECK(has_provider_initialized_);
   const DeviceInfo* local_info =
       local_device_info_provider_->GetLocalDeviceInfo();
   // If our dependency was yanked out from beneath us, we cannot correctly
   // handle this request, and all our data will be deleted soon.
   if (local_info == nullptr) {
-    return SyncError();
+    return ModelError();
   }
 
   std::unique_ptr<WriteBatch> batch = store_->CreateWriteBatch();
   bool has_changes = false;
   for (EntityChange& change : entity_changes) {
     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_info->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::MakeUnique<DeviceInfoSpecifics>(specifics),
                      batch.get());
       has_changes = true;
     }
   }
 
   batch->TransferMetadataChanges(std::move(metadata_change_list));
   CommitAndNotify(std::move(batch), has_changes);
-  return SyncError();
+  return ModelError();
 }
 
 void DeviceInfoSyncBridge::GetData(StorageKeyList storage_keys,
                                    DataCallback callback) {
   auto batch = base::MakeUnique<MutableDataBatch>();
   for (const auto& key : storage_keys) {
     const auto& iter = all_data_.find(key);
     if (iter != all_data_.end()) {
       DCHECK_EQ(key, iter->second->cache_guid());
       batch->Put(key, CopyToEntityData(*iter->second));
     }
   }
-  callback.Run(SyncError(), std::move(batch));
+  callback.Run(std::move(batch));
 }
 
 void DeviceInfoSyncBridge::GetAllData(DataCallback callback) {
   auto batch = base::MakeUnique<MutableDataBatch>();
   for (const auto& kv : all_data_) {
     batch->Put(kv.first, CopyToEntityData(*kv.second));
   }
-  callback.Run(SyncError(), std::move(batch));
+  callback.Run(std::move(batch));
 }
 
 std::string DeviceInfoSyncBridge::GetClientTag(const EntityData& entity_data) {
   DCHECK(entity_data.specifics.has_device_info());
   return DeviceInfoUtil::SpecificsToTag(entity_data.specifics.device_info());
 }
 
 std::string DeviceInfoSyncBridge::GetStorageKey(const EntityData& entity_data) {
   DCHECK(entity_data.specifics.has_device_info());
   return entity_data.specifics.device_info().cache_guid();
@@ skipping 98 matching lines @@
 }
 
 void DeviceInfoSyncBridge::OnStoreCreated(
     Result result,
     std::unique_ptr<ModelTypeStore> store) {
   if (result == Result::SUCCESS) {
     std::swap(store_, store);
     store_->ReadAllData(base::Bind(&DeviceInfoSyncBridge::OnReadAllData,
                                    base::AsWeakPtr(this)));
   } else {
-    ReportStartupErrorToSync("ModelTypeStore creation failed.");
+    change_processor()->ReportError(FROM_HERE,
+                                    "ModelTypeStore creation failed.");
   }
 }
 
 void DeviceInfoSyncBridge::OnReadAllData(
     Result result,
     std::unique_ptr<RecordList> record_list) {
   if (result != Result::SUCCESS) {
-    ReportStartupErrorToSync("Initial load of data failed.");
+    change_processor()->ReportError(FROM_HERE, "Initial load of data failed.");
     return;
   }
 
   for (const Record& r : *record_list.get()) {
     std::unique_ptr<DeviceInfoSpecifics> specifics =
         base::MakeUnique<DeviceInfoSpecifics>();
     if (specifics->ParseFromString(r.value)) {
       all_data_[specifics->cache_guid()] = std::move(specifics);
     } else {
-      ReportStartupErrorToSync("Failed to deserialize specifics.");
+      change_processor()->ReportError(FROM_HERE,
+                                      "Failed to deserialize specifics.");
+      return;
     }
   }
 
   has_data_loaded_ = true;
   LoadMetadataIfReady();
 }
 
 void DeviceInfoSyncBridge::LoadMetadataIfReady() {
   if (has_data_loaded_ && has_provider_initialized_) {
     store_->ReadAllMetadata(base::Bind(&DeviceInfoSyncBridge::OnReadAllMetadata,
                                        base::AsWeakPtr(this)));
   }
 }
 
 void DeviceInfoSyncBridge::OnReadAllMetadata(
-    SyncError error,
+    ModelError error,
     std::unique_ptr<MetadataBatch> metadata_batch) {
-  change_processor()->OnMetadataLoaded(error, std::move(metadata_batch));
+  if (error.IsSet()) {
+    change_processor()->ReportError(error);
+    return;
+  }
+
+  change_processor()->OnMetadataLoaded(std::move(metadata_batch));
   ReconcileLocalAndStored();
 }
 
 void DeviceInfoSyncBridge::OnCommit(Result result) {
   if (result != Result::SUCCESS) {
-    change_processor()->CreateAndUploadError(FROM_HERE,
-                                             "Failed a write to store.");
+    change_processor()->ReportError(FROM_HERE, "Failed a write to store.");
   }
 }
 
 void DeviceInfoSyncBridge::ReconcileLocalAndStored() {
   // On initial syncing we will have a change processor here, but it will not be
   // tracking changes. We need to persist a copy of our local device info to
   // disk, but the Put call to the processor will be ignored. That should be
   // fine however, as the discrepancy will be picked up later in merge. We don't
   // bother trying to track this case and act intelligently because simply not
   // much of a benefit in doing so.
@@ skipping 65 matching lines @@
 }
 
 int DeviceInfoSyncBridge::CountActiveDevices(const Time now) const {
   return std::count_if(all_data_.begin(), all_data_.end(),
                        [now](ClientIdToSpecifics::const_reference pair) {
                          return DeviceInfoUtil::IsActive(
                              GetLastUpdateTime(*pair.second), now);
                        });
 }
 
-void DeviceInfoSyncBridge::ReportStartupErrorToSync(const std::string& msg) {
-  // TODO(skym): Shouldn't need to log this here, reporting should always log.
-  LOG(WARNING) << msg;
-  change_processor()->OnMetadataLoaded(
-      change_processor()->CreateAndUploadError(FROM_HERE, msg), nullptr);
-}
-
 }  // namespace syncer