Remove dependency of PrefSyncableService on Profile.

chrome/browser/prefs/pref_model_associator_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.

[gab, 2015/09/10 14:15:09]

Not sure why this file is marked 'D' by reitveld?!

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/test/base/testing_profile.h"
-#include "content/public/test/test_browser_thread_bundle.h"
+#include "chrome/browser/prefs/pref_model_associator_client.h"
+#include "chrome/browser/prefs/pref_service_mock_factory.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/browser/prefs/pref_service_syncable_factory.h"
+#include "components/pref_registry/pref_registry_syncable.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-// Any content settings pref name should do for these tests.
-const char* kContentSettingsPrefName =
-    "profile.content_settings.exceptions.cookies";
+namespace {
+
+const char kStringPrefName[] = "string_pref";
+const char kListPrefName[] = "list_pref";
+const char kDictionaryPrefName[] = "dictionary_pref";
+
+}  // namespace
 
 class AbstractPreferenceMergeTest : public testing::Test {
  protected:
-  void SetUp() override { pref_service_ = profile_.GetPrefs(); }
+  AbstractPreferenceMergeTest() {
+    pref_model_associator_client_.RegisterPreference(
+        kListPrefName, PREF_MODEL_PREFERENCE_TYPE_LIST);
+    pref_model_associator_client_.RegisterPreference(
+        kDictionaryPrefName, PREF_MODEL_PREFERENCE_TYPE_DICT);
+
+    PrefServiceMockFactory factory;
+    factory.SetPrefModelAssociatorClient(&pref_model_associator_client_);
+    scoped_refptr<user_prefs::PrefRegistrySyncable> pref_registry(
+        new user_prefs::PrefRegistrySyncable);
+    pref_service_ = factory.CreateSyncable(pref_registry.get());

[gab, 2015/09/10 14:15:09]

We're trying to move towards a world where all registrations happen first and
then ownership of the PrefRegistry is handed to |PrefService| (i.e. no dynamic
registration).

In that light, please make all registrations before creating the PrefService.

+
+    pref_registry->RegisterStringPref(
+        kStringPrefName, std::string(),
+        user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+    pref_registry->RegisterListPref(
+        kListPrefName,
+        user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+    pref_registry->RegisterDictionaryPref(
+        kDictionaryPrefName,
+        user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  }
 
   void SetContentPattern(base::DictionaryValue* patterns_dict,
                          const std::string& expression,
                          int setting) {
     base::DictionaryValue* expression_dict;
-    bool found =
-        patterns_dict->GetDictionaryWithoutPathExpansion(expression,
-                                                         &expression_dict);
+    bool found = patterns_dict->GetDictionaryWithoutPathExpansion(
+        expression, &expression_dict);
     if (!found) {
       expression_dict = new base::DictionaryValue;
       patterns_dict->SetWithoutPathExpansion(expression, expression_dict);
     }
     expression_dict->SetWithoutPathExpansion(
         "setting", new base::FundamentalValue(setting));
   }
 
   void SetPrefToEmpty(const std::string& pref_name) {
     scoped_ptr<base::Value> empty_value;
     const PrefService::Preference* pref =
         pref_service_->FindPreference(pref_name.c_str());
     ASSERT_TRUE(pref);
     base::Value::Type type = pref->GetType();
     if (type == base::Value::TYPE_DICTIONARY)
       empty_value.reset(new base::DictionaryValue);
     else if (type == base::Value::TYPE_LIST)
       empty_value.reset(new base::ListValue);
     else
       FAIL();
     pref_service_->Set(pref_name.c_str(), *empty_value);
   }
 
-  content::TestBrowserThreadBundle thread_bundle_;
-  TestingProfile profile_;
-  PrefService* pref_service_;
+  PrefModelAssociatorClient pref_model_associator_client_;
+  scoped_ptr<PrefServiceSyncable> pref_service_;
 };
 
 class ListPreferenceMergeTest : public AbstractPreferenceMergeTest {
  protected:
-  ListPreferenceMergeTest() :
-      server_url0_("http://example.com/server0"),
-      server_url1_("http://example.com/server1"),
-      local_url0_("http://example.com/local0"),
-      local_url1_("http://example.com/local1") {}
+  ListPreferenceMergeTest()
+      : server_url0_("http://example.com/server0"),
+        server_url1_("http://example.com/server1"),
+        local_url0_("http://example.com/local0"),
+        local_url1_("http://example.com/local1") {}
 
   void SetUp() override {
     AbstractPreferenceMergeTest::SetUp();
     server_url_list_.Append(new base::StringValue(server_url0_));
     server_url_list_.Append(new base::StringValue(server_url1_));
   }
 
   std::string server_url0_;
   std::string server_url1_;
   std::string local_url0_;
   std::string local_url1_;
   base::ListValue server_url_list_;
 };
 
 TEST_F(ListPreferenceMergeTest, NotListOrDictionary) {
-  pref_service_->SetString(prefs::kHomePage, local_url0_);
+  pref_service_->SetString(kStringPrefName, local_url0_);
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kHomePage);
+      pref_service_->FindPreference(kStringPrefName);
   scoped_ptr<base::Value> server_value(new base::StringValue(server_url0_));
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           *server_value));
+                                           *server_value,
+                                           &pref_model_associator_client_));
   EXPECT_TRUE(merged_value->Equals(server_value.get()));
 }
 
 TEST_F(ListPreferenceMergeTest, LocalEmpty) {
-  SetPrefToEmpty(prefs::kURLsToRestoreOnStartup);
+  SetPrefToEmpty(kListPrefName);
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
+      pref_service_->FindPreference(kListPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           server_url_list_));
+                                           server_url_list_,
+                                           &pref_model_associator_client_));
   EXPECT_TRUE(merged_value->Equals(&server_url_list_));
 }
 
 TEST_F(ListPreferenceMergeTest, ServerNull) {
   scoped_ptr<base::Value> null_value = base::Value::CreateNullValue();
   {
-    ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
+    ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
     local_list_value->Append(new base::StringValue(local_url0_));
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
+      pref_service_->FindPreference(kListPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           *null_value));
+                                           *null_value,
+                                           &pref_model_associator_client_));
   const base::ListValue* local_list_value =
-        pref_service_->GetList(prefs::kURLsToRestoreOnStartup);
+      pref_service_->GetList(kListPrefName);
   EXPECT_TRUE(merged_value->Equals(local_list_value));
 }
 
 TEST_F(ListPreferenceMergeTest, ServerEmpty) {
   scoped_ptr<base::Value> empty_value(new base::ListValue);
   {
-    ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
+    ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
     local_list_value->Append(new base::StringValue(local_url0_));
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
+      pref_service_->FindPreference(kListPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           *empty_value));
+                                           *empty_value,
+                                           &pref_model_associator_client_));
   const base::ListValue* local_list_value =
-        pref_service_->GetList(prefs::kURLsToRestoreOnStartup);
+      pref_service_->GetList(kListPrefName);
   EXPECT_TRUE(merged_value->Equals(local_list_value));
 }
 
 TEST_F(ListPreferenceMergeTest, Merge) {
   {
-    ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
+    ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
     local_list_value->Append(new base::StringValue(local_url0_));
     local_list_value->Append(new base::StringValue(local_url1_));
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
+      pref_service_->FindPreference(kListPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           server_url_list_));
+                                           server_url_list_,
+                                           &pref_model_associator_client_));
 
   base::ListValue expected;
   expected.Append(new base::StringValue(server_url0_));
   expected.Append(new base::StringValue(server_url1_));
   expected.Append(new base::StringValue(local_url0_));
   expected.Append(new base::StringValue(local_url1_));
   EXPECT_TRUE(merged_value->Equals(&expected));
 }
 
 TEST_F(ListPreferenceMergeTest, Duplicates) {
   {
-    ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
+    ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
     local_list_value->Append(new base::StringValue(local_url0_));
     local_list_value->Append(new base::StringValue(server_url0_));
     local_list_value->Append(new base::StringValue(server_url1_));
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
+      pref_service_->FindPreference(kListPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           server_url_list_));
+                                           server_url_list_,
+                                           &pref_model_associator_client_));
 
   base::ListValue expected;
   expected.Append(new base::StringValue(server_url0_));
   expected.Append(new base::StringValue(server_url1_));
   expected.Append(new base::StringValue(local_url0_));
   EXPECT_TRUE(merged_value->Equals(&expected));
 }
 
 TEST_F(ListPreferenceMergeTest, Equals) {
   {
-    ListPrefUpdate update(pref_service_, prefs::kURLsToRestoreOnStartup);
+    ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
     local_list_value->Append(new base::StringValue(server_url0_));
     local_list_value->Append(new base::StringValue(server_url1_));
   }
 
   scoped_ptr<base::Value> original(server_url_list_.DeepCopy());
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kURLsToRestoreOnStartup);
-  scoped_ptr<base::Value> merged_value(
-      PrefModelAssociator::MergePreference(pref->name(),
-                                           *pref->GetValue(),
-                                           server_url_list_));
+      pref_service_->FindPreference(kListPrefName);
+  scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
+      pref->name(), *pref->GetValue(), server_url_list_,
+      &pref_model_associator_client_));
   EXPECT_TRUE(merged_value->Equals(original.get()));
 }
 
 class DictionaryPreferenceMergeTest : public AbstractPreferenceMergeTest {
  protected:
-  DictionaryPreferenceMergeTest() :
-      expression0_("expression0"),
-      expression1_("expression1"),
-      expression2_("expression2"),
-      expression3_("expression3"),
-      expression4_("expression4") {}
+  DictionaryPreferenceMergeTest()
+      : expression0_("expression0"),
+        expression1_("expression1"),
+        expression2_("expression2"),
+        expression3_("expression3"),
+        expression4_("expression4") {}
 
   void SetUp() override {
     AbstractPreferenceMergeTest::SetUp();
     SetContentPattern(&server_patterns_, expression0_, 1);
     SetContentPattern(&server_patterns_, expression1_, 2);
     SetContentPattern(&server_patterns_, expression2_, 1);
   }
 
   std::string expression0_;
   std::string expression1_;
   std::string expression2_;
   std::string expression3_;
   std::string expression4_;
   base::DictionaryValue server_patterns_;
 };
 
 TEST_F(DictionaryPreferenceMergeTest, LocalEmpty) {
-  SetPrefToEmpty(kContentSettingsPrefName);
+  SetPrefToEmpty(kDictionaryPrefName);
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(kContentSettingsPrefName);
+      pref_service_->FindPreference(kDictionaryPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           server_patterns_));
+                                           server_patterns_,
+                                           &pref_model_associator_client_));
   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, ServerNull) {
   scoped_ptr<base::Value> null_value = base::Value::CreateNullValue();
   {
-    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
+    DictionaryPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(kContentSettingsPrefName);
+      pref_service_->FindPreference(kDictionaryPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           *null_value));
+                                           *null_value,
+                                           &pref_model_associator_client_));
   const base::DictionaryValue* local_dict_value =
-      pref_service_->GetDictionary(kContentSettingsPrefName);
+      pref_service_->GetDictionary(kDictionaryPrefName);
   EXPECT_TRUE(merged_value->Equals(local_dict_value));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, ServerEmpty) {
   scoped_ptr<base::Value> empty_value(new base::DictionaryValue);
   {
-    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
+    DictionaryPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(kContentSettingsPrefName);
+      pref_service_->FindPreference(kDictionaryPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
-                                           *empty_value));
+                                           *empty_value,
+                                           &pref_model_associator_client_));
   const base::DictionaryValue* local_dict_value =
-      pref_service_->GetDictionary(kContentSettingsPrefName);
+      pref_service_->GetDictionary(kDictionaryPrefName);
   EXPECT_TRUE(merged_value->Equals(local_dict_value));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, MergeNoConflicts) {
   {
-    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
+    DictionaryPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-      kContentSettingsPrefName,
-      *pref_service_->FindPreference(kContentSettingsPrefName)->GetValue(),
-      server_patterns_));
+      kDictionaryPrefName,
+      *pref_service_->FindPreference(kDictionaryPrefName)->GetValue(),
+      server_patterns_,
+      &pref_model_associator_client_));
 
   base::DictionaryValue expected;
   SetContentPattern(&expected, expression0_, 1);
   SetContentPattern(&expected, expression1_, 2);
   SetContentPattern(&expected, expression2_, 1);
   SetContentPattern(&expected, expression3_, 1);
   EXPECT_TRUE(merged_value->Equals(&expected));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, MergeConflicts) {
   {
-    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
+    DictionaryPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression0_, 2);
     SetContentPattern(local_dict_value, expression2_, 1);
     SetContentPattern(local_dict_value, expression3_, 1);
     SetContentPattern(local_dict_value, expression4_, 2);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-      kContentSettingsPrefName,
-      *pref_service_->FindPreference(kContentSettingsPrefName)->GetValue(),
-      server_patterns_));
+      kDictionaryPrefName,
+      *pref_service_->FindPreference(kDictionaryPrefName)->GetValue(),
+      server_patterns_,
+      &pref_model_associator_client_));
 
   base::DictionaryValue expected;
   SetContentPattern(&expected, expression0_, 1);
   SetContentPattern(&expected, expression1_, 2);
   SetContentPattern(&expected, expression2_, 1);
   SetContentPattern(&expected, expression3_, 1);
   SetContentPattern(&expected, expression4_, 2);
   EXPECT_TRUE(merged_value->Equals(&expected));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, MergeValueToDictionary) {
   base::DictionaryValue local_dict_value;
   local_dict_value.SetInteger("key", 0);
 
   base::DictionaryValue server_dict_value;
   server_dict_value.SetInteger("key.subkey", 0);
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-      kContentSettingsPrefName,
+      kDictionaryPrefName,
       local_dict_value,
-      server_dict_value));
+      server_dict_value,
+      &pref_model_associator_client_));
 
   EXPECT_TRUE(merged_value->Equals(&server_dict_value));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, Equal) {
   {
-    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
+    DictionaryPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression0_, 1);
     SetContentPattern(local_dict_value, expression1_, 2);
     SetContentPattern(local_dict_value, expression2_, 1);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-      kContentSettingsPrefName,
-      *pref_service_->FindPreference(kContentSettingsPrefName)->GetValue(),
-      server_patterns_));
+      kDictionaryPrefName,
+      *pref_service_->FindPreference(kDictionaryPrefName)->GetValue(),
+      server_patterns_,
+      &pref_model_associator_client_));
   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, ConflictButServerWins) {
   {
-    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
+    DictionaryPrefUpdate update(pref_service_.get(), kDictionaryPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression0_, 2);
     SetContentPattern(local_dict_value, expression1_, 2);
     SetContentPattern(local_dict_value, expression2_, 1);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-      kContentSettingsPrefName,
-      *pref_service_->FindPreference(kContentSettingsPrefName)->GetValue(),
-      server_patterns_));
+      kDictionaryPrefName,
+      *pref_service_->FindPreference(kDictionaryPrefName)->GetValue(),
+      server_patterns_,
+      &pref_model_associator_client_));
   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 }
 
 class IndividualPreferenceMergeTest : public AbstractPreferenceMergeTest {
  protected:
-  IndividualPreferenceMergeTest() :
-      url0_("http://example.com/server0"),
-      url1_("http://example.com/server1"),
-      expression0_("expression0"),
-      expression1_("expression1") {}
+  IndividualPreferenceMergeTest()
+      : url0_("http://example.com/server0"),
+        url1_("http://example.com/server1"),
+        expression0_("expression0"),
+        expression1_("expression1") {}
 
   void SetUp() override {
     AbstractPreferenceMergeTest::SetUp();
     server_url_list_.Append(new base::StringValue(url0_));
     SetContentPattern(&server_patterns_, expression0_, 1);
   }
 
   bool MergeListPreference(const char* pref) {
     {
-      ListPrefUpdate update(pref_service_, pref);
+      ListPrefUpdate update(pref_service_.get(), pref);
       base::ListValue* local_list_value = update.Get();
       local_list_value->Append(new base::StringValue(url1_));
     }
 
     scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
         pref,
         *pref_service_->GetUserPrefValue(pref),
-        server_url_list_));
+        server_url_list_,
+        &pref_model_associator_client_));
 
     base::ListValue expected;
     expected.Append(new base::StringValue(url0_));
     expected.Append(new base::StringValue(url1_));
     return merged_value->Equals(&expected);
   }
 
   bool MergeDictionaryPreference(const char* pref) {
     {
-      DictionaryPrefUpdate update(pref_service_, pref);
+      DictionaryPrefUpdate update(pref_service_.get(), pref);
       base::DictionaryValue* local_dict_value = update.Get();
       SetContentPattern(local_dict_value, expression1_, 1);
     }
 
     scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
         pref,
         *pref_service_->GetUserPrefValue(pref),
-        server_patterns_));
+        server_patterns_,
+        &pref_model_associator_client_));
 
     base::DictionaryValue expected;
     SetContentPattern(&expected, expression0_, 1);
     SetContentPattern(&expected, expression1_, 1);
     return merged_value->Equals(&expected);
   }
 
   std::string url0_;
   std::string url1_;
   std::string expression0_;
   std::string expression1_;
   std::string content_type0_;
   base::ListValue server_url_list_;
   base::DictionaryValue server_patterns_;
 };
 
 TEST_F(IndividualPreferenceMergeTest, URLsToRestoreOnStartup) {

[gab, 2015/09/10 14:15:09]

Change name of this test to reflect its new generic nature.

-  EXPECT_TRUE(MergeListPreference(prefs::kURLsToRestoreOnStartup));
+  EXPECT_TRUE(MergeListPreference(kListPrefName));
 }