[Sync] Introduce ModelError for USS error handling.

components/sync/device_info/device_info_sync_bridge_unittest.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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 97 matching lines @@
   EXPECT_EQ(specifics.cache_guid(), model.guid());
   EXPECT_EQ(specifics.client_name(), model.client_name());
   EXPECT_EQ(specifics.device_type(), model.device_type());
   EXPECT_EQ(specifics.sync_user_agent(), model.sync_user_agent());
   EXPECT_EQ(specifics.chrome_version(), model.chrome_version());
   EXPECT_EQ(specifics.signin_scoped_device_id(),
             model.signin_scoped_device_id());
 }
 
 void VerifyDataBatch(std::map<std::string, DeviceInfoSpecifics> expected,
-                     SyncError error,
                      std::unique_ptr<DataBatch> batch) {
-  EXPECT_FALSE(error.IsSet());
   while (batch->HasNext()) {
     const KeyAndData& pair = batch->Next();
     auto iter = expected.find(pair.first);
     ASSERT_NE(iter, expected.end());
     VerifyEqual(iter->second, pair.second->specifics.device_info());
     // Removing allows us to verify we don't see the same item multiple times,
     // and that we saw everything we expected.
     expected.erase(iter);
   }
   EXPECT_TRUE(expected.empty());
@@ skipping 54 matching lines @@
            std::unique_ptr<EntityData> entity_data,
            MetadataChangeList* metadata_changes) override {
     put_multimap_.insert(std::make_pair(storage_key, std::move(entity_data)));
   }
 
   void Delete(const std::string& storage_key,
               MetadataChangeList* metadata_changes) override {
     delete_set_.insert(storage_key);
   }
 
-  void OnMetadataLoaded(SyncError error,
-                        std::unique_ptr<MetadataBatch> batch) override {
+  void OnMetadataLoaded(std::unique_ptr<MetadataBatch> batch) override {
     std::swap(metadata_, batch);
   }
 
   const std::multimap<std::string, std::unique_ptr<EntityData>>& put_multimap()
       const {
     return put_multimap_;
   }
   const std::set<std::string>& delete_set() const { return delete_set_; }
   const MetadataBatch* metadata() const { return metadata_.get(); }
 
@@ skipping 287 matching lines @@
   const std::map<std::string, DeviceInfoSpecifics> expected{
       {specifics1.cache_guid(), specifics1},
       {specifics2.cache_guid(), specifics2}};
   bridge()->GetData({specifics1.cache_guid(), specifics2.cache_guid()},
                     base::Bind(&VerifyDataBatch, expected));
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ApplySyncChangesEmpty) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
-  const SyncError error = bridge()->ApplySyncChanges(
+  const ModelError error = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityChangeList());
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ApplySyncChangesInMemory) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
   const DeviceInfoSpecifics specifics = CreateSpecifics(1);
-  const SyncError error_on_add = bridge()->ApplySyncChanges(
+  const ModelError error_on_add = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityAddList({specifics}));
 
   EXPECT_FALSE(error_on_add.IsSet());
   std::unique_ptr<DeviceInfo> info =
       bridge()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   VerifyEqual(specifics, *info.get());
   EXPECT_EQ(2, change_count());
 
-  const SyncError error_on_delete = bridge()->ApplySyncChanges(
+  const ModelError error_on_delete = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(),
       {EntityChange::CreateDelete(specifics.cache_guid())});
 
   EXPECT_FALSE(error_on_delete.IsSet());
   EXPECT_FALSE(bridge()->GetDeviceInfo(specifics.cache_guid()));
   EXPECT_EQ(3, change_count());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ApplySyncChangesStore) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
   const DeviceInfoSpecifics specifics = CreateSpecifics(1);
   ModelTypeState state = StateWithEncryption("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes =
       bridge()->CreateMetadataChangeList();
   metadata_changes->UpdateModelTypeState(state);
 
-  const SyncError error = bridge()->ApplySyncChanges(
+  const ModelError error = bridge()->ApplySyncChanges(
       std::move(metadata_changes), EntityAddList({specifics}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, change_count());
 
   RestartBridge();
 
   std::unique_ptr<DeviceInfo> info =
       bridge()->GetDeviceInfo(specifics.cache_guid());
   ASSERT_TRUE(info);
   VerifyEqual(specifics, *info.get());
@@ skipping 16 matching lines @@
   EXPECT_EQ(1, change_count());
   // Ensure |last_updated| is about now, plus or minus a little bit.
   const Time last_updated(ProtoTimeToTime(processor()
                                               ->put_multimap()
                                               .begin()
                                               ->second->specifics.device_info()
                                               .last_updated_timestamp()));
   EXPECT_LT(Time::Now() - TimeDelta::FromMinutes(1), last_updated);
   EXPECT_GT(Time::Now() + TimeDelta::FromMinutes(1), last_updated);
 
-  const SyncError error_on_add = bridge()->ApplySyncChanges(
+  const ModelError error_on_add = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityAddList({specifics}));
   EXPECT_FALSE(error_on_add.IsSet());
   EXPECT_EQ(1, change_count());
 
-  const SyncError error_on_delete = bridge()->ApplySyncChanges(
+  const ModelError error_on_delete = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(),
       {EntityChange::CreateDelete(specifics.cache_guid())});
   EXPECT_FALSE(error_on_delete.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ApplyDeleteNonexistent) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
-  const SyncError error =
+  const ModelError error =
       bridge()->ApplySyncChanges(bridge()->CreateMetadataChangeList(),
                                  {EntityChange::CreateDelete("guid")});
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ClearProviderAndApply) {
   // This will initialize the provider a first time.
   InitializeAndPump();
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
 
   const DeviceInfoSpecifics specifics = CreateSpecifics(1, Time::Now());
 
   local_device()->Clear();
-  SyncError error = bridge()->ApplySyncChanges(
+  ModelError error = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityAddList({specifics}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
 
   local_device()->Initialize(CreateModel(kDefaultLocalSuffix));
   error = bridge()->ApplySyncChanges(bridge()->CreateMetadataChangeList(),
                                      EntityAddList({specifics}));
   EXPECT_EQ(2u, bridge()->GetAllDeviceInfo().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MergeEmpty) {
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
-  const SyncError error = bridge()->MergeSyncData(
+  const ModelError error = bridge()->MergeSyncData(
       bridge()->CreateMetadataChangeList(), EntityDataMap());
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1, change_count());
   // TODO(skym): Stop sending local twice. The first of the two puts will
   // probably happen before the processor is tracking metadata yet, and so there
   // should not be much overhead.
   EXPECT_EQ(2u, processor()->put_multimap().size());
   EXPECT_EQ(2u, processor()->put_multimap().count(
                     local_device()->GetLocalDeviceInfo()->guid()));
   EXPECT_EQ(0u, processor()->delete_set().size());
@@ skipping 11 matching lines @@
 
   WriteToStore({unique_local, conflict_local});
   InitializeAndPump();
   EXPECT_EQ(1, change_count());
 
   ModelTypeState state = StateWithEncryption("ekn");
   std::unique_ptr<MetadataChangeList> metadata_changes =
       bridge()->CreateMetadataChangeList();
   metadata_changes->UpdateModelTypeState(state);
 
-  const SyncError error = bridge()->MergeSyncData(
+  const ModelError error = bridge()->MergeSyncData(
       std::move(metadata_changes),
       InlineEntityDataMap({conflict_remote, unique_remote}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2, change_count());
 
   // The remote should beat the local in conflict.
   EXPECT_EQ(4u, bridge()->GetAllDeviceInfo().size());
   VerifyEqual(unique_local,
               *bridge()->GetDeviceInfo(unique_local.cache_guid()).get());
   VerifyEqual(unique_remote,
@@ skipping 14 matching lines @@
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MergeLocalGuid) {
   // If not recent, then reconcile is going to try to send an updated version to
   // Sync, which makes interpreting change_count() more difficult.
   const DeviceInfoSpecifics specifics =
       CreateSpecifics(kDefaultLocalSuffix, Time::Now());
   WriteToStore({specifics});
   InitializeAndPump();
 
-  const SyncError error = bridge()->MergeSyncData(
+  const ModelError error = bridge()->MergeSyncData(
       bridge()->CreateMetadataChangeList(), InlineEntityDataMap({specifics}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   EXPECT_TRUE(processor()->delete_set().empty());
   EXPECT_TRUE(processor()->put_multimap().empty());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, MergeLocalGuidBeforeReconcile) {
   InitializeBridge();
 
   // The message loop is never pumped, which means local data/metadata is never
   // loaded, and thus reconcile is never called. The bridge should ignore this
   // EntityData because its cache guid is the same the local device's.
-  const SyncError error = bridge()->MergeSyncData(
+  const ModelError error = bridge()->MergeSyncData(
       bridge()->CreateMetadataChangeList(),
       InlineEntityDataMap({CreateSpecifics(kDefaultLocalSuffix)}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(0, change_count());
   EXPECT_EQ(0u, bridge()->GetAllDeviceInfo().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, ClearProviderAndMerge) {
   // This will initialize the provider a first time.
   InitializeAndPump();
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
 
   const DeviceInfoSpecifics specifics = CreateSpecifics(1, Time::Now());
 
   local_device()->Clear();
-  SyncError error = bridge()->MergeSyncData(
+  ModelError error = bridge()->MergeSyncData(
       bridge()->CreateMetadataChangeList(), InlineEntityDataMap({specifics}));
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   local_device()->Initialize(CreateModel(kDefaultLocalSuffix));
   error = bridge()->MergeSyncData(bridge()->CreateMetadataChangeList(),
                                   InlineEntityDataMap({specifics}));
   EXPECT_EQ(2u, bridge()->GetAllDeviceInfo().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, CountActiveDevices) {
@@ skipping 57 matching lines @@
   EXPECT_EQ(2, change_count());
   EXPECT_EQ(2u, processor()->put_multimap().size());
 }
 
 TEST_F(DeviceInfoSyncBridgeTest, DisableSync) {
   InitializeAndPump();
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(1, change_count());
 
   const DeviceInfoSpecifics specifics = CreateSpecifics(1);
-  const SyncError error = bridge()->ApplySyncChanges(
+  const ModelError error = bridge()->ApplySyncChanges(
       bridge()->CreateMetadataChangeList(), EntityAddList({specifics}));
 
   EXPECT_FALSE(error.IsSet());
   EXPECT_EQ(2u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(2, change_count());
 
   // Should clear out all local data and notify observers.
   bridge()->DisableSync();
   EXPECT_EQ(0u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(3, change_count());
 
   // Reloading from storage shouldn't contain remote data.
   RestartBridge();
   EXPECT_EQ(1u, bridge()->GetAllDeviceInfo().size());
   EXPECT_EQ(4, change_count());
 }
 
 }  // namespace
 
 }  // namespace syncer