Extension settings API: force through changes that come from sync (ignoring

chrome/browser/extensions/settings/settings_sync_unittest.cc

 // Copyright (c) 2011 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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 14 matching lines @@
 // TODO(kalman): Integration tests for sync.
 
 using content::BrowserThread;
 
 namespace extensions {
 
 using namespace settings_test_util;
 
 namespace {
 
+// To save typing SettingsStorage::DEFAULTS everywhere.
+const SettingsStorage::WriteOptions DEFAULTS = SettingsStorage::DEFAULTS;
+
 // Gets the pretty-printed JSON for a value.
 static std::string GetJson(const Value& value) {
   std::string json;
   base::JSONWriter::Write(&value, true, &json);
   return json;
 }
 
 // Returns whether two Values are equal.
 testing::AssertionResult ValuesEq(
     const char* _1, const char* _2,
@@ skipping 220 matching lines @@
   syncable::ModelType model_type = syncable::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   SettingsStorage* storage1 = AddExtensionAndGetStorage("s1", type);
   SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
 
-  storage1->Set("foo", value1);
-  storage2->Set("bar", value2);
+  storage1->Set(DEFAULTS, "foo", value1);
+  storage2->Set(DEFAULTS, "bar", value2);
 
   std::map<std::string, SettingSyncDataList> all_sync_data =
       GetAllSyncData(model_type);
   ASSERT_EQ(2u, all_sync_data.size());
   ASSERT_EQ(1u, all_sync_data["s1"].size());
   ASSERT_PRED_FORMAT2(ValuesEq, &value1, &all_sync_data["s1"][0].value());
   ASSERT_EQ(1u, all_sync_data["s2"].size());
   ASSERT_PRED_FORMAT2(ValuesEq, &value2, &all_sync_data["s2"][0].value());
 
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s1", "foo", value1));
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2));
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, sync_data, &sync_);
 
   // Already in sync, so no changes.
   ASSERT_EQ(0u, sync_.changes().size());
 
   // Regression test: not-changing the synced value shouldn't result in a sync
   // change, and changing the synced value should result in an update.
-  storage1->Set("foo", value1);
+  storage1->Set(DEFAULTS, "foo", value1);
   ASSERT_EQ(0u, sync_.changes().size());
 
-  storage1->Set("foo", value2);
+  storage1->Set(DEFAULTS, "foo", value2);
   ASSERT_EQ(1u, sync_.changes().size());
   SettingSyncData change = sync_.GetOnlyChange("s1", "foo");
   ASSERT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
   ASSERT_TRUE(value2.Equals(&change.value()));
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, LocalDataWithNoSyncDataIsPushedToSync) {
   syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   SettingsStorage* storage1 = AddExtensionAndGetStorage("s1", type);
   SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
 
-  storage1->Set("foo", value1);
-  storage2->Set("bar", value2);
+  storage1->Set(DEFAULTS, "foo", value1);
+  storage2->Set(DEFAULTS, "bar", value2);
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, SyncDataList(), &sync_);
 
   // All settings should have been pushed to sync.
   ASSERT_EQ(2u, sync_.changes().size());
   SettingSyncData change = sync_.GetOnlyChange("s1", "foo");
   ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
   ASSERT_TRUE(value1.Equals(&change.value()));
   change = sync_.GetOnlyChange("s2", "bar");
@@ skipping 10 matching lines @@
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   // Maintain dictionaries mirrored to the expected values of the settings in
   // each storage area.
   DictionaryValue expected1, expected2;
 
   // Pre-populate one of the storage areas.
   SettingsStorage* storage1 = AddExtensionAndGetStorage("s1", type);
-  storage1->Set("overwriteMe", value1);
+  storage1->Set(DEFAULTS, "overwriteMe", value1);
 
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s1", "foo", value1));
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2));
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, sync_data, &sync_);
   expected1.Set("foo", value1.DeepCopy());
   expected2.Set("bar", value2.DeepCopy());
@@ skipping 19 matching lines @@
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   // Maintain dictionaries mirrored to the expected values of the settings in
   // each storage area.
   DictionaryValue expected1, expected2;
 
   // Make storage1 initialised from local data, storage2 initialised from sync.
   SettingsStorage* storage1 = AddExtensionAndGetStorage("s1", type);
   SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
 
-  storage1->Set("foo", value1);
+  storage1->Set(DEFAULTS, "foo", value1);
   expected1.Set("foo", value1.DeepCopy());
 
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2));
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, sync_data, &sync_);
   expected2.Set("bar", value2.DeepCopy());
 
@@ skipping 49 matching lines @@
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   // Make storage1/2 initialised from local data, storage3/4 initialised from
   // sync.
   SettingsStorage* storage1 = AddExtensionAndGetStorage("s1", type);
   SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
   SettingsStorage* storage3 = AddExtensionAndGetStorage("s3", type);
   SettingsStorage* storage4 = AddExtensionAndGetStorage("s4", type);
 
-  storage1->Set("foo", value1);
-  storage2->Set("foo", value1);
+  storage1->Set(DEFAULTS, "foo", value1);
+  storage2->Set(DEFAULTS, "foo", value1);
 
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s3", "bar", value2));
   sync_data.push_back(settings_sync_util::CreateData(
       "s4", "bar", value2));
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, sync_data, &sync_);
 
   // Add something locally.
-  storage1->Set("bar", value2);
-  storage2->Set("bar", value2);
-  storage3->Set("foo", value1);
-  storage4->Set("foo", value1);
+  storage1->Set(DEFAULTS, "bar", value2);
+  storage2->Set(DEFAULTS, "bar", value2);
+  storage3->Set(DEFAULTS, "foo", value1);
+  storage4->Set(DEFAULTS, "foo", value1);
 
   SettingSyncData change = sync_.GetOnlyChange("s1", "bar");
     ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
     ASSERT_TRUE(value2.Equals(&change.value()));
   sync_.GetOnlyChange("s2", "bar");
     ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
     ASSERT_TRUE(value2.Equals(&change.value()));
   change = sync_.GetOnlyChange("s3", "foo");
     ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
     ASSERT_TRUE(value1.Equals(&change.value()));
   change = sync_.GetOnlyChange("s4", "foo");
     ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
     ASSERT_TRUE(value1.Equals(&change.value()));
 
   // Change something locally, storage1/3 the new setting and storage2/4 the
   // initial setting, for all combinations of local vs sync intialisation and
   // new vs initial.
   sync_.ClearChanges();
-  storage1->Set("bar", value1);
-  storage2->Set("foo", value2);
-  storage3->Set("bar", value1);
-  storage4->Set("foo", value2);
+  storage1->Set(DEFAULTS, "bar", value1);
+  storage2->Set(DEFAULTS, "foo", value2);
+  storage3->Set(DEFAULTS, "bar", value1);
+  storage4->Set(DEFAULTS, "foo", value2);
 
   change = sync_.GetOnlyChange("s1", "bar");
     ASSERT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
     ASSERT_TRUE(value1.Equals(&change.value()));
   change = sync_.GetOnlyChange("s2", "foo");
     ASSERT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
     ASSERT_TRUE(value2.Equals(&change.value()));
   change = sync_.GetOnlyChange("s3", "bar");
     ASSERT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
     ASSERT_TRUE(value1.Equals(&change.value()));
   change = sync_.GetOnlyChange("s4", "foo");
     ASSERT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
     ASSERT_TRUE(value2.Equals(&change.value()));
 
   // Remove something locally, storage1/3 the new setting and storage2/4 the
   // initial setting, for all combinations of local vs sync intialisation and
   // new vs initial.
   sync_.ClearChanges();
-  storage1->Remove("foo");
-  storage2->Remove("bar");
-  storage3->Remove("foo");
-  storage4->Remove("bar");
+  storage1->Remove(DEFAULTS, "foo");
+  storage2->Remove(DEFAULTS, "bar");
+  storage3->Remove(DEFAULTS, "foo");
+  storage4->Remove(DEFAULTS, "bar");
 
   ASSERT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s1", "foo").change_type());
   ASSERT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s2", "bar").change_type());
   ASSERT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s3", "foo").change_type());
   ASSERT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s4", "bar").change_type());
 
   // Remove some nonexistent settings.
   sync_.ClearChanges();
-  storage1->Remove("foo");
-  storage2->Remove("bar");
-  storage3->Remove("foo");
-  storage4->Remove("bar");
+  storage1->Remove(DEFAULTS, "foo");
+  storage2->Remove(DEFAULTS, "bar");
+  storage3->Remove(DEFAULTS, "foo");
+  storage4->Remove(DEFAULTS, "bar");
 
   ASSERT_EQ(0u, sync_.changes().size());
 
   // Clear the rest of the settings.  Add the removed ones back first so that
   // more than one setting is cleared.
-  storage1->Set("foo", value1);
-  storage2->Set("bar", value2);
-  storage3->Set("foo", value1);
-  storage4->Set("bar", value2);
+  storage1->Set(DEFAULTS, "foo", value1);
+  storage2->Set(DEFAULTS, "bar", value2);
+  storage3->Set(DEFAULTS, "foo", value1);
+  storage4->Set(DEFAULTS, "bar", value2);
 
   sync_.ClearChanges();
-  storage1->Clear();
-  storage2->Clear();
-  storage3->Clear();
-  storage4->Clear();
+  storage1->Clear(DEFAULTS);
+  storage2->Clear(DEFAULTS);
+  storage3->Clear(DEFAULTS);
+  storage4->Clear(DEFAULTS);
 
   ASSERT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s1", "foo").change_type());
   ASSERT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s1", "bar").change_type());
   ASSERT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s2", "foo").change_type());
@@ skipping 20 matching lines @@
   StringValue value1("fooValue");
   ListValue value2;
   value2.Append(StringValue::CreateStringValue("barValue"));
 
   // storage1 is an extension, storage2 is an app.
   SettingsStorage* storage1 = AddExtensionAndGetStorage(
       "s1", Extension::TYPE_EXTENSION);
   SettingsStorage* storage2 = AddExtensionAndGetStorage(
       "s2", Extension::TYPE_PACKAGED_APP);
 
-  storage1->Set("foo", value1);
-  storage2->Set("bar", value2);
+  storage1->Set(DEFAULTS, "foo", value1);
+  storage2->Set(DEFAULTS, "bar", value2);
 
   std::map<std::string, SettingSyncDataList> extension_sync_data =
       GetAllSyncData(syncable::EXTENSION_SETTINGS);
   ASSERT_EQ(1u, extension_sync_data.size());
   ASSERT_EQ(1u, extension_sync_data["s1"].size());
   ASSERT_PRED_FORMAT2(ValuesEq, &value1, &extension_sync_data["s1"][0].value());
 
   std::map<std::string, SettingSyncDataList> app_sync_data =
       GetAllSyncData(syncable::APP_SETTINGS);
   ASSERT_EQ(1u, app_sync_data.size());
@@ skipping 57 matching lines @@
     dict.Set("foo", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     DictionaryValue dict;
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Changes made to good should be sent to sync, changes from bad shouldn't.
   sync_.ClearChanges();
-  good->Set("bar", barValue);
-  bad->Set("bar", barValue);
+  good->Set(DEFAULTS, "bar", barValue);
+  bad->Set(DEFAULTS, "bar", barValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(1u, sync_.changes().size());
 
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     dict.Set("bar", barValue.DeepCopy());
@@ skipping 26 matching lines @@
   }
   {
     DictionaryValue dict;
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Changes made to bad still shouldn't go to sync, even though it didn't fail
   // last time.
   sync_.ClearChanges();
-  good->Set("bar", fooValue);
-  bad->Set("bar", fooValue);
+  good->Set(DEFAULTS, "bar", fooValue);
+  bad->Set(DEFAULTS, "bar", fooValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(1u, sync_.changes().size());
 
   {
     DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     dict.Set("bar", fooValue.DeepCopy());
@@ skipping 44 matching lines @@
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("bad", "bar").change_type());
   EXPECT_EQ(3u, sync_.changes().size());
 
   // Live local changes now get pushed, too.
   sync_.ClearChanges();
-  good->Set("bar", barValue);
-  bad->Set("bar", barValue);
+  good->Set(DEFAULTS, "bar", barValue);
+  bad->Set(DEFAULTS, "bar", barValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("bad", "bar").change_type());
   EXPECT_EQ(2u, sync_.changes().size());
 
   // And ProcessSyncChanges work, too.
@@ skipping 78 matching lines @@
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // No more changes sent to sync for bad.
   sync_.ClearChanges();
-  good->Set("foo", barValue);
-  bad->Set("foo", barValue);
+  good->Set(DEFAULTS, "foo", barValue);
+  bad->Set(DEFAULTS, "foo", barValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(1u, sync_.changes().size());
 
   // No more changes received from sync should go to bad.
   {
     SyncChangeList change_list;
     change_list.push_back(
@@ skipping 23 matching lines @@
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingSettingsStorageFactory* testing_factory =
       new TestingSettingsStorageFactory();
   storage_factory_->Reset(testing_factory);
 
   SettingsStorage* good = AddExtensionAndGetStorage("good", type);
   SettingsStorage* bad = AddExtensionAndGetStorage("bad", type);
 
-  good->Set("foo", fooValue);
-  bad->Set("foo", fooValue);
+  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);
   {
     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);
 
   // Sync shouldn't be disabled for good (nor bad -- but this is unimportant).
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, SyncDataList(), &sync_);
 
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("bad", "foo").change_type());
   EXPECT_EQ(2u, sync_.changes().size());
 
   sync_.ClearChanges();
-  good->Set("bar", barValue);
-  bad->Set("bar", barValue);
+  good->Set(DEFAULTS, "bar", barValue);
+  bad->Set(DEFAULTS, "bar", barValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("bad", "bar").change_type());
   EXPECT_EQ(2u, sync_.changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToReadChangesToPushDisablesSync) {
   syncable::ModelType model_type = syncable::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingSettingsStorageFactory* testing_factory =
       new TestingSettingsStorageFactory();
   storage_factory_->Reset(testing_factory);
 
   SettingsStorage* good = AddExtensionAndGetStorage("good", type);
   SettingsStorage* bad = AddExtensionAndGetStorage("bad", type);
 
-  good->Set("foo", fooValue);
-  bad->Set("foo", fooValue);
+  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);
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, SyncDataList(), &sync_);
   testing_factory->GetExisting("bad")->SetFailAllRequests(false);
 
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(1u, sync_.changes().size());
 
   // bad should now be disabled for sync.
   sync_.ClearChanges();
-  good->Set("bar", barValue);
-  bad->Set("bar", barValue);
+  good->Set(DEFAULTS, "bar", barValue);
+  bad->Set(DEFAULTS, "bar", barValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(1u, sync_.changes().size());
 
   {
     SyncChangeList change_list;
     change_list.push_back(
         settings_sync_util::CreateUpdate("good", "foo", barValue));
@@ skipping 32 matching lines @@
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("bad", "foo").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("bad", "bar").change_type());
   EXPECT_EQ(4u, sync_.changes().size());
 
   sync_.ClearChanges();
-  good->Set("bar", fooValue);
-  bad->Set("bar", fooValue);
+  good->Set(DEFAULTS, "bar", fooValue);
+  bad->Set(DEFAULTS, "bar", fooValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(2u, sync_.changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalStateDisablesSync) {
   syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingSettingsStorageFactory* testing_factory =
       new TestingSettingsStorageFactory();
   storage_factory_->Reset(testing_factory);
 
   SettingsStorage* good = AddExtensionAndGetStorage("good", type);
   SettingsStorage* bad = AddExtensionAndGetStorage("bad", type);
 
   // Only set bad; setting good will cause it to fail below.
-  bad->Set("foo", fooValue);
+  bad->Set(DEFAULTS, "foo", fooValue);
 
   sync_.SetFailAllRequests(true);
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, SyncDataList(), &sync_);
   sync_.SetFailAllRequests(false);
 
   // Changes from good will be send to sync, changes from bad won't.
   sync_.ClearChanges();
-  good->Set("foo", barValue);
-  bad->Set("foo", barValue);
+  good->Set(DEFAULTS, "foo", barValue);
+  bad->Set(DEFAULTS, "foo", barValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(1u, sync_.changes().size());
 
   // Changes from sync will be sent to good, not to bad.
   {
     SyncChangeList change_list;
     change_list.push_back(
@@ skipping 26 matching lines @@
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("bad", "foo").change_type());
   EXPECT_EQ(3u, sync_.changes().size());
 
   sync_.ClearChanges();
-  good->Set("foo", fooValue);
-  bad->Set("foo", fooValue);
+  good->Set(DEFAULTS, "foo", fooValue);
+  bad->Set(DEFAULTS, "foo", fooValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(2u, sync_.changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalChangeDisablesSync) {
   syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   TestingSettingsStorageFactory* testing_factory =
       new TestingSettingsStorageFactory();
   storage_factory_->Reset(testing_factory);
 
   SettingsStorage* good = AddExtensionAndGetStorage("good", type);
   SettingsStorage* bad = AddExtensionAndGetStorage("bad", type);
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, SyncDataList(), &sync_);
 
   // bad will fail to send changes.
-  good->Set("foo", fooValue);
+  good->Set(DEFAULTS, "foo", fooValue);
   sync_.SetFailAllRequests(true);
-  bad->Set("foo", fooValue);
+  bad->Set(DEFAULTS, "foo", fooValue);
   sync_.SetFailAllRequests(false);
 
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(1u, sync_.changes().size());
 
   // No further changes should be sent from bad.
   sync_.ClearChanges();
-  good->Set("foo", barValue);
-  bad->Set("foo", barValue);
+  good->Set(DEFAULTS, "foo", barValue);
+  bad->Set(DEFAULTS, "foo", barValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(1u, sync_.changes().size());
 
   // Changes from sync will be sent to good, not to bad.
   {
     SyncChangeList change_list;
     change_list.push_back(
@@ skipping 26 matching lines @@
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("good", "bar").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_ADD,
       sync_.GetOnlyChange("bad", "foo").change_type());
   EXPECT_EQ(3u, sync_.changes().size());
 
   sync_.ClearChanges();
-  good->Set("foo", fooValue);
-  bad->Set("foo", fooValue);
+  good->Set(DEFAULTS, "foo", fooValue);
+  bad->Set(DEFAULTS, "foo", fooValue);
 
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
       SyncChange::ACTION_UPDATE,
       sync_.GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(2u, sync_.changes().size());
 }
 
+TEST_F(ExtensionSettingsSyncTest,
+    LargeOutgoingChangeRejectedButIncomingAccepted) {

[not at google - send to devlin, 2011/11/17 07:02:53]

Change #4: another test

+  syncable::ModelType model_type = syncable::APP_SETTINGS;
+  Extension::Type type = Extension::TYPE_PACKAGED_APP;
+
+  // This value should be larger than the limit in settings_backend.cc.
+  std::string string_5k;
+  for (size_t i = 0; i < 5000; ++i) {
+    string_5k.append("a");
+  }
+  StringValue large_value(string_5k);
+
+  GetSyncableService(model_type)->MergeDataAndStartSyncing(
+      model_type, SyncDataList(), &sync_);
+
+  // Large local change rejected and doesn't get sent out.
+  SettingsStorage* storage1 = AddExtensionAndGetStorage("s1", type);
+  EXPECT_TRUE(storage1->Set(DEFAULTS, "large_value", large_value).HasError());
+  EXPECT_EQ(0u, sync_.changes().size());
+
+  // Large incoming change should still get accepted.
+  SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
+  {
+    SyncChangeList change_list;
+    change_list.push_back(
+        settings_sync_util::CreateAdd("s1", "large_value", large_value));
+    change_list.push_back(
+        settings_sync_util::CreateAdd("s2", "large_value", large_value));
+    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
+  }
+  {
+    DictionaryValue expected;
+    expected.Set("large_value", large_value.DeepCopy());
+    EXPECT_PRED_FORMAT2(SettingsEq, expected, storage1->Get());
+    EXPECT_PRED_FORMAT2(SettingsEq, expected, storage2->Get());
+  }
+
+  GetSyncableService(model_type)->StopSyncing(model_type);
+}
+
 }  // namespace extensions