Extend TwoClientExtensionSettingsSyncTest to test app settings.

chrome/browser/extensions/settings/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 "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 107 matching lines @@
     for (SettingSyncDataList::iterator it = changes_.begin();
         it != changes_.end(); ++it) {
       if (it->extension_id() == extension_id && it->key() == key) {
         matching_changes.push_back(*it);
       }
     }
     if (matching_changes.empty()) {
       ADD_FAILURE() << "No matching changes for " << extension_id << "/" <<
           key << " (out of " << changes_.size() << ")";
       return SettingSyncData(
-          SyncChange::ACTION_INVALID, "", "", new DictionaryValue());
+          SyncChange::ACTION_INVALID, "", "",
+          scoped_ptr<Value>(new DictionaryValue()));
     }
     if (matching_changes.size() != 1u) {
       ADD_FAILURE() << matching_changes.size() << " matching changes for " <<
            extension_id << "/" << key << " (out of " << changes_.size() << ")";
     }
     return matching_changes[0];
   }
 
  private:
   SettingSyncDataList changes_;
@@ skipping 140 matching lines @@
   std::map<std::string, SettingSyncDataList> all_sync_data =
       GetAllSyncData(model_type);
   EXPECT_EQ(2u, all_sync_data.size());
   EXPECT_EQ(1u, all_sync_data["s1"].size());
   EXPECT_PRED_FORMAT2(ValuesEq, &value1, &all_sync_data["s1"][0].value());
   EXPECT_EQ(1u, all_sync_data["s2"].size());
   EXPECT_PRED_FORMAT2(ValuesEq, &value2, &all_sync_data["s2"][0].value());
 
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
-      "s1", "foo", value1));
+      "s1", "foo", value1, model_type));
   sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2));
+      "s2", "bar", value2, model_type));
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, sync_data, &sync_);
 
   // Already in sync, so no changes.
   EXPECT_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(DEFAULTS, "foo", value1);
@@ skipping 48 matching lines @@
   // 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(DEFAULTS, "overwriteMe", value1);
 
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
-      "s1", "foo", value1));
+      "s1", "foo", value1, model_type));
   sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2));
+      "s2", "bar", value2, model_type));
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, sync_data, &sync_);
   expected1.Set("foo", value1.DeepCopy());
   expected2.Set("bar", value2.DeepCopy());
 
   SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
 
   // All changes should be local, so no sync changes.
   EXPECT_EQ(0u, sync_.changes().size());
 
@@ skipping 18 matching lines @@
 
   // Make storage1 initialised from local data, storage2 initialised from sync.
   SettingsStorage* storage1 = AddExtensionAndGetStorage("s1", type);
   SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
 
   storage1->Set(DEFAULTS, "foo", value1);
   expected1.Set("foo", value1.DeepCopy());
 
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2));
+      "s2", "bar", value2, model_type));
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, sync_data, &sync_);
   expected2.Set("bar", value2.DeepCopy());
 
   // Make sync add some settings.
   SyncChangeList change_list;
   change_list.push_back(settings_sync_util::CreateAdd(
-      "s1", "bar", value2));
+      "s1", "bar", value2, model_type));
   change_list.push_back(settings_sync_util::CreateAdd(
-      "s2", "foo", value1));
+      "s2", "foo", value1, model_type));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   expected1.Set("bar", value2.DeepCopy());
   expected2.Set("foo", value1.DeepCopy());
 
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   // Make sync update some settings, storage1 the new setting, storage2 the
   // initial setting.
   change_list.clear();
   change_list.push_back(settings_sync_util::CreateUpdate(
-      "s1", "bar", value2));
+      "s1", "bar", value2, model_type));
   change_list.push_back(settings_sync_util::CreateUpdate(
-      "s2", "bar", value1));
+      "s2", "bar", value1, model_type));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   expected1.Set("bar", value2.DeepCopy());
   expected2.Set("bar", value1.DeepCopy());
 
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   // Make sync remove some settings, storage1 the initial setting, storage2 the
   // new setting.
   change_list.clear();
   change_list.push_back(settings_sync_util::CreateDelete(
-      "s1", "foo"));
+      "s1", "foo", model_type));
   change_list.push_back(settings_sync_util::CreateDelete(
-      "s2", "foo"));
+      "s2", "foo", model_type));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   expected1.Remove("foo", NULL);
   expected2.Remove("foo", NULL);
 
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
@@ skipping 10 matching lines @@
   SettingsStorage* storage1 = AddExtensionAndGetStorage("s1", type);
   SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
   SettingsStorage* storage3 = AddExtensionAndGetStorage("s3", type);
   SettingsStorage* storage4 = AddExtensionAndGetStorage("s4", type);
 
   storage1->Set(DEFAULTS, "foo", value1);
   storage2->Set(DEFAULTS, "foo", value1);
 
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
-      "s3", "bar", value2));
+      "s3", "bar", value2, model_type));
   sync_data.push_back(settings_sync_util::CreateData(
-      "s4", "bar", value2));
+      "s4", "bar", value2, model_type));
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, sync_data, &sync_);
 
   // Add something locally.
   storage1->Set(DEFAULTS, "bar", value2);
   storage2->Set(DEFAULTS, "bar", value2);
   storage3->Set(DEFAULTS, "foo", value1);
   storage4->Set(DEFAULTS, "foo", value1);
 
@@ skipping 126 matching lines @@
 
   std::map<std::string, SettingSyncDataList> app_sync_data =
       GetAllSyncData(syncable::APP_SETTINGS);
   EXPECT_EQ(1u, app_sync_data.size());
   EXPECT_EQ(1u, app_sync_data["s2"].size());
   EXPECT_PRED_FORMAT2(ValuesEq, &value2, &app_sync_data["s2"][0].value());
 
   // Stop each separately, there should be no changes either time.
   SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
-      "s1", "foo", value1));
+      "s1", "foo", value1, syncable::EXTENSION_SETTINGS));
 
   GetSyncableService(syncable::EXTENSION_SETTINGS)->
       MergeDataAndStartSyncing(syncable::EXTENSION_SETTINGS, sync_data, &sync_);
   GetSyncableService(syncable::EXTENSION_SETTINGS)->
       StopSyncing(syncable::EXTENSION_SETTINGS);
   EXPECT_EQ(0u, sync_.changes().size());
 
   sync_data.clear();
   sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2));
+      "s2", "bar", value2, syncable::APP_SETTINGS));
 
   GetSyncableService(syncable::APP_SETTINGS)->
       MergeDataAndStartSyncing(syncable::APP_SETTINGS, sync_data, &sync_);
   GetSyncableService(syncable::APP_SETTINGS)->
       StopSyncing(syncable::APP_SETTINGS);
   EXPECT_EQ(0u, sync_.changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingStartSyncingDisablesSync) {
   syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue fooValue("fooValue");
   StringValue barValue("barValue");
 
   // There is a bit of a convoluted method to get storage areas that can fail;
   // hand out TestingSettingsStorage object then toggle them failing/succeeding
   // as necessary.
   TestingSettingsStorageFactory* testing_factory =
       new TestingSettingsStorageFactory();
   storage_factory_->Reset(testing_factory);
 
   SettingsStorage* good = AddExtensionAndGetStorage("good", type);
   SettingsStorage* bad = AddExtensionAndGetStorage("bad", type);
 
   // Make bad fail for incoming sync changes.
   testing_factory->GetExisting("bad")->SetFailAllRequests(true);
   {
     SyncDataList sync_data;
-    sync_data.push_back(
-        settings_sync_util::CreateData("good", "foo", fooValue));
-    sync_data.push_back(
-        settings_sync_util::CreateData("bad", "foo", fooValue));
+    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_);
   }
   testing_factory->GetExisting("bad")->SetFailAllRequests(false);
 
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
@@ skipping 21 matching lines @@
   {
     DictionaryValue dict;
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Changes received from sync should go to good but not bad (even when it's
   // not failing).
   {
     SyncChangeList change_list;
-    change_list.push_back(
-        settings_sync_util::CreateUpdate("good", "foo", barValue));
+    change_list.push_back(settings_sync_util::CreateUpdate(
+          "good", "foo", barValue, model_type));
     // (Sending UPDATE here even though it's adding, since that's what the state
     // of sync is.  In any case, it won't work.)
-    change_list.push_back(
-        settings_sync_util::CreateUpdate("bad", "foo", barValue));
+    change_list.push_back(settings_sync_util::CreateUpdate(
+          "bad", "foo", barValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
@@ skipping 22 matching lines @@
   {
     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);
   {
     SyncChangeList change_list;
-    change_list.push_back(
-        settings_sync_util::CreateUpdate("good", "foo", fooValue));
+    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));
+    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);
 
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     dict.Set("bar", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
@@ skipping 31 matching lines @@
       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.
   {
     SyncChangeList change_list;
-    change_list.push_back(
-        settings_sync_util::CreateUpdate("good", "bar", fooValue));
-    change_list.push_back(
-        settings_sync_util::CreateUpdate("bad", "bar", fooValue));
+    change_list.push_back(settings_sync_util::CreateUpdate(
+          "good", "bar", fooValue, model_type));
+    change_list.push_back(settings_sync_util::CreateUpdate(
+          "bad", "bar", fooValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     dict.Set("bar", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
@@ skipping 15 matching lines @@
   TestingSettingsStorageFactory* testing_factory =
       new TestingSettingsStorageFactory();
   storage_factory_->Reset(testing_factory);
 
   SettingsStorage* good = AddExtensionAndGetStorage("good", type);
   SettingsStorage* bad = AddExtensionAndGetStorage("bad", type);
 
   // Unlike before, initially succeeding MergeDataAndStartSyncing.
   {
     SyncDataList sync_data;
-    sync_data.push_back(
-        settings_sync_util::CreateData("good", "foo", fooValue));
-    sync_data.push_back(
-        settings_sync_util::CreateData("bad", "foo", fooValue));
+    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_);
   }
 
   EXPECT_EQ(0u, sync_.changes().size());
 
   {
     DictionaryValue dict;
     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);
   {
     SyncChangeList change_list;
-    change_list.push_back(
-        settings_sync_util::CreateAdd("good", "bar", barValue));
-    change_list.push_back(
-        settings_sync_util::CreateAdd("bad", "bar", barValue));
+    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);
 
   {
     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());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // No more changes sent to sync for bad.
   sync_.ClearChanges();
   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(
-        settings_sync_util::CreateAdd("good", "foo", fooValue));
-    change_list.push_back(
-        settings_sync_util::CreateAdd("bad", "foo", fooValue));
+    change_list.push_back(settings_sync_util::CreateAdd(
+          "good", "foo", fooValue, model_type));
+    change_list.push_back(settings_sync_util::CreateAdd(
+          "bad", "foo", fooValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
@@ skipping 90 matching lines @@
   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));
+    change_list.push_back(settings_sync_util::CreateUpdate(
+          "good", "foo", barValue, model_type));
     // (Sending ADD here even though it's updating, since that's what the state
     // of sync is.  In any case, it won't work.)
-    change_list.push_back(
-        settings_sync_util::CreateAdd("bad", "foo", barValue));
+    change_list.push_back(settings_sync_util::CreateAdd(
+          "bad", "foo", barValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
@@ skipping 65 matching lines @@
   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(
-        settings_sync_util::CreateAdd("good", "bar", barValue));
-    change_list.push_back(
-        settings_sync_util::CreateAdd("bad", "bar", barValue));
+    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);
   }
 
   {
     DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
@@ skipping 66 matching lines @@
   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(
-        settings_sync_util::CreateAdd("good", "bar", barValue));
-    change_list.push_back(
-        settings_sync_util::CreateAdd("bad", "bar", barValue));
+    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);
   }
 
   {
     DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
@@ skipping 49 matching lines @@
 
   // 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));
+    change_list.push_back(settings_sync_util::CreateAdd(
+          "s1", "large_value", large_value, model_type));
+    change_list.push_back(settings_sync_util::CreateAdd(
+          "s2", "large_value", large_value, model_type));
     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