Extension Settings API: move the API functions into an object SettingsNamepace,

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 144 matching lines @@
   // SettingsStorageFactory implementation.
   virtual SettingsStorage* Create(
       const FilePath& base_path, const std::string& extension_id) OVERRIDE {
     TestingSettingsStorage* new_storage = new TestingSettingsStorage();
     DCHECK(!created_.count(extension_id));
     created_[extension_id] = new_storage;
     return new_storage;
   }
 
  private:
+  // SettingsStorageFactory is refcounted.
+  virtual ~TestingSettingsStorageFactory() {}
+
   // None of these storage areas are owned by this factory, so care must be
   // taken when calling GetExisting.
   std::map<std::string, TestingSettingsStorage*> created_;
 };
 
 void AssignSettingsService(SyncableService** dst, SyncableService* src) {
   *dst = src;
 }
 
 }  // namespace
 
 class ExtensionSettingsSyncTest : public testing::Test {
  public:
   ExtensionSettingsSyncTest()
       : ui_thread_(BrowserThread::UI, MessageLoop::current()),
-        file_thread_(BrowserThread::FILE, MessageLoop::current()) {}
+        file_thread_(BrowserThread::FILE, MessageLoop::current()),
+        storage_factory_(new ScopedSettingsStorageFactory()) {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     profile_.reset(new MockProfile(temp_dir_.path()));
-    storage_factory_ =
-        new ScopedSettingsStorageFactory(new SettingsLeveldbStorage::Factory());
-    frontend_.reset(SettingsFrontend::Create(storage_factory_, profile_.get()));
+    storage_factory_->Reset(new SettingsLeveldbStorage::Factory());
+    frontend_.reset(
+        SettingsFrontend::Create(storage_factory_.get(), profile_.get()));
   }
 
   virtual void TearDown() OVERRIDE {
     frontend_.reset();
     profile_.reset();
   }
 
  protected:
   // Adds a record of an extension or app to the extension service, then returns
   // its storage area.
@@ skipping 29 matching lines @@
 
   // Need these so that the DCHECKs for running on FILE or UI threads pass.
   MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   ScopedTempDir temp_dir_;
   MockSyncChangeProcessor sync_;
   scoped_ptr<MockProfile> profile_;
   scoped_ptr<SettingsFrontend> frontend_;
-
-  // Owned by |frontend_|.
-  ScopedSettingsStorageFactory* storage_factory_;
+  scoped_refptr<ScopedSettingsStorageFactory> storage_factory_;
 };
 
 // Get a semblance of coverage for both EXTENSION_SETTINGS and APP_SETTINGS
 // sync by roughly alternative which one to test.
 
 TEST_F(ExtensionSettingsSyncTest, NoDataDoesNotInvokeSync) {
   syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
-  ASSERT_EQ(0u, GetAllSyncData(model_type).size());
+  EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   // Have one extension created before sync is set up, the other created after.
   AddExtensionAndGetStorage("s1", type);
-  ASSERT_EQ(0u, GetAllSyncData(model_type).size());
+  EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type, SyncDataList(), &sync_);
 
   AddExtensionAndGetStorage("s2", type);
-  ASSERT_EQ(0u, GetAllSyncData(model_type).size());
+  EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 
-  ASSERT_EQ(0u, sync_.changes().size());
-  ASSERT_EQ(0u, GetAllSyncData(model_type).size());
+  EXPECT_EQ(0u, sync_.changes().size());
+  EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, InSyncDataDoesNotInvokeSync) {
   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(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());
+  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));
   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());
+  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);
-  ASSERT_EQ(0u, sync_.changes().size());
+  EXPECT_EQ(0u, sync_.changes().size());
 
   storage1->Set(DEFAULTS, "foo", value2);
-  ASSERT_EQ(1u, sync_.changes().size());
+  EXPECT_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()));
+  EXPECT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
+  EXPECT_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(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());
+  EXPECT_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()));
+  EXPECT_EQ(SyncChange::ACTION_ADD, change.change_type());
+  EXPECT_TRUE(value1.Equals(&change.value()));
   change = sync_.GetOnlyChange("s2", "bar");
-  ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
-  ASSERT_TRUE(value2.Equals(&change.value()));
+  EXPECT_EQ(SyncChange::ACTION_ADD, change.change_type());
+  EXPECT_TRUE(value2.Equals(&change.value()));
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, AnySyncDataOverwritesLocalData) {
   syncable::ModelType model_type = syncable::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue value1("fooValue");
   ListValue value2;
@@ skipping 13 matching lines @@
   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());
 
   SettingsStorage* storage2 = AddExtensionAndGetStorage("s2", type);
 
   // All changes should be local, so no sync changes.
-  ASSERT_EQ(0u, sync_.changes().size());
+  EXPECT_EQ(0u, sync_.changes().size());
 
   // Sync settings should have been pushed to local settings.
-  ASSERT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
-  ASSERT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+  EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
+  EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, ProcessSyncChanges) {
   syncable::ModelType model_type = syncable::EXTENSION_SETTINGS;
   Extension::Type type = Extension::TYPE_EXTENSION;
 
   StringValue value1("fooValue");
   ListValue value2;
@@ skipping 21 matching lines @@
   // Make sync add some settings.
   SyncChangeList change_list;
   change_list.push_back(settings_sync_util::CreateAdd(
       "s1", "bar", value2));
   change_list.push_back(settings_sync_util::CreateAdd(
       "s2", "foo", value1));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   expected1.Set("bar", value2.DeepCopy());
   expected2.Set("foo", value1.DeepCopy());
 
-  ASSERT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
-  ASSERT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+  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));
   change_list.push_back(settings_sync_util::CreateUpdate(
       "s2", "bar", value1));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   expected1.Set("bar", value2.DeepCopy());
   expected2.Set("bar", value1.DeepCopy());
 
-  ASSERT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
-  ASSERT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+  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"));
   change_list.push_back(settings_sync_util::CreateDelete(
       "s2", "foo"));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   expected1.Remove("foo", NULL);
   expected2.Remove("foo", NULL);
 
-  ASSERT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
-  ASSERT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+  EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
+  EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, PushToSync) {
   syncable::ModelType model_type = syncable::APP_SETTINGS;
   Extension::Type type = Extension::TYPE_PACKAGED_APP;
 
   StringValue value1("fooValue");
   ListValue value2;
@@ skipping 18 matching lines @@
   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);
 
   SettingSyncData change = sync_.GetOnlyChange("s1", "bar");
-    ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
-    ASSERT_TRUE(value2.Equals(&change.value()));
+    EXPECT_EQ(SyncChange::ACTION_ADD, change.change_type());
+    EXPECT_TRUE(value2.Equals(&change.value()));
   sync_.GetOnlyChange("s2", "bar");
-    ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
-    ASSERT_TRUE(value2.Equals(&change.value()));
+    EXPECT_EQ(SyncChange::ACTION_ADD, change.change_type());
+    EXPECT_TRUE(value2.Equals(&change.value()));
   change = sync_.GetOnlyChange("s3", "foo");
-    ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
-    ASSERT_TRUE(value1.Equals(&change.value()));
+    EXPECT_EQ(SyncChange::ACTION_ADD, change.change_type());
+    EXPECT_TRUE(value1.Equals(&change.value()));
   change = sync_.GetOnlyChange("s4", "foo");
-    ASSERT_EQ(SyncChange::ACTION_ADD, change.change_type());
-    ASSERT_TRUE(value1.Equals(&change.value()));
+    EXPECT_EQ(SyncChange::ACTION_ADD, change.change_type());
+    EXPECT_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(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()));
+    EXPECT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
+    EXPECT_TRUE(value1.Equals(&change.value()));
   change = sync_.GetOnlyChange("s2", "foo");
-    ASSERT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
-    ASSERT_TRUE(value2.Equals(&change.value()));
+    EXPECT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
+    EXPECT_TRUE(value2.Equals(&change.value()));
   change = sync_.GetOnlyChange("s3", "bar");
-    ASSERT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
-    ASSERT_TRUE(value1.Equals(&change.value()));
+    EXPECT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
+    EXPECT_TRUE(value1.Equals(&change.value()));
   change = sync_.GetOnlyChange("s4", "foo");
-    ASSERT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
-    ASSERT_TRUE(value2.Equals(&change.value()));
+    EXPECT_EQ(SyncChange::ACTION_UPDATE, change.change_type());
+    EXPECT_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");
 
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s1", "foo").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s2", "bar").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s3", "foo").change_type());
-  ASSERT_EQ(
+  EXPECT_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");
 
-  ASSERT_EQ(0u, sync_.changes().size());
+  EXPECT_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(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();
 
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s1", "foo").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s1", "bar").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s2", "foo").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s2", "bar").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s3", "foo").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s3", "bar").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s4", "foo").change_type());
-  ASSERT_EQ(
+  EXPECT_EQ(
       SyncChange::ACTION_DELETE,
       sync_.GetOnlyChange("s4", "bar").change_type());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, ExtensionAndAppSettingsSyncSeparately) {
   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(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());
+  EXPECT_EQ(1u, extension_sync_data.size());
+  EXPECT_EQ(1u, extension_sync_data["s1"].size());
+  EXPECT_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());
-  ASSERT_EQ(1u, app_sync_data["s2"].size());
-  ASSERT_PRED_FORMAT2(ValuesEq, &value2, &app_sync_data["s2"][0].value());
+  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));
 
   GetSyncableService(syncable::EXTENSION_SETTINGS)->
       MergeDataAndStartSyncing(syncable::EXTENSION_SETTINGS, sync_data, &sync_);
   GetSyncableService(syncable::EXTENSION_SETTINGS)->
       StopSyncing(syncable::EXTENSION_SETTINGS);
-  ASSERT_EQ(0u, sync_.changes().size());
+  EXPECT_EQ(0u, sync_.changes().size());
 
   sync_data.clear();
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2));
 
   GetSyncableService(syncable::APP_SETTINGS)->
       MergeDataAndStartSyncing(syncable::APP_SETTINGS, sync_data, &sync_);
   GetSyncableService(syncable::APP_SETTINGS)->
       StopSyncing(syncable::APP_SETTINGS);
-  ASSERT_EQ(0u, sync_.changes().size());
+  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;
@@ skipping 634 matching lines @@
     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