Add a URL param to indicate group selection in Instant field trial.

chrome/browser/search_engines/template_url_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 "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"
 #include "chrome/browser/search_engines/template_url.h"
+#include "chrome/test/base/testing_profile.h"
 #include "chrome/test/testing_browser_process_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Simple implementation of SearchTermsData.
 class TestSearchTermsData : public SearchTermsData {
  public:
   explicit TestSearchTermsData(const char* google_base_url)
       : google_base_url_(google_base_url)  {
   }
 
@@ skipping 23 matching lines @@
   virtual void TearDown() {
     TemplateURLRef::SetGoogleBaseURL(NULL);
   }
 
   void CheckSuggestBaseURL(const char* base_url,
                            const char* base_suggest_url) const {
     TestSearchTermsData search_terms_data(base_url);
     EXPECT_STREQ(base_suggest_url,
                  search_terms_data.GoogleBaseSuggestURLValue().c_str());
   }
+
+ protected:
+  TestingProfile profile_;
 };
 
 TEST_F(TemplateURLTest, Defaults) {
   TemplateURL url;
   ASSERT_FALSE(url.show_in_default_list());
   ASSERT_FALSE(url.safe_for_autoreplace());
   ASSERT_EQ(0, url.prepopulate_id());
 }
 
 TEST_F(TemplateURLTest, TestValidWithComplete) {
@@ skipping 16 matching lines @@
     { "http://en.wikipedia.org/{searchTerms}", ASCIIToUTF16("wiki/?"),
       "http://en.wikipedia.org/wiki/%3F" }
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
     const SearchTermsCase& value = search_term_cases[i];
     TemplateURL t_url;
     TemplateURLRef ref(value.url, 0, 0);
     ASSERT_TRUE(ref.IsValid());
 
     ASSERT_TRUE(ref.SupportsReplacement());
-    GURL result = GURL(ref.ReplaceSearchTerms(t_url, value.terms,
+    GURL result = GURL(ref.ReplaceSearchTerms(&profile_, t_url, value.terms,
         TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
     ASSERT_TRUE(result.is_valid());
     ASSERT_EQ(value.output, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount) {
   TemplateURL t_url;
   TemplateURLRef ref("http://foo{searchTerms}{count?}", 0, 0);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = GURL(ref.ReplaceSearchTerms(t_url, ASCIIToUTF16("X"),
+  GURL result = GURL(ref.ReplaceSearchTerms(&profile_, t_url, ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://foox/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount2) {
   TemplateURL t_url;
   TemplateURLRef ref("http://foo{searchTerms}{count}", 0, 0);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = GURL(ref.ReplaceSearchTerms(t_url, ASCIIToUTF16("X"),
+  GURL result = GURL(ref.ReplaceSearchTerms(&profile_, t_url, ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://foox10/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestIndices) {
   TemplateURL t_url;
   TemplateURLRef ref("http://foo{searchTerms}x{startIndex?}y{startPage?}",
                      1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = GURL(ref.ReplaceSearchTerms(t_url, ASCIIToUTF16("X"),
+  GURL result = GURL(ref.ReplaceSearchTerms(&profile_, t_url, ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxxy/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestIndices2) {
   TemplateURL t_url;
   TemplateURLRef ref("http://foo{searchTerms}x{startIndex}y{startPage}", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = GURL(ref.ReplaceSearchTerms(t_url, ASCIIToUTF16("X"),
+  GURL result = GURL(ref.ReplaceSearchTerms(&profile_, t_url, ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxx1y2/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestEncoding) {
   TemplateURL t_url;
   TemplateURLRef ref(
       "http://foo{searchTerms}x{inputEncoding?}y{outputEncoding?}a", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = GURL(ref.ReplaceSearchTerms(t_url, ASCIIToUTF16("X"),
+  GURL result = GURL(ref.ReplaceSearchTerms(&profile_, t_url, ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxxutf-8ya/", result.spec());
 }
 
 TEST_F(TemplateURLTest, SetPrepopulatedAndParse) {
   TemplateURL t_url;
   t_url.SetURL("http://foo{fhqwhgads}", 0, 0);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
@@ skipping 14 matching lines @@
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, InputEncodingBeforeSearchTerm) {
   TemplateURL t_url;
   TemplateURLRef ref(
       "http://foox{inputEncoding?}a{searchTerms}y{outputEncoding?}b", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = GURL(ref.ReplaceSearchTerms(t_url, ASCIIToUTF16("X"),
+  GURL result = GURL(ref.ReplaceSearchTerms(&profile_, t_url, ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   ASSERT_EQ("http://fooxutf-8axyb/", result.spec());
 }
 
 TEST_F(TemplateURLTest, URLRefTestEncoding2) {
   TemplateURL t_url;
   TemplateURLRef ref(
       "http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result = GURL(ref.ReplaceSearchTerms(t_url, ASCIIToUTF16("X"),
+  GURL result = GURL(ref.ReplaceSearchTerms(&profile_, t_url, ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   ASSERT_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/yy" },
     { "{google:baseSuggestURL}{searchTerms}", string16(),
       "http://clients1.example.com/complete/" }
   };
 
   TestSearchTermsData search_terms_data("http://example.com/e/");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
     const SearchTermsCase& value = search_term_cases[i];
     TemplateURL t_url;
     TemplateURLRef ref(value.url, 0, 0);
     ASSERT_TRUE(ref.IsValid());
 
     ASSERT_TRUE(ref.SupportsReplacement());
     GURL result = GURL(ref.ReplaceSearchTermsUsingTermsData(
-        t_url, value.terms,
+        &profile_, t_url, value.terms,
         TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16(),
         search_terms_data));
     ASSERT_TRUE(result.is_valid());
     ASSERT_EQ(value.output, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, URLRefTermToWide) {
   struct ToWideCase {
     const char* encoded_search_term;
@@ skipping 100 matching lines @@
   };
   TemplateURL turl;
   turl.add_input_encoding("UTF-8");
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     TemplateURLRef ref(data[i].url, 1, 2);
     EXPECT_TRUE(ref.IsValid());
     EXPECT_TRUE(ref.SupportsReplacement());
     std::string expected_result = data[i].expected_result;
     ReplaceSubstringsAfterOffset(&expected_result, 0, "{language}",
         g_browser_process->GetApplicationLocale());
-    GURL result = GURL(ref.ReplaceSearchTerms(turl, ASCIIToUTF16("X"),
-        TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
+    GURL result = GURL(ref.ReplaceSearchTerms(&profile_, turl,
+        ASCIIToUTF16("X"), TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
+        string16()));
     EXPECT_TRUE(result.is_valid());
     EXPECT_EQ(expected_result, result.spec());
   }
 }
 
 
 // Tests replacing search terms in various encodings and making sure the
 // generated URL matches the expected value.
 TEST_F(TemplateURLTest, ReplaceArbitrarySearchTerms) {
   struct TestData {
     const std::string encoding;
     const string16 search_term;
     const std::string url;
     const std::string expected_result;
   } data[] = {
     { "BIG5",  WideToUTF16(L"\x60BD"),
       "http://foo/?{searchTerms}{inputEncoding}",
       "http://foo/?%B1~BIG5" },
     { "UTF-8", ASCIIToUTF16("blah"),
       "http://foo/?{searchTerms}{inputEncoding}",
       "http://foo/?blahUTF-8" },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     TemplateURL turl;
     turl.add_input_encoding(data[i].encoding);
     TemplateURLRef ref(data[i].url, 1, 2);
-    GURL result = GURL(ref.ReplaceSearchTerms(turl,
+    GURL result = GURL(ref.ReplaceSearchTerms(&profile_, turl,
         data[i].search_term, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
         string16()));
     EXPECT_TRUE(result.is_valid());
     EXPECT_EQ(data[i].expected_result, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, Suggestions) {
   struct TestData {
     const int accepted_suggestion;
@@ skipping 11 matching lines @@
     { 0, string16(), "http://bar/foo?aq=0&oq=&q=foobar" },
     { 1, ASCIIToUTF16("foo"), "http://bar/foo?aq=1&oq=foo&q=foobar" },
   };
   TemplateURL turl;
   turl.add_input_encoding("UTF-8");
   TemplateURLRef ref("http://bar/foo?{google:acceptedSuggestion}"
       "{google:originalQueryForSuggestion}q={searchTerms}", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
-    GURL result = GURL(ref.ReplaceSearchTerms(turl, ASCIIToUTF16("foobar"),
-        data[i].accepted_suggestion, data[i].original_query_for_suggestion));
+    GURL result = GURL(ref.ReplaceSearchTerms(&profile_, turl,
+        ASCIIToUTF16("foobar"), data[i].accepted_suggestion,
+        data[i].original_query_for_suggestion));
     EXPECT_TRUE(result.is_valid());
     EXPECT_EQ(data[i].expected_result, result.spec());
   }
 }
 
 #if defined(OS_WIN)
 TEST_F(TemplateURLTest, RLZ) {
   string16 rlz_string;
 #if defined(GOOGLE_CHROME_BUILD)
   RLZTracker::GetAccessPointRlz(rlz_lib::CHROME_OMNIBOX, &rlz_string);
 #endif
 
   TemplateURL t_url;
   TemplateURLRef ref("http://bar/?{google:RLZ}{searchTerms}", 1, 2);
   ASSERT_TRUE(ref.IsValid());
   ASSERT_TRUE(ref.SupportsReplacement());
-  GURL result(ref.ReplaceSearchTerms(t_url, L"x",
+  GURL result(ref.ReplaceSearchTerms(&profile_, t_url, L"x",
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   std::string expected_url = "http://bar/?";
   if (!rlz_string.empty()) {
     expected_url += "rlz=" + WideToUTF8(rlz_string) + "&";
   }
   expected_url += "x";
   ASSERT_EQ(expected_url, result.spec());
 }
 #endif
@@ skipping 137 matching lines @@
 TEST_F(TemplateURLTest, ParseURLNestedParameter) {
   TemplateURLRef url_ref("{%s", 0, 0);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("{", url_ref.ParseURL("{{searchTerms}", &replacements, &valid));
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(static_cast<size_t>(1), replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
   EXPECT_TRUE(valid);
 }