Clean up TemplateURL prepopulate data:

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/file_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/scoped_temp_dir.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/search_engines/search_engine_type.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_prepopulate_data.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "chrome/test/base/testing_profile.h"
+#include "grit/generated_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/l10n/l10n_util.h"
 
 typedef testing::Test TemplateURLPrepopulateDataTest;
 
 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',
@@ skipping 36 matching lines @@
     '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 };
 
 // Verifies the set of prepopulate data doesn't contain entries with duplicate
 // ids.
-TEST_F(TemplateURLPrepopulateDataTest, UniqueIDs) {
+TEST(TemplateURLPrepopulateDataTest, UniqueIDs) {
   TestingProfile profile;
   for (size_t i = 0; i < arraysize(kCountryIds); ++i) {
     profile.GetPrefs()->SetInteger(prefs::kCountryIDAtInstall, kCountryIds[i]);
     ScopedVector<TemplateURL> urls;
     size_t default_index;
-    TemplateURLPrepopulateData::GetPrepopulatedEngines(
-        profile.GetPrefs(), &(urls.get()), &default_index);
+    TemplateURLPrepopulateData::GetPrepopulatedEngines(profile.GetPrefs(),
+        &urls.get(), &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_F(TemplateURLPrepopulateDataTest, ProvidersFromPrefs) {
-  TestingPrefService prefs;
-  TemplateURLPrepopulateData::RegisterUserPrefs(&prefs);
-  prefs.SetUserPref(prefs::kSearchProviderOverridesVersion,
-                    Value::CreateIntegerValue(1));
+TEST(TemplateURLPrepopulateDataTest, ProvidersFromPrefs) {
+  TestingProfile profile;
+  TestingPrefService* prefs = profile.GetTestingPrefService();
+  prefs->SetUserPref(prefs::kSearchProviderOverridesVersion,
+                     Value::CreateIntegerValue(1));
   ListValue* overrides = new ListValue;
   DictionaryValue* entry = new DictionaryValue;
   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("suggest_url", "");
   entry->SetString("instant_url", "");
   entry->SetString("encoding", "UTF-8");
   entry->SetInteger("search_engine_type", 1);
   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);
 
   ScopedVector<TemplateURL> t_urls;
   size_t default_index;
-  TemplateURLPrepopulateData::GetPrepopulatedEngines(
-      &prefs, &(t_urls.get()), &default_index);
+  TemplateURLPrepopulateData::GetPrepopulatedEngines(prefs, &t_urls.get(),
+                                                     &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", t_urls[0]->url()->GetHost());
   EXPECT_EQ("foi.com", t_urls[0]->GetFaviconURL().host());
   EXPECT_EQ(1u, t_urls[0]->input_encodings().size());
   EXPECT_EQ(1001, t_urls[0]->prepopulate_id());
-  EXPECT_EQ(SEARCH_ENGINE_GOOGLE, t_urls[0]->search_engine_type());
 }
 
-TEST_F(TemplateURLPrepopulateDataTest, SearchEngineFromOrigin) {
-  UIThreadSearchTermsData search_terms_data;
-  std::set<GURL> unique_engines;
-
-  { // Scoping for the profile.
-    TestingProfile profile;
-    for (size_t i = 0; i < arraysize(kCountryIds); ++i) {
-      profile.GetPrefs()->SetInteger(prefs::kCountryIDAtInstall,
-                                     kCountryIds[i]);
-      ScopedVector<TemplateURL> urls;
-      size_t default_index;
-      TemplateURLPrepopulateData::GetPrepopulatedEngines(
-          profile.GetPrefs(), &(urls.get()), &default_index);
-      for (size_t turl_i = 0; turl_i < urls.size(); ++turl_i) {
-        GURL engine_url(urls[turl_i]->url()->url());
-        if (!engine_url.is_valid()) {
-          engine_url = TemplateURLService::GenerateSearchURLUsingTermsData(
-              urls[turl_i], search_terms_data);
-        }
-        GURL origin = engine_url.GetOrigin();
-        unique_engines.insert(origin);
-      }
-    }
-  }
-
-  TestingProfile profile;
-  for (std::set<GURL>::iterator it = unique_engines.begin();
-       it != unique_engines.end(); ++it) {
-    scoped_ptr<TemplateURL> found_url(
-        TemplateURLPrepopulateData::GetEngineForOrigin(profile.GetPrefs(),
-                                                       *it));
-    EXPECT_EQ(
-        TemplateURLService::GenerateSearchURLUsingTermsData(
-            found_url.get(), search_terms_data).GetOrigin(),
-        it->GetOrigin());
-  }
-
-  GURL not_a_search_engine("http://example.com/");
-  EXPECT_EQ(NULL, TemplateURLPrepopulateData::GetEngineForOrigin(
-      profile.GetPrefs(),
-      not_a_search_engine));
+TEST(TemplateURLPrepopulateDataTest, GetEngineName) {
+  EXPECT_EQ(ASCIIToUTF16("Atlas"),
+       TemplateURLPrepopulateData::GetEngineName("http://search.atlas.cz/"));
+  EXPECT_EQ(ASCIIToUTF16("Google"),
+       TemplateURLPrepopulateData::GetEngineName("http://www.google.com/"));
+  EXPECT_EQ(ASCIIToUTF16("example.com"),
+            TemplateURLPrepopulateData::GetEngineName("http://example.com/"));
+  EXPECT_EQ(l10n_util::GetStringUTF16(IDS_UNKNOWN_SEARCH_ENGINE_NAME),
+            TemplateURLPrepopulateData::GetEngineName("!@#"));
 }
 
-TEST_F(TemplateURLPrepopulateDataTest, FindPrepopulatedEngine) {
+TEST(TemplateURLPrepopulateDataTest, GetEngineTypeBasic) {
+  EXPECT_EQ(SEARCH_ENGINE_OTHER,
+            TemplateURLPrepopulateData::GetEngineType("http://example.com/"));
+  EXPECT_EQ(SEARCH_ENGINE_ASK,
+            TemplateURLPrepopulateData::GetEngineType("http://www.ask.com/"));
+  EXPECT_EQ(SEARCH_ENGINE_OTHER,
+       TemplateURLPrepopulateData::GetEngineType("http://search.atlas.cz/"));
+  EXPECT_EQ(SEARCH_ENGINE_GOOGLE,
+       TemplateURLPrepopulateData::GetEngineType("http://www.google.com/"));
+}
+
+TEST_F(TemplateURLPrepopulateDataTest, GetEngineTypeAdvanced) {
   // Google URLs in different forms.
   const char* kGoogleURLs[] = {
     // Original with google:baseURL:
     "{google:baseURL}search?{google:RLZ}{google:acceptedSuggestion}"
     "{google:originalQueryForSuggestion}{google:searchFieldtrialParameter}"
     "{google:instantFieldTrialGroupParameter}"
     "sourceid=chrome&ie={inputEncoding}&q={searchTerms}",
     // Custom with google.com:
     "http://google.com/search?{google:RLZ}{google:acceptedSuggestion}"
     "{google:originalQueryForSuggestion}{google:searchFieldtrialParameter}"
     "{google:instantFieldTrialGroupParameter}"
     "sourceid=chrome&ie={inputEncoding}&q={searchTerms}",
     // Custom with a country TLD:
     "http://www.google.ru/search?{google:RLZ}{google:acceptedSuggestion}"
     "{google:originalQueryForSuggestion}{google:searchFieldtrialParameter}"
     "{google:instantFieldTrialGroupParameter}"
     "sourceid=chrome&ie={inputEncoding}&q={searchTerms}"
   };
-  scoped_ptr<TemplateURL> t_url;
   for (size_t i = 0; i < arraysize(kGoogleURLs); ++i) {
-    t_url.reset(
-        TemplateURLPrepopulateData::FindPrepopulatedEngine(kGoogleURLs[i]));
-    ASSERT_TRUE(t_url.get());
-    // Google's prepopulated ID is 1.
-    EXPECT_EQ(1, t_url->prepopulate_id());
+    EXPECT_EQ(SEARCH_ENGINE_GOOGLE,
+              TemplateURLPrepopulateData::GetEngineType(kGoogleURLs[i]));
   }
   // Non-Google URLs.
   const char* kYahooURLs[] = {
       "http://search.yahoo.com/search?"
       "ei={inputEncoding}&fr=crmas&p={searchTerms}",
       "http://search.yahoo.com/search?p={searchTerms}"
   };
   for (size_t i = 0; i < arraysize(kYahooURLs); ++i) {
-    t_url.reset(
-        TemplateURLPrepopulateData::FindPrepopulatedEngine(kYahooURLs[i]));
-    ASSERT_TRUE(t_url.get());
-    // Yahoo!'s prepopulated ID is 2.
-    EXPECT_EQ(2, t_url->prepopulate_id());
+    EXPECT_EQ(SEARCH_ENGINE_YAHOO,
+              TemplateURLPrepopulateData::GetEngineType(kYahooURLs[i]));
   }
   // Search URL for which no prepopulated search provider exists.
   std::string kExampleSearchURL = "http://example.net/search?q={searchTerms}";
-  EXPECT_FALSE(TemplateURLPrepopulateData::FindPrepopulatedEngine(
-      kExampleSearchURL));
-  // Invalid search URL.
-  EXPECT_FALSE(TemplateURLPrepopulateData::FindPrepopulatedEngine(
-      "invalid:search:url"));
+  EXPECT_EQ(SEARCH_ENGINE_OTHER,
+            TemplateURLPrepopulateData::GetEngineType(kExampleSearchURL));
+  EXPECT_EQ(SEARCH_ENGINE_OTHER,
+            TemplateURLPrepopulateData::GetEngineType("invalid:search:url"));
 }