Add user_prefs::TestPrefServiceSyncable

chrome/browser/search_engines/template_url_prepopulate_data_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/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_prepopulate_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
-#include "chrome/test/base/testing_pref_service_syncable.h"
-#include "chrome/test/base/testing_profile.h"
 #include "components/google/core/browser/google_switches.h"
+#include "components/pref_registry/testing_pref_service_syncable.h"
 #include "components/search_engines/prepopulated_engines.h"
 #include "components/search_engines/search_terms_data.h"
 #include "grit/generated_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::ASCIIToUTF16;
 
 namespace {
 
 SearchEngineType GetEngineType(const std::string& url) {
   TemplateURLData data;
   data.SetURL(url);
   return TemplateURLPrepopulateData::GetEngineType(TemplateURL(data),
                                                    SearchTermsData());
 }
 
 std::string GetHostFromTemplateURLData(const TemplateURLData& data) {
   return TemplateURL(data).url_ref().GetHost(SearchTermsData());
 }
 
 }  // namespace
 
-typedef testing::Test TemplateURLPrepopulateDataTest;
+class TemplateURLPrepopulateDataTest : public testing::Test {
+ public:
+  virtual void SetUp() OVERRIDE {
+    TemplateURLPrepopulateData::RegisterProfilePrefs(prefs_.registry());
+  }
+
+ protected:
+  user_prefs::TestingPrefServiceSyncable prefs_;
+};
 
 // Verifies the set of prepopulate data doesn't contain entries with duplicate
 // ids.
-TEST(TemplateURLPrepopulateDataTest, UniqueIDs) {
+TEST_F(TemplateURLPrepopulateDataTest, UniqueIDs) {
   const int kCountryIds[] = {
       'A'<<8|'D', 'A'<<8|'E', 'A'<<8|'F', 'A'<<8|'G', 'A'<<8|'I',
       'A'<<8|'L', 'A'<<8|'M', 'A'<<8|'N', 'A'<<8|'O', 'A'<<8|'Q',
       'A'<<8|'R', 'A'<<8|'S', 'A'<<8|'T', 'A'<<8|'U', 'A'<<8|'W',
       'A'<<8|'X', 'A'<<8|'Z', 'B'<<8|'A', 'B'<<8|'B', 'B'<<8|'D',
       'B'<<8|'E', 'B'<<8|'F', 'B'<<8|'G', 'B'<<8|'H', 'B'<<8|'I',
       'B'<<8|'J', 'B'<<8|'M', 'B'<<8|'N', 'B'<<8|'O', 'B'<<8|'R',
       'B'<<8|'S', 'B'<<8|'T', 'B'<<8|'V', 'B'<<8|'W', 'B'<<8|'Y',
       'B'<<8|'Z', 'C'<<8|'A', 'C'<<8|'C', 'C'<<8|'D', 'C'<<8|'F',
       'C'<<8|'G', 'C'<<8|'H', 'C'<<8|'I', 'C'<<8|'K', 'C'<<8|'L',
@@ skipping 31 matching lines @@
       'S'<<8|'M', 'S'<<8|'N', 'S'<<8|'O', 'S'<<8|'R', 'S'<<8|'T',
       'S'<<8|'V', 'S'<<8|'Y', 'S'<<8|'Z', 'T'<<8|'C', 'T'<<8|'D',
       'T'<<8|'F', 'T'<<8|'G', 'T'<<8|'H', 'T'<<8|'J', 'T'<<8|'K',
       'T'<<8|'L', 'T'<<8|'M', 'T'<<8|'N', 'T'<<8|'O', 'T'<<8|'R',
       'T'<<8|'T', 'T'<<8|'V', 'T'<<8|'W', 'T'<<8|'Z', 'U'<<8|'A',
       'U'<<8|'G', 'U'<<8|'M', 'U'<<8|'S', 'U'<<8|'Y', 'U'<<8|'Z',
       'V'<<8|'A', 'V'<<8|'C', 'V'<<8|'E', 'V'<<8|'G', 'V'<<8|'I',
       'V'<<8|'N', 'V'<<8|'U', 'W'<<8|'F', 'W'<<8|'S', 'Y'<<8|'E',
       'Y'<<8|'T', 'Z'<<8|'A', 'Z'<<8|'M', 'Z'<<8|'W', -1 };
 
-  TestingProfile profile;
   for (size_t i = 0; i < arraysize(kCountryIds); ++i) {
-    profile.GetPrefs()->SetInteger(prefs::kCountryIDAtInstall, kCountryIds[i]);
+    prefs_.SetInteger(prefs::kCountryIDAtInstall, kCountryIds[i]);
     size_t default_index;
     ScopedVector<TemplateURLData> urls =
-        TemplateURLPrepopulateData::GetPrepopulatedEngines(profile.GetPrefs(),
+        TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
                                                            &default_index);
     std::set<int> unique_ids;
     for (size_t turl_i = 0; turl_i < urls.size(); ++turl_i) {
       ASSERT_TRUE(unique_ids.find(urls[turl_i]->prepopulate_id) ==
                   unique_ids.end());
       unique_ids.insert(urls[turl_i]->prepopulate_id);
     }
   }
 }
 
 // Verifies that default search providers from the preferences file
 // override the built-in ones.
-TEST(TemplateURLPrepopulateDataTest, ProvidersFromPrefs) {
-  TestingProfile profile;
-  TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
-  prefs->SetUserPref(prefs::kSearchProviderOverridesVersion,
+TEST_F(TemplateURLPrepopulateDataTest, ProvidersFromPrefs) {
+  prefs_.SetUserPref(prefs::kSearchProviderOverridesVersion,
                      base::Value::CreateIntegerValue(1));
   base::ListValue* overrides = new base::ListValue;
   scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
   // Set only the minimal required settings for a search provider configuration.
   entry->SetString("name", "foo");
   entry->SetString("keyword", "fook");
   entry->SetString("search_url", "http://foo.com/s?q={searchTerms}");
   entry->SetString("favicon_url", "http://foi.com/favicon.ico");
   entry->SetString("encoding", "UTF-8");
   entry->SetInteger("id", 1001);
   overrides->Append(entry->DeepCopy());
-  prefs->SetUserPref(prefs::kSearchProviderOverrides, overrides);
+  prefs_.SetUserPref(prefs::kSearchProviderOverrides, overrides);
 
-  int version = TemplateURLPrepopulateData::GetDataVersion(prefs);
+  int version = TemplateURLPrepopulateData::GetDataVersion(&prefs_);
   EXPECT_EQ(1, version);
 
   size_t default_index;
   ScopedVector<TemplateURLData> t_urls =
-      TemplateURLPrepopulateData::GetPrepopulatedEngines(prefs, &default_index);
+      TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
+                                                         &default_index);
 
   ASSERT_EQ(1u, t_urls.size());
   EXPECT_EQ(ASCIIToUTF16("foo"), t_urls[0]->short_name);
   EXPECT_EQ(ASCIIToUTF16("fook"), t_urls[0]->keyword());
   EXPECT_EQ("foo.com", GetHostFromTemplateURLData(*t_urls[0]));
   EXPECT_EQ("foi.com", t_urls[0]->favicon_url.host());
   EXPECT_EQ(1u, t_urls[0]->input_encodings.size());
   EXPECT_EQ(1001, t_urls[0]->prepopulate_id);
   EXPECT_TRUE(t_urls[0]->suggestions_url.empty());
   EXPECT_TRUE(t_urls[0]->instant_url.empty());
   EXPECT_EQ(0u, t_urls[0]->alternate_urls.size());
   EXPECT_TRUE(t_urls[0]->search_terms_replacement_key.empty());
 
   // Test the optional settings too.
   entry->SetString("suggest_url", "http://foo.com/suggest?q={searchTerms}");
   entry->SetString("instant_url", "http://foo.com/instant?q={searchTerms}");
   base::ListValue* alternate_urls = new base::ListValue;
   alternate_urls->AppendString("http://foo.com/alternate?q={searchTerms}");
   entry->Set("alternate_urls", alternate_urls);
   entry->SetString("search_terms_replacement_key", "espv");
   overrides = new base::ListValue;
   overrides->Append(entry->DeepCopy());
-  prefs->SetUserPref(prefs::kSearchProviderOverrides, overrides);
+  prefs_.SetUserPref(prefs::kSearchProviderOverrides, overrides);
 
   t_urls = TemplateURLPrepopulateData::GetPrepopulatedEngines(
-      profile.GetPrefs(), &default_index);
+      &prefs_, &default_index);
   ASSERT_EQ(1u, t_urls.size());
   EXPECT_EQ(ASCIIToUTF16("foo"), t_urls[0]->short_name);
   EXPECT_EQ(ASCIIToUTF16("fook"), t_urls[0]->keyword());
   EXPECT_EQ("foo.com", GetHostFromTemplateURLData(*t_urls[0]));
   EXPECT_EQ("foi.com", t_urls[0]->favicon_url.host());
   EXPECT_EQ(1u, t_urls[0]->input_encodings.size());
   EXPECT_EQ(1001, t_urls[0]->prepopulate_id);
   EXPECT_EQ("http://foo.com/suggest?q={searchTerms}",
             t_urls[0]->suggestions_url);
   EXPECT_EQ("http://foo.com/instant?q={searchTerms}",
@@ skipping 10 matching lines @@
   entry->SetInteger("id", 1002);
   entry->SetString("name", "bar");
   entry->SetString("keyword", "bark");
   entry->SetString("encoding", std::string());
   overrides->Append(entry->DeepCopy());
   entry->SetInteger("id", 1003);
   entry->SetString("name", "baz");
   entry->SetString("keyword", "bazk");
   entry->SetString("encoding", "UTF-8");
   overrides->Append(entry->DeepCopy());
-  prefs->SetUserPref(prefs::kSearchProviderOverrides, overrides);
+  prefs_.SetUserPref(prefs::kSearchProviderOverrides, overrides);
 
   t_urls =
-      TemplateURLPrepopulateData::GetPrepopulatedEngines(prefs, &default_index);
+      TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
+                                                         &default_index);
   EXPECT_EQ(2u, t_urls.size());
 }
 
-TEST(TemplateURLPrepopulateDataTest, ClearProvidersFromPrefs) {
-  TestingProfile profile;
-  TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
-  prefs->SetUserPref(prefs::kSearchProviderOverridesVersion,
+TEST_F(TemplateURLPrepopulateDataTest, ClearProvidersFromPrefs) {
+  prefs_.SetUserPref(prefs::kSearchProviderOverridesVersion,
                      base::Value::CreateIntegerValue(1));
   base::ListValue* overrides = new base::ListValue;
   base::DictionaryValue* entry(new base::DictionaryValue);
   // Set only the minimal required settings for a search provider configuration.
   entry->SetString("name", "foo");
   entry->SetString("keyword", "fook");
   entry->SetString("search_url", "http://foo.com/s?q={searchTerms}");
   entry->SetString("favicon_url", "http://foi.com/favicon.ico");
   entry->SetString("encoding", "UTF-8");
   entry->SetInteger("id", 1001);
   overrides->Append(entry);
-  prefs->SetUserPref(prefs::kSearchProviderOverrides, overrides);
+  prefs_.SetUserPref(prefs::kSearchProviderOverrides, overrides);
 
-  int version = TemplateURLPrepopulateData::GetDataVersion(prefs);
+  int version = TemplateURLPrepopulateData::GetDataVersion(&prefs_);
   EXPECT_EQ(1, version);
 
   // This call removes the above search engine.
-  TemplateURLPrepopulateData::ClearPrepopulatedEnginesInPrefs(prefs);
+  TemplateURLPrepopulateData::ClearPrepopulatedEnginesInPrefs(&prefs_);
 
-  version = TemplateURLPrepopulateData::GetDataVersion(prefs);
+  version = TemplateURLPrepopulateData::GetDataVersion(&prefs_);
   EXPECT_EQ(TemplateURLPrepopulateData::kCurrentDataVersion, version);
 
   size_t default_index;
   ScopedVector<TemplateURLData> t_urls =
-      TemplateURLPrepopulateData::GetPrepopulatedEngines(prefs, &default_index);
+      TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
+                                                         &default_index);
   ASSERT_FALSE(t_urls.empty());
   for (size_t i = 0; i < t_urls.size(); ++i) {
     EXPECT_NE(ASCIIToUTF16("foo"), t_urls[i]->short_name);
     EXPECT_NE(ASCIIToUTF16("fook"), t_urls[i]->keyword());
     EXPECT_NE("foi.com", t_urls[i]->favicon_url.host());
     EXPECT_NE("foo.com", GetHostFromTemplateURLData(*t_urls[i]));
     EXPECT_NE(1001, t_urls[i]->prepopulate_id);
   }
   // Ensures the default URL is Google and has the optional fields filled.
   EXPECT_EQ(ASCIIToUTF16("Google"), t_urls[default_index]->short_name);
   EXPECT_FALSE(t_urls[default_index]->suggestions_url.empty());
   EXPECT_FALSE(t_urls[default_index]->instant_url.empty());
   EXPECT_FALSE(t_urls[default_index]->image_url.empty());
   EXPECT_FALSE(t_urls[default_index]->new_tab_url.empty());
   EXPECT_FALSE(t_urls[default_index]->contextual_search_url.empty());
   EXPECT_FALSE(t_urls[default_index]->image_url_post_params.empty());
   EXPECT_EQ(SEARCH_ENGINE_GOOGLE,
             TemplateURLPrepopulateData::GetEngineType(
                 TemplateURL(*t_urls[default_index]),
                 SearchTermsData()));
 }
 
 // Verifies that built-in search providers are processed correctly.
-TEST(TemplateURLPrepopulateDataTest, ProvidersFromPrepopulated) {
-  TestingProfile profile;
+TEST_F(TemplateURLPrepopulateDataTest, ProvidersFromPrepopulated) {
   // Use United States.
-  profile.GetPrefs()->SetInteger(prefs::kCountryIDAtInstall, 'U'<<8|'S');
+  prefs_.SetInteger(prefs::kCountryIDAtInstall, 'U'<<8|'S');
   size_t default_index;
   ScopedVector<TemplateURLData> t_urls =
-      TemplateURLPrepopulateData::GetPrepopulatedEngines(profile.GetPrefs(),
+      TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
                                                          &default_index);
 
   // Ensure all the URLs have the required fields populated.
   ASSERT_FALSE(t_urls.empty());
   for (size_t i = 0; i < t_urls.size(); ++i) {
     ASSERT_FALSE(t_urls[i]->short_name.empty());
     ASSERT_FALSE(t_urls[i]->keyword().empty());
     ASSERT_FALSE(t_urls[i]->favicon_url.host().empty());
     ASSERT_FALSE(GetHostFromTemplateURLData(*t_urls[i]).empty());
     ASSERT_FALSE(t_urls[i]->input_encodings.empty());
@@ skipping 13 matching lines @@
   EXPECT_GT(t_urls[default_index]->alternate_urls.size(), 1u);
   for (size_t i = 0; i < t_urls[default_index]->alternate_urls.size(); ++i)
     EXPECT_FALSE(t_urls[default_index]->alternate_urls[i].empty());
   EXPECT_EQ(SEARCH_ENGINE_GOOGLE,
             TemplateURLPrepopulateData::GetEngineType(
                 TemplateURL(*t_urls[default_index]),
                 SearchTermsData()));
   EXPECT_FALSE(t_urls[default_index]->search_terms_replacement_key.empty());
 }
 
-TEST(TemplateURLPrepopulateDataTest, GetEngineTypeBasic) {
+TEST_F(TemplateURLPrepopulateDataTest, GetEngineTypeBasic) {
   EXPECT_EQ(SEARCH_ENGINE_OTHER, GetEngineType("http://example.com/"));
   EXPECT_EQ(SEARCH_ENGINE_ASK, GetEngineType("http://www.ask.com/"));
   EXPECT_EQ(SEARCH_ENGINE_OTHER, GetEngineType("http://search.atlas.cz/"));
   EXPECT_EQ(SEARCH_ENGINE_GOOGLE, GetEngineType("http://www.google.com/"));
 }
 
-TEST(TemplateURLPrepopulateDataTest, GetEngineTypeAdvanced) {
+TEST_F(TemplateURLPrepopulateDataTest, GetEngineTypeAdvanced) {
   // Google URLs in different forms.
   const char* kGoogleURLs[] = {
     // Original with google:baseURL:
     "{google:baseURL}search?q={searchTerms}&{google:RLZ}"
     "{google:originalQueryForSuggestion}{google:searchFieldtrialParameter}"
     "sourceid=chrome&ie={inputEncoding}",
     // Custom with google.com and reordered query params:
     "http://google.com/search?{google:RLZ}{google:originalQueryForSuggestion}"
     "{google:searchFieldtrialParameter}"
     "sourceid=chrome&ie={inputEncoding}&q={searchTerms}",
@@ skipping 29 matching lines @@
   EXPECT_EQ(SEARCH_ENGINE_OTHER, GetEngineType("invalid:search:url"));
 
   // URL that doesn't look Google-related, but matches a Google base URL
   // specified on the command line.
   const std::string foo_url("http://www.foo.com/search?q={searchTerms}");
   EXPECT_EQ(SEARCH_ENGINE_OTHER, GetEngineType(foo_url));
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(switches::kGoogleBaseURL,
                                                       "http://www.foo.com/");
   EXPECT_EQ(SEARCH_ENGINE_GOOGLE, GetEngineType(foo_url));
 }