Add a Profile* member to TemplateURL. This makes some invocations of ReplaceSearchTerms() a bit le…

chrome/browser/search_engines/template_url_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/base_paths.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
@@ skipping 49 matching lines @@
 TEST_F(TemplateURLTest, Defaults) {
   TemplateURLData data;
   EXPECT_FALSE(data.show_in_default_list);
   EXPECT_FALSE(data.safe_for_autoreplace);
   EXPECT_EQ(0, data.prepopulate_id);
 }
 
 TEST_F(TemplateURLTest, TestValidWithComplete) {
   TemplateURLData data;
   data.SetURL("{searchTerms}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
 }
 
 TEST_F(TemplateURLTest, URLRefTestSearchTerms) {
   struct SearchTermsCase {
     const char* url;
     const string16 terms;
     const std::string output;
     bool valid_url;
   } search_term_cases[] = {
     { "http://foo{searchTerms}", ASCIIToUTF16("sea rch/bar"),
       "http://foosea%20rch%2Fbar", false },
     { "http://foo{searchTerms}?boo=abc", ASCIIToUTF16("sea rch/bar"),
       "http://foosea%20rch%2Fbar?boo=abc", false },
     { "http://foo/?boo={searchTerms}", ASCIIToUTF16("sea rch/bar"),
       "http://foo/?boo=sea+rch%2Fbar", true },
     { "http://en.wikipedia.org/{searchTerms}", ASCIIToUTF16("wiki/?"),
       "http://en.wikipedia.org/wiki%2F%3F", true }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
     const SearchTermsCase& value = search_term_cases[i];
     TemplateURLData data;
     data.SetURL(value.url);
-    TemplateURL url(data);
+    TemplateURL url(NULL, data);
     EXPECT_TRUE(url.url_ref().IsValid());
     ASSERT_TRUE(url.url_ref().SupportsReplacement());
     std::string result = url.url_ref().ReplaceSearchTerms(value.terms,
         TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16());
     EXPECT_EQ(value.output, result);
     GURL result_url(result);
     EXPECT_EQ(value.valid_url, result_url.is_valid());
   }
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}{count?}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://foox/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount2) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}{count}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://foox10/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestIndices) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}x{startIndex?}y{startPage?}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxxy/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestIndices2) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}x{startIndex}y{startPage}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxx1y1/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestEncoding) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}x{inputEncoding?}y{outputEncoding?}a");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxxutf-8ya/", result.spec());
 }
 
 // Test that setting the prepopulate ID from TemplateURL causes the stored
 // TemplateURLRef to handle parsing the URL parameters differently.
 TEST_F(TemplateURLTest, SetPrepopulatedAndParse) {
   TemplateURLData data;
   data.SetURL("http://foo{fhqwhgads}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("http://foo{fhqwhgads}",
       url.url_ref().ParseURL("http://foo{fhqwhgads}", &replacements, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 
   data.prepopulate_id = 123;
-  TemplateURL url2(data);
+  TemplateURL url2(NULL, data);
   EXPECT_EQ("http://foo", url2.url_ref().ParseURL("http://foo{fhqwhgads}",
                                                   &replacements, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, InputEncodingBeforeSearchTerm) {
   TemplateURLData data;
   data.SetURL("http://foox{inputEncoding?}a{searchTerms}y{outputEncoding?}b");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxutf-8axyb/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestEncoding2) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxxutf-8yutf-8a/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestSearchTermsUsingTermsData) {
   struct SearchTermsCase {
     const char* url;
     const string16 terms;
     const char* output;
   } search_term_cases[] = {
     { "{google:baseURL}{language}{searchTerms}", string16(),
       "http://example.com/e/en" },
     { "{google:baseSuggestURL}{searchTerms}", string16(),
       "http://example.com/complete/" }
   };
 
   TestSearchTermsData search_terms_data("http://example.com/e/");
   TemplateURLData data;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
     const SearchTermsCase& value = search_term_cases[i];
     data.SetURL(value.url);
-    TemplateURL url(data);
+    TemplateURL url(NULL, data);
     EXPECT_TRUE(url.url_ref().IsValid());
     ASSERT_TRUE(url.url_ref().SupportsReplacement());
     GURL result(url.url_ref().ReplaceSearchTermsUsingTermsData(value.terms,
         TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16(),
         search_terms_data));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(value.output, result.spec());
   }
 }
 
@@ skipping 14 matching lines @@
     // Make sure we convert %2B to +.
     {"C%2B%2B", ASCIIToUTF16("C++")},
     // C%2B is escaped as C%252B, make sure we unescape it properly.
     {"C%252B", ASCIIToUTF16("C%2B")},
   };
 
   // Set one input encoding: big-5. This is so we can test fallback to UTF-8.
   TemplateURLData data;
   data.SetURL("http://foo?q={searchTerms}");
   data.input_encodings.push_back("big-5");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(to_wide_cases); i++) {
     EXPECT_EQ(to_wide_cases[i].expected_decoded_term,
               url.url_ref().SearchTermToString16(
                   to_wide_cases[i].encoded_search_term));
   }
 }
 
 TEST_F(TemplateURLTest, DisplayURLToURLRef) {
   struct TestData {
     const std::string url;
     const string16 expected_result;
   } test_data[] = {
     { "http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a",
       ASCIIToUTF16("http://foo%sx{inputEncoding}y{outputEncoding}a") },
     { "http://X",
       ASCIIToUTF16("http://X") },
     { "http://foo{searchTerms",
       ASCIIToUTF16("http://foo{searchTerms") },
     { "http://foo{searchTerms}{language}",
       ASCIIToUTF16("http://foo%s{language}") },
   };
   TemplateURLData data;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
-    TemplateURL url(data);
+    TemplateURL url(NULL, data);
     EXPECT_EQ(test_data[i].expected_result, url.url_ref().DisplayURL());
     EXPECT_EQ(test_data[i].url,
               TemplateURLRef::DisplayURLToURLRef(url.url_ref().DisplayURL()));
   }
 }
 
 TEST_F(TemplateURLTest, ReplaceSearchTerms) {
   struct TestData {
     const std::string url;
     const std::string expected_result;
@@ skipping 20 matching lines @@
       "http://foo/XaUTF-8a{language}a" },
     { "http://foo/{inputEncoding}a{searchTerms}a{language}a",
       "http://foo/UTF-8aXa{language}a" },
     { "http://foo/{inputEncoding}a{language}a{searchTerms}a",
       "http://foo/UTF-8a{language}aXa" },
   };
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
-    TemplateURL url(data);
+    TemplateURL url(NULL, data);
     EXPECT_TRUE(url.url_ref().IsValid());
     ASSERT_TRUE(url.url_ref().SupportsReplacement());
     std::string expected_result = test_data[i].expected_result;
     ReplaceSubstringsAfterOffset(&expected_result, 0, "{language}",
         g_browser_process->GetApplicationLocale());
     GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
         TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(expected_result, result.spec());
   }
@@ skipping 20 matching lines @@
       "http://foo/%82%A0/bar"},
     { "Shift_JIS", UTF8ToUTF16("\xe3\x81\x82 \xe3\x81\x84"),
       "http://foo/{searchTerms}/bar",
       "http://foo/%82%A0%20%82%A2/bar"},
   };
   TemplateURLData data;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     data.SetURL(test_data[i].url);
     data.input_encodings.clear();
     data.input_encodings.push_back(test_data[i].encoding);
-    TemplateURL url(data);
+    TemplateURL url(NULL, data);
     EXPECT_TRUE(url.url_ref().IsValid());
     ASSERT_TRUE(url.url_ref().SupportsReplacement());
     GURL result(url.url_ref().ReplaceSearchTerms(test_data[i].search_term,
         TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, Suggestions) {
@@ skipping 10 matching lines @@
       "http://bar/foo?aq=f&q=foobar" },
     { TemplateURLRef::NO_SUGGESTION_CHOSEN, ASCIIToUTF16("foo"),
       "http://bar/foo?aq=f&q=foobar" },
     { 0, string16(), "http://bar/foo?aq=0&oq=&q=foobar" },
     { 1, ASCIIToUTF16("foo"), "http://bar/foo?aq=1&oq=foo&q=foobar" },
   };
   TemplateURLData data;
   data.SetURL("http://bar/foo?{google:acceptedSuggestion}"
               "{google:originalQueryForSuggestion}q={searchTerms}");
   data.input_encodings.push_back("UTF-8");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("foobar"),
         test_data[i].accepted_suggestion,
         test_data[i].original_query_for_suggestion));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 TEST_F(TemplateURLTest, RLZ) {
   string16 rlz_string;
 #if defined(ENABLE_RLZ)
   std::string brand;
   if (google_util::GetBrand(&brand) && !brand.empty() &&
       !google_util::IsOrganic(brand)) {
     RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz_string);
   }
 #endif
 
   TemplateURLData data;
   data.SetURL("http://bar/?{google:RLZ}{searchTerms}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("x"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   std::string expected_url = "http://bar/?";
   if (!rlz_string.empty())
     expected_url += "rlz=" + UTF16ToUTF8(rlz_string) + "&";
   expected_url += "x";
   EXPECT_EQ(expected_url, result.spec());
@@ skipping 23 matching lines @@
 
     { "http://blah/?q={searchTerms}", "blah", "/", "q"},
 
     // Single term with extra chars in value should match.
     { "http://blah/?q=stock:{searchTerms}", "blah", "/", "q"},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     TemplateURLData data;
     data.SetURL(test_data[i].url);
-    TemplateURL url(data);
+    TemplateURL url(NULL, data);
     EXPECT_EQ(test_data[i].host, url.url_ref().GetHost());
     EXPECT_EQ(test_data[i].path, url.url_ref().GetPath());
     EXPECT_EQ(test_data[i].search_term_key, url.url_ref().GetSearchTermKey());
   }
 }
 
 TEST_F(TemplateURLTest, GoogleBaseSuggestURL) {
   static const struct {
     const char* const base_url;
     const char* const base_suggest_url;
   } data[] = {
     { "http://google.com/", "http://google.com/complete/", },
     { "http://www.google.com/", "http://www.google.com/complete/", },
     { "http://www.google.co.uk/", "http://www.google.co.uk/complete/", },
     { "http://www.google.com.by/", "http://www.google.com.by/complete/", },
     { "http://google.com/intl/xx/", "http://google.com/complete/", },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i)
     CheckSuggestBaseURL(data[i].base_url, data[i].base_suggest_url);
 }
 
 TEST_F(TemplateURLTest, Keyword) {
   TemplateURLData data;
   data.SetURL("http://www.google.com/search");
   EXPECT_FALSE(data.autogenerate_keyword());
   data.SetKeyword(ASCIIToUTF16("foo"));
-  EXPECT_EQ(ASCIIToUTF16("foo"), TemplateURL(data).keyword());
+  EXPECT_EQ(ASCIIToUTF16("foo"), TemplateURL(NULL, data).keyword());
   data.SetAutogenerateKeyword(true);
   EXPECT_TRUE(data.autogenerate_keyword());
-  EXPECT_EQ(ASCIIToUTF16("google.com"), TemplateURL(data).keyword());
+  EXPECT_EQ(ASCIIToUTF16("google.com"), TemplateURL(NULL, data).keyword());
   data.SetKeyword(ASCIIToUTF16("foo"));
   EXPECT_FALSE(data.autogenerate_keyword());
-  EXPECT_EQ(ASCIIToUTF16("foo"), TemplateURL(data).keyword());
+  EXPECT_EQ(ASCIIToUTF16("foo"), TemplateURL(NULL, data).keyword());
 }
 
 TEST_F(TemplateURLTest, ParseParameterKnown) {
   std::string parsed_url("{searchTerms}");
   TemplateURLData data;
   data.SetURL(parsed_url);
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   EXPECT_TRUE(url.url_ref().ParseParameter(0, 12, &parsed_url, &replacements));
   EXPECT_EQ(std::string(), parsed_url);
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(0U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
 }
 
 TEST_F(TemplateURLTest, ParseParameterUnknown) {
   std::string parsed_url("{fhqwhgads}");
   TemplateURLData data;
   data.SetURL(parsed_url);
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
 
   // By default, TemplateURLRef should not consider itself prepopulated.
   // Therefore we should not replace the unknown parameter.
   EXPECT_FALSE(url.url_ref().ParseParameter(0, 10, &parsed_url, &replacements));
   EXPECT_EQ("{fhqwhgads}", parsed_url);
   EXPECT_TRUE(replacements.empty());
 
   // If the TemplateURLRef is prepopulated, we should remove unknown parameters.
   parsed_url = "{fhqwhgads}";
   data.prepopulate_id = 1;
-  TemplateURL url2(data);
+  TemplateURL url2(NULL, data);
   EXPECT_FALSE(url2.url_ref().ParseParameter(0, 10, &parsed_url,
                                              &replacements));
   EXPECT_EQ(std::string(), parsed_url);
   EXPECT_TRUE(replacements.empty());
 }
 
 TEST_F(TemplateURLTest, ParseURLEmpty) {
-  TemplateURLData data;
-  TemplateURL url(data);
+  TemplateURL url(NULL, TemplateURLData());
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ(std::string(),
             url.url_ref().ParseURL(std::string(), &replacements, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, ParseURLNoTemplateEnd) {
   TemplateURLData data;
   data.SetURL("{");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ(std::string(), url.url_ref().ParseURL("{", &replacements, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_FALSE(valid);
 }
 
 TEST_F(TemplateURLTest, ParseURLNoKnownParameters) {
   TemplateURLData data;
   data.SetURL("{}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("{}", url.url_ref().ParseURL("{}", &replacements, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, ParseURLTwoParameters) {
   TemplateURLData data;
   data.SetURL("{}{{%s}}");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("{}{}",
             url.url_ref().ParseURL("{}{{searchTerms}}", &replacements, &valid));
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(3U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, ParseURLNestedParameter) {
   TemplateURLData data;
   data.SetURL("{%s");
-  TemplateURL url(data);
+  TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("{",
             url.url_ref().ParseURL("{{searchTerms}", &replacements, &valid));
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(1U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
   EXPECT_TRUE(valid);
 }