[Sync] Introduce ModelError for USS error handling.

components/autofill/core/browser/webdata/autocomplete_sync_bridge.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/autofill/core/browser/webdata/autocomplete_sync_bridge.h"
 
 #include <unordered_set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/proto/autofill_sync.pb.h"
 #include "components/autofill/core/browser/webdata/autofill_metadata_change_list.h"
 #include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_backend.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/sync/model/entity_data.h"
+#include "components/sync/model/model_error.h"
 #include "components/sync/model/model_type_change_processor.h"
 #include "components/sync/model/mutable_data_batch.h"
-#include "components/sync/model/sync_error.h"
 #include "net/base/escape.h"
 
 namespace autofill {
 
 namespace {
 
 const char kAutocompleteEntryNamespaceTag[] = "autofill_entry|";
 const char kAutocompleteTagDelimiter[] = "|";
 
 void* UserDataKey() {
@@ skipping 65 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 std::unique_ptr<syncer::MetadataChangeList>
 AutocompleteSyncBridge::CreateMetadataChangeList() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return base::MakeUnique<AutofillMetadataChangeList>(GetAutofillTable(),
                                                       syncer::AUTOFILL);
 }
 
-syncer::SyncError AutocompleteSyncBridge::MergeSyncData(
+syncer::ModelError AutocompleteSyncBridge::MergeSyncData(
     std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
     syncer::EntityDataMap entity_data_map) {
   DCHECK(thread_checker_.CalledOnValidThread());
   NOTIMPLEMENTED();
-  return syncer::SyncError();
+  return syncer::ModelError();
 }
 
-syncer::SyncError AutocompleteSyncBridge::ApplySyncChanges(
+syncer::ModelError AutocompleteSyncBridge::ApplySyncChanges(
     std::unique_ptr<syncer::MetadataChangeList> metadata_change_list,
     syncer::EntityChangeList entity_changes) {
   DCHECK(thread_checker_.CalledOnValidThread());
   NOTIMPLEMENTED();
-  return syncer::SyncError();
+  return syncer::ModelError();
 }
 
 void AutocompleteSyncBridge::AutocompleteSyncBridge::GetData(
     StorageKeyList storage_keys,
     DataCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::unordered_set<std::string> keys_set;
   for (const auto& key : storage_keys) {

[skym, 2017/01/09 18:20:28]

Might as well only make this after we avoid the error case. Though if you do the
predicate suggestion below then you cannot do this.

[maxbogue, 2017/01/09 21:29:33]

Done.

     keys_set.insert(key);
   }
 
+  std::vector<AutofillEntry> entries;
+  if (!GetAutofillTable()->GetAllAutofillEntries(&entries)) {

[skym, 2017/01/09 18:20:27]

I see you added the logic here but not the unit tests! :p

[maxbogue, 2017/01/09 21:29:33]

Taking you up on your offline offer to add them yourself :)

+    change_processor()->ReportError(FROM_HERE,
+                                    "Failed to load entries from table.");
+    return;
+  }
+
   auto batch = base::MakeUnique<syncer::MutableDataBatch>();
-  std::vector<AutofillEntry> entries;
-  GetAutofillTable()->GetAllAutofillEntries(&entries);
   for (const AutofillEntry& entry : entries) {
     std::string key = GetStorageKeyFromModel(entry.key());
     if (keys_set.find(key) != keys_set.end()) {
       batch->Put(key, CreateEntityData(entry));
     }
   }
-  callback.Run(syncer::SyncError(), std::move(batch));
+  callback.Run(std::move(batch));
 }
 
 void AutocompleteSyncBridge::GetAllData(DataCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  std::vector<AutofillEntry> entries;
+  if (!GetAutofillTable()->GetAllAutofillEntries(&entries)) {

[skym, 2017/01/09 18:20:27]

This is looking very repeated to above. You could create a predicate function
that filters out results for GetData(...) and no-ops for GetAllData(...). But if
you don't feel like it, I'm okay with that too.

[maxbogue, 2017/01/09 21:29:33]

Passing on this for now.

+    change_processor()->ReportError(FROM_HERE,
+                                    "Failed to load entries from table.");
+    return;
+  }
+
   auto batch = base::MakeUnique<syncer::MutableDataBatch>();
-  std::vector<AutofillEntry> entries;
-  GetAutofillTable()->GetAllAutofillEntries(&entries);
   for (const AutofillEntry& entry : entries) {
     batch->Put(GetStorageKeyFromModel(entry.key()), CreateEntityData(entry));
   }
-  callback.Run(syncer::SyncError(), std::move(batch));
+  callback.Run(std::move(batch));
 }
 
 std::string AutocompleteSyncBridge::GetClientTag(
     const syncer::EntityData& entity_data) {
   DCHECK(entity_data.specifics.has_autofill());
   const sync_pb::AutofillSpecifics specifics = entity_data.specifics.autofill();
   return std::string(kAutocompleteEntryNamespaceTag) +
          net::EscapePath(specifics.name()) +
          std::string(kAutocompleteTagDelimiter) +
          net::EscapePath(specifics.value());
@@ skipping 25 matching lines @@
     date_last_used = base::Time::FromInternalValue(*timestamps.rbegin());
   }
   return AutofillEntry(key, date_created, date_last_used);
 }
 
 AutofillTable* AutocompleteSyncBridge::GetAutofillTable() const {
   return AutofillTable::FromWebDatabase(web_data_backend_->GetDatabase());
 }
 
 }  // namespace autofill