Propagate more information about ValueStore errors to callers, notably an

chrome/browser/extensions/api/storage/settings_sync_unittest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 60 matching lines @@
 }
 
 // Returns whether the result of a storage operation is an expected value.
 // Logs when different.
 testing::AssertionResult SettingsEq(
     const char* _1, const char* _2,
     const DictionaryValue& expected,
     ValueStore::ReadResult actual) {
   if (actual->HasError()) {
     return testing::AssertionFailure() <<
-        "Expected: " << GetJson(expected) <<
-        ", actual has error: " << actual->error();
+        "Expected: " << expected <<
+        ", actual has error: " << actual->error().message;
   }
-  return ValuesEq(_1, _2, &expected, actual->settings().get());
+  return ValuesEq(_1, _2, &expected, &actual->settings());
 }
 
 // SyncChangeProcessor which just records the changes made, accessed after
 // being converted to the more useful SettingSyncData via changes().
 class MockSyncChangeProcessor : public syncer::SyncChangeProcessor {
  public:
   MockSyncChangeProcessor() : fail_all_requests_(false) {}
 
   // syncer::SyncChangeProcessor implementation.
   virtual syncer::SyncError ProcessSyncChanges(
@@ skipping 19 matching lines @@
   }
 
   // Mock methods.
 
   const SettingSyncDataList& changes() { return changes_; }
 
   void ClearChanges() {
     changes_.clear();
   }
 
-  void SetFailAllRequests(bool fail_all_requests) {
+  void set_fail_all_requests(bool fail_all_requests) {
     fail_all_requests_ = fail_all_requests;
   }
 
   // Returns the only change for a given extension setting.  If there is not
   // exactly 1 change for that key, a test assertion will fail.
   SettingSyncData GetOnlyChange(
       const std::string& extension_id, const std::string& key) {
     SettingSyncDataList matching_changes;
     for (SettingSyncDataList::iterator it = changes_.begin();
         it != changes_.end(); ++it) {
@@ skipping 579 matching lines @@
   // There is a bit of a convoluted method to get storage areas that can fail;
   // hand out TestingValueStore object then toggle them failing/succeeding
   // as necessary.
   TestingValueStoreFactory* testing_factory = new TestingValueStoreFactory();
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   // Make bad fail for incoming sync changes.
-  testing_factory->GetExisting("bad")->SetFailAllRequests(true);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::CORRUPTION);
   {
     syncer::SyncDataList sync_data;
     sync_data.push_back(settings_sync_util::CreateData(
           "good", "foo", fooValue, model_type));
     sync_data.push_back(settings_sync_util::CreateData(
           "bad", "foo", fooValue, model_type));
     GetSyncableService(model_type)->MergeDataAndStartSyncing(
         model_type,
         sync_data,
         sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
         scoped_ptr<syncer::SyncErrorFactory>(
             new syncer::SyncErrorFactoryMock()));
   }
-  testing_factory->GetExisting("bad")->SetFailAllRequests(false);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::OK);
 
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     DictionaryValue dict;
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
@@ skipping 62 matching lines @@
     dict.Set("bar", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     DictionaryValue dict;
     dict.Set("bar", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Failing ProcessSyncChanges shouldn't go to the storage.
-  testing_factory->GetExisting("bad")->SetFailAllRequests(true);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::CORRUPTION);
   {
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateUpdate(
           "good", "foo", fooValue, model_type));
     // (Ditto.)
     change_list.push_back(settings_sync_util::CreateUpdate(
           "bad", "foo", fooValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
-  testing_factory->GetExisting("bad")->SetFailAllRequests(false);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::OK);
 
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     dict.Set("bar", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     DictionaryValue dict;
     dict.Set("bar", fooValue.DeepCopy());
@@ skipping 97 matching lines @@
     dict.Set("foo", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Now fail ProcessSyncChanges for bad.
-  testing_factory->GetExisting("bad")->SetFailAllRequests(true);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::CORRUPTION);
   {
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateAdd(
           "good", "bar", barValue, model_type));
     change_list.push_back(settings_sync_util::CreateAdd(
           "bad", "bar", barValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
-  testing_factory->GetExisting("bad")->SetFailAllRequests(false);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::OK);
 
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
@@ skipping 44 matching lines @@
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   good->Set(DEFAULTS, "foo", fooValue);
   bad->Set(DEFAULTS, "foo", fooValue);
 
   // Even though bad will fail to get all sync data, sync data should still
   // include that from good.
-  testing_factory->GetExisting("bad")->SetFailAllRequests(true);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::CORRUPTION);
   {
     syncer::SyncDataList all_sync_data =
         GetSyncableService(model_type)->GetAllSyncData(model_type);
     EXPECT_EQ(1u, all_sync_data.size());
     EXPECT_EQ("good/foo", all_sync_data[0].GetTag());
   }
-  testing_factory->GetExisting("bad")->SetFailAllRequests(false);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::OK);
 
   // Sync shouldn't be disabled for good (nor bad -- but this is unimportant).
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
@@ skipping 27 matching lines @@
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   good->Set(DEFAULTS, "foo", fooValue);
   bad->Set(DEFAULTS, "foo", fooValue);
 
   // good will successfully push foo:fooValue to sync, but bad will fail to
   // get them so won't.
-  testing_factory->GetExisting("bad")->SetFailAllRequests(true);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::CORRUPTION);
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
-  testing_factory->GetExisting("bad")->SetFailAllRequests(false);
+  testing_factory->GetExisting("bad")->set_error_code(ValueStore::OK);
 
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
 
   // bad should now be disabled for sync.
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "bar", barValue);
   bad->Set(DEFAULTS, "bar", barValue);
@@ skipping 75 matching lines @@
 
   TestingValueStoreFactory* testing_factory = new TestingValueStoreFactory();
   storage_factory_->Reset(testing_factory);
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   // Only set bad; setting good will cause it to fail below.
   bad->Set(DEFAULTS, "foo", fooValue);
 
-  sync_processor_->SetFailAllRequests(true);
+  sync_processor_->set_fail_all_requests(true);
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
-  sync_processor_->SetFailAllRequests(false);
+  sync_processor_->set_fail_all_requests(false);
 
   // Changes from good will be send to sync, changes from bad won't.
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "foo", barValue);
   bad->Set(DEFAULTS, "foo", barValue);
 
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
@@ skipping 69 matching lines @@
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // bad will fail to send changes.
   good->Set(DEFAULTS, "foo", fooValue);
-  sync_processor_->SetFailAllRequests(true);
+  sync_processor_->set_fail_all_requests(true);
   bad->Set(DEFAULTS, "foo", fooValue);
-  sync_processor_->SetFailAllRequests(false);
+  sync_processor_->set_fail_all_requests(false);
 
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
 
   // No further changes should be sent from bad.
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "foo", barValue);
   bad->Set(DEFAULTS, "foo", barValue);
@@ skipping 125 matching lines @@
 
   // Test dots in keys that come from sync.
   {
     ValueStore::ReadResult data = storage->Get();
     ASSERT_FALSE(data->HasError());
 
     DictionaryValue expected_data;
     expected_data.SetWithoutPathExpansion(
         "key.with.dot",
         new base::StringValue("value"));
-    EXPECT_TRUE(Value::Equals(&expected_data, data->settings().get()));
+    EXPECT_TRUE(Value::Equals(&expected_data, &data->settings()));
   }
 
   // Test dots in keys going to sync.
   {
     scoped_ptr<Value> string_value(new base::StringValue("spot"));
     storage->Set(DEFAULTS, "key.with.spot", *string_value);
 
     ASSERT_EQ(1u, sync_processor_->changes().size());
     SettingSyncData sync_data = sync_processor_->changes()[0];
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, sync_data.change_type());
     EXPECT_EQ("ext", sync_data.extension_id());
     EXPECT_EQ("key.with.spot", sync_data.key());
     EXPECT_TRUE(sync_data.value().Equals(string_value.get()));
   }
 }
 
 }  // namespace extensions