[Sync] Remove ModelError::IsSet() in favor of base::Optional.

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 132 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::ModelError error,
+    base::Optional<syncer::ModelError> error,
     std::unique_ptr<syncer::MetadataBatch> metadata_batch) {
   DCHECK(CalledOnValidThread());
-  if (error.IsSet()) {
+  if (error) {
     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;
 }
 
@@ skipping 24 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::ModelError ReadingListStore::MergeSyncData(
+base::Optional<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::ModelError();
+  return {};
 }
 
 // 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::ModelError ReadingListStore::ApplySyncChanges(
+base::Optional<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::ModelError();
+  return {};
 }
 
 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);
@@ skipping 90 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;
 }