[Sync] Introduce ModelError for USS error handling.

components/reading_list/ios/reading_list_store.cc

 // Copyright 2016 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/reading_list/ios/reading_list_store.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "components/reading_list/ios/proto/reading_list.pb.h"
@@ skipping 100 matching lines @@
 
   change_processor()->Delete(entry.URL().spec(), metadata_change_list.get());
   batch_->TransferMetadataChanges(std::move(metadata_change_list));
 }
 
 void ReadingListStore::OnDatabaseLoad(
     syncer::ModelTypeStore::Result result,
     std::unique_ptr<syncer::ModelTypeStore::RecordList> entries) {
   DCHECK(CalledOnValidThread());
   if (result != syncer::ModelTypeStore::Result::SUCCESS) {
-    change_processor()->OnMetadataLoaded(
-        change_processor()->CreateAndUploadError(
-            FROM_HERE, "Cannot load Reading List Database."),
-        nullptr);
+    change_processor()->ReportError(FROM_HERE,
+                                    "Cannot load Reading List Database.");
     return;
   }
   auto loaded_entries =
       base::MakeUnique<ReadingListStoreDelegate::ReadingListEntries>();
 
   for (const syncer::ModelTypeStore::Record& r : *entries.get()) {
     reading_list::ReadingListLocal proto;
     if (!proto.ParseFromString(r.value)) {
       continue;
       // TODO(skym, crbug.com/582460): Handle unrecoverable initialization
@@ skipping 10 matching lines @@
     loaded_entries->insert(std::make_pair(url, std::move(*entry)));
   }
 
   delegate_->StoreLoaded(std::move(loaded_entries));
 
   store_->ReadAllMetadata(
       base::Bind(&ReadingListStore::OnReadAllMetadata, base::AsWeakPtr(this)));
 }
 
 void ReadingListStore::OnReadAllMetadata(
-    syncer::SyncError sync_error,
+    syncer::ModelError error,
     std::unique_ptr<syncer::MetadataBatch> metadata_batch) {
   DCHECK(CalledOnValidThread());
-  change_processor()->OnMetadataLoaded(sync_error, std::move(metadata_batch));
+  if (error.IsSet()) {
+    change_processor()->ReportError(FROM_HERE, "Failed to read metadata.");
+  } else {
+    change_processor()->OnMetadataLoaded(std::move(metadata_batch));
+  }
 }
 
 void ReadingListStore::OnDatabaseSave(syncer::ModelTypeStore::Result result) {
   return;
 }
 
 void ReadingListStore::OnStoreCreated(
     syncer::ModelTypeStore::Result result,
     std::unique_ptr<syncer::ModelTypeStore> store) {
   DCHECK(CalledOnValidThread());
@@ skipping 20 matching lines @@
 // keys in the |entity_data_map| will have been created via GetClientTag(...),
 // and if a local and sync data should match/merge but disagree on tags, the
 // service should use the sync data's tag. Any local pieces of data that are
 // not present in sync should immediately be Put(...) to the processor before
 // returning. The same MetadataChangeList that was passed into this function
 // can be passed to Put(...) calls. Delete(...) can also be called but should
 // not be needed for most model types. Durable storage writes, if not able to
 // combine all change atomically, should save the metadata after the data
 // changes, so that this merge will be re-driven by sync if is not completely
 // saved during the current run.
-syncer::SyncError ReadingListStore::MergeSyncData(
+syncer::ModelError ReadingListStore::MergeSyncData(
     std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
     syncer::EntityDataMap entity_data_map) {
   DCHECK(CalledOnValidThread());
   auto token = EnsureBatchCreated();
   // Keep track of the last update of each item.
   std::set<std::string> synced_entries;
   std::unique_ptr<ReadingListModel::ScopedReadingListBatchUpdate>
       model_batch_updates = model_->BeginBatchUpdates();
 
   // Merge sync to local data.
@@ skipping 58 matching lines @@
 
     auto entity_data = base::MakeUnique<syncer::EntityData>();
     *(entity_data->specifics.mutable_reading_list()) = *entry_pb;
     entity_data->non_unique_name = entry_pb->entry_id();
 
     change_processor()->Put(entry_pb->entry_id(), std::move(entity_data),
                             metadata_change_list.get());
   }
   batch_->TransferMetadataChanges(std::move(metadata_change_list));
 
-  return syncer::SyncError();
+  return syncer::ModelError();
 }
 
 // Apply changes from the sync server locally.
 // Please note that |entity_changes| might have fewer entries than
 // |metadata_change_list| in case when some of the data changes are filtered
 // out, or even be empty in case when a commit confirmation is processed and
 // only the metadata needs to persisted.
-syncer::SyncError ReadingListStore::ApplySyncChanges(
+syncer::ModelError ReadingListStore::ApplySyncChanges(
     std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
     syncer::EntityChangeList entity_changes) {
   DCHECK(CalledOnValidThread());
   std::unique_ptr<ReadingListModel::ScopedReadingListBatchUpdate> batch =
       model_->BeginBatchUpdates();
   auto token = EnsureBatchCreated();
 
   for (syncer::EntityChange& change : entity_changes) {
     if (change.type() == syncer::EntityChange::ACTION_DELETE) {
       batch_->DeleteData(change.storage_key());
@@ skipping 41 matching lines @@
         // ping-pong.
         change_processor()->Put(entry_sync_pb->entry_id(),
                                 std::move(entity_data),
                                 metadata_change_list.get());
 
       }
     }
   }
 
   batch_->TransferMetadataChanges(std::move(metadata_change_list));
-  return syncer::SyncError();
+  return syncer::ModelError();
 }
 
 void ReadingListStore::GetData(StorageKeyList storage_keys,
                                DataCallback callback) {
   DCHECK(CalledOnValidThread());
   auto batch = base::MakeUnique<syncer::MutableDataBatch>();
   for (const std::string& url_string : storage_keys) {
     const ReadingListEntry* entry = model_->GetEntryByURL(GURL(url_string));
     if (entry) {
       AddEntryToBatch(batch.get(), *entry);
     }
   }
 
-  callback.Run(syncer::SyncError(), std::move(batch));
+  callback.Run(std::move(batch));
 }
 
 void ReadingListStore::GetAllData(DataCallback callback) {
   DCHECK(CalledOnValidThread());
   auto batch = base::MakeUnique<syncer::MutableDataBatch>();
 
   for (const auto& url : model_->Keys()) {
     const ReadingListEntry* entry = model_->GetEntryByURL(GURL(url));
     AddEntryToBatch(batch.get(), *entry);
   }
 
-  callback.Run(syncer::SyncError(), std::move(batch));
+  callback.Run(std::move(batch));
 }
 
 void ReadingListStore::AddEntryToBatch(syncer::MutableDataBatch* batch,
                                        const ReadingListEntry& entry) {
   DCHECK(CalledOnValidThread());
   std::unique_ptr<sync_pb::ReadingListSpecifics> entry_pb =
       entry.AsReadingListSpecifics();
 
   std::unique_ptr<syncer::EntityData> entity_data(new syncer::EntityData());
   *(entity_data->specifics.mutable_reading_list()) = *entry_pb;
@@ skipping 64 matching lines @@
     if (rhs.first_read_time_us() == 0 && lhs.first_read_time_us() != 0) {
       return false;
     }
     if (rhs.first_read_time_us() > lhs.first_read_time_us() &&
         lhs.first_read_time_us() != 0) {
       return false;
     }
   }
   return true;
 }