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

chrome/browser/search_engines/template_url_service_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/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/test/mock_time_provider.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 19 matching lines @@
 
 using base::Time;
 using base::TimeDelta;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 // Test the GenerateSearchURL on a thread or the main thread.
 class TestGenerateSearchURL
     : public base::RefCountedThreadSafe<TestGenerateSearchURL> {
  public:
-  explicit TestGenerateSearchURL(SearchTermsData* search_terms_data)
-      : search_terms_data_(search_terms_data),
+  TestGenerateSearchURL(Profile* profile, SearchTermsData* search_terms_data)
+      : profile_(profile),
+        search_terms_data_(search_terms_data),
         passed_(false) {
   }
 
   // Run the test cases for GenerateSearchURL.
   void RunTest();
 
   // Did the test pass?
   bool passed() const { return passed_; }
 
  private:
   friend class base::RefCountedThreadSafe<TestGenerateSearchURL>;
   ~TestGenerateSearchURL() {}
 
+  Profile* const profile_;
   SearchTermsData* search_terms_data_;
   bool passed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestGenerateSearchURL);
 };
 
 // Simple implementation of SearchTermsData.
 class TestSearchTermsData : public SearchTermsData {
  public:
   explicit TestSearchTermsData(const char* google_base_url)
@@ skipping 241 matching lines @@
   // gtest documentation.
   bool everything_passed = true;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(generate_url_cases); ++i) {
     TemplateURL t_url;
     if (generate_url_cases[i].url)
       t_url.SetURL(generate_url_cases[i].url, 0, 0);
 
     std::string result = search_terms_data_ ?
         TemplateURLService::GenerateSearchURLUsingTermsData(
             &t_url, *search_terms_data_).spec() :
-        TemplateURLService::GenerateSearchURL(&t_url).spec();
+        TemplateURLService::GenerateSearchURL(&t_url, profile_).spec();
     if (strcmp(generate_url_cases[i].expected, result.c_str())) {
       LOG(ERROR) << generate_url_cases[i].test_name << " failed. Expected " <<
           generate_url_cases[i].expected << " Actual " << result;
 
       everything_passed = false;
     }
   }
   passed_ = everything_passed;
 }
 
@@ skipping 149 matching lines @@
   // FTP shouldn't generate a keyword.
   ASSERT_EQ(string16(),
             TemplateURLService::GenerateKeyword(GURL("ftp://blah/"), true));
   // Make sure we don't get a trailing /
   ASSERT_EQ(ASCIIToUTF16("blah"),
             TemplateURLService::GenerateKeyword(GURL("http://blah/"), true));
 }
 
 TEST_F(TemplateURLServiceTest, GenerateSearchURL) {
   scoped_refptr<TestGenerateSearchURL> test_generate_search_url(
-      new TestGenerateSearchURL(NULL));
+      new TestGenerateSearchURL(profile(), NULL));
   test_generate_search_url->RunTest();
   EXPECT_TRUE(test_generate_search_url->passed());
 }
 
 TEST_F(TemplateURLServiceTest, GenerateSearchURLUsingTermsData) {
   // Run the test for GenerateSearchURLUsingTermsData on the "IO" thread and
   // wait for it to finish.
   TestSearchTermsData search_terms_data("http://google.com/");
   scoped_refptr<TestGenerateSearchURL> test_generate_search_url(
-      new TestGenerateSearchURL(&search_terms_data));
+      new TestGenerateSearchURL(profile(), &search_terms_data));
 
   test_util_.StartIOThread();
   BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)->PostTask(
           FROM_HERE,
           NewRunnableMethod(test_generate_search_url.get(),
                             &TestGenerateSearchURL::RunTest));
   TemplateURLServiceTestUtil::BlockTillIOThreadProcessesRequests();
   EXPECT_TRUE(test_generate_search_url->passed());
 }
 
@@ skipping 377 matching lines @@
   // Change the Google base url.
   test_util_.ResetObserverCount();
   SetGoogleBaseURL("http://foo.com/");
   VerifyObserverCount(1);
 
   // Make sure the host->TemplateURL map was updated appropriately.
   ASSERT_EQ(t_url, model()->GetTemplateURLForHost("foo.com"));
   EXPECT_TRUE(model()->GetTemplateURLForHost("google.com") == NULL);
   EXPECT_EQ("foo.com", t_url->url()->GetHost());
   EXPECT_EQ(ASCIIToUTF16("foo.com"), t_url->keyword());
-  EXPECT_EQ("http://foo.com/?q=x", t_url->url()->ReplaceSearchTerms(*t_url,
-      ASCIIToUTF16("x"), TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
+  EXPECT_EQ("http://foo.com/?q=x", t_url->url()->ReplaceSearchTerms(profile(),

[Peter Kasting, 2011/08/10 20:54:06]

This call and the one below can pass NULL since you don't care about the field
trial in tests.

+      *t_url, ASCIIToUTF16("x"), TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
+      string16()));
 }
 
 struct QueryHistoryCallbackImpl {
   QueryHistoryCallbackImpl() : success(false) {}
 
   void Callback(HistoryService::Handle handle,
                 bool success, const history::URLRow* row,
                 history::VisitVector* visits) {
     this->success = success;
     if (row)
@@ skipping 16 matching lines @@
   // Create a keyword.
   TemplateURL* t_url = AddKeywordWithDate(
       "keyword", false, "http://foo.com/foo?query={searchTerms}",
       "http://sugg1", "http://icon1", "UTF-8;UTF-16", "keyword",
       true, base::Time::Now(), base::Time::Now());
 
   // Add a visit that matches the url of the keyword.
   HistoryService* history =
       profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
   history->AddPage(
-      GURL(t_url->url()->ReplaceSearchTerms(*t_url, ASCIIToUTF16("blah"), 0,
-                                            string16())),
+      GURL(t_url->url()->ReplaceSearchTerms(profile(), *t_url,
+          ASCIIToUTF16("blah"), 0, string16())),
       NULL, 0, GURL(), PageTransition::KEYWORD, history::RedirectList(),
       history::SOURCE_BROWSED, false);
 
   // Wait for history to finish processing the request.
   profile()->BlockUntilHistoryProcessesPendingRequests();
 
   // Query history for the generated url.
   CancelableRequestConsumer consumer;
   QueryHistoryCallbackImpl callback;
   history->QueryURL(GURL("http://keyword"), true, &consumer,
@@ skipping 293 matching lines @@
   model()->SetDefaultSearchProvider(t_url);
   EXPECT_EQ(t_url, model()->GetDefaultSearchProvider());
 
   // Now reset the model again but load it after setting the preferences.
   ResetModel(false);
   SetManagedDefaultSearchPreferences(false, "", "", "", "", "", "");
   VerifyLoad();
   EXPECT_TRUE(model()->is_default_search_managed());
   EXPECT_TRUE(model()->GetDefaultSearchProvider() == NULL);
 }