Stop using UIThreadSearchTermsData in tests when unnecessary

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/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/autocomplete/autocomplete_input.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/search_engines/template_url.h"
-#include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
+#include "components/search_engines/search_terms_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(ENABLE_RLZ)
-#include "chrome/browser/google/google_brand.h"
-#endif
-
-#if defined(OS_ANDROID)
-#include "chrome/browser/search_engines/ui_thread_search_terms_data_android.h"
-#endif
-
 using base::ASCIIToUTF16;
 
 // TestSearchTermsData --------------------------------------------------------
 
 // Simple implementation of SearchTermsData.
 class TestSearchTermsData : public SearchTermsData {
  public:
   explicit TestSearchTermsData(const std::string& google_base_url);
 
   virtual std::string GoogleBaseURLValue() const OVERRIDE;
+  virtual base::string16 GetRlzParameterValue(
+      bool from_app_list) const OVERRIDE;
+  virtual std::string GetSearchClient() const OVERRIDE;
+
+  void set_google_base_url(const std::string& google_base_url) {
+    google_base_url_ = google_base_url;
+  }
+  void set_search_client(const std::string& search_client) {
+    search_client_ = search_client;
+  }
 
  private:
   std::string google_base_url_;
+  std::string search_client_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSearchTermsData);
 };
 
 TestSearchTermsData::TestSearchTermsData(const std::string& google_base_url)
     : google_base_url_(google_base_url) {
 }
 
 std::string TestSearchTermsData::GoogleBaseURLValue() const {
   return google_base_url_;
 }
 
+base::string16 TestSearchTermsData::GetRlzParameterValue(
+    bool from_app_list) const {
+  return ASCIIToUTF16(
+      from_app_list ? "rlz_parameter_from_app_list" : "rlz_parameter");
+}
+
+std::string TestSearchTermsData::GetSearchClient() const {
+  return search_client_;
+}
+
 // TemplateURLTest ------------------------------------------------------------
 
 class TemplateURLTest : public testing::Test {
  public:
-  TemplateURLTest() : search_terms_data_(NULL) {}
+  TemplateURLTest() : search_terms_data_("http://www.google.com/") {}
   void CheckSuggestBaseURL(const std::string& base_url,
                            const std::string& base_suggest_url) const;
 
-  UIThreadSearchTermsData search_terms_data_;
+  TestSearchTermsData search_terms_data_;
 };
 
 void TemplateURLTest::CheckSuggestBaseURL(
     const std::string& base_url,
     const std::string& base_suggest_url) const {
   TestSearchTermsData search_terms_data(base_url);
   EXPECT_EQ(base_suggest_url, search_terms_data.GoogleBaseSuggestURLValue());
 }
 
 
@@ skipping 371 matching lines @@
   };
   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);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     std::string expected_result = test_data[i].expected_result;
     ReplaceSubstringsAfterOffset(&expected_result, 0, "{language}",
-        g_browser_process->GetApplicationLocale());
+                                 search_terms_data_.GetApplicationLocale());
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")),
         search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(expected_result, result.spec());
   }
 }
 
 
 // Tests replacing search terms in various encodings and making sure the
@@ skipping 57 matching lines @@
       "https://foo/?fooaqs=chrome.0.0l6&" },
     // HTTPS available, however AQS is empty.
     { ASCIIToUTF16("foo"),
       "",
       "https://foo/",
       "{google:baseURL}?{searchTerms}{google:assistedQueryStats}",
       "https://foo/?foo" },
     // No {google:baseURL} and protocol is HTTP, we must not substitute AQS.
     { ASCIIToUTF16("foo"),
       "chrome.0.0l6",
-      "",
+      "http://www.google.com",
       "http://foo?{searchTerms}{google:assistedQueryStats}",
       "http://foo/?foo" },
     // A non-Google search provider with HTTPS should allow AQS.
     { ASCIIToUTF16("foo"),
       "chrome.0.0l6",
-      "",
+      "https://www.google.com",
       "https://foo?{searchTerms}{google:assistedQueryStats}",
       "https://foo/?fooaqs=chrome.0.0l6&" },
   };
   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);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.assisted_query_stats = test_data[i].aqs;
-    UIThreadSearchTermsData::SetGoogleBaseURL(test_data[i].base_url);
+    search_terms_data_.set_google_base_url(test_data[i].base_url);
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
 
 // Tests replacing cursor position.
 TEST_F(TemplateURLTest, ReplaceCursorPosition) {
   struct TestData {
     const base::string16 search_term;
     size_t cursor_position;
     const std::string url;
     const std::string expected_result;
   } test_data[] = {
     { ASCIIToUTF16("foo"),
       base::string16::npos,
       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
       "http://www.google.com/?foo&" },
     { ASCIIToUTF16("foo"),
       2,
       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
       "http://www.google.com/?foo&cp=2&" },
     { ASCIIToUTF16("foo"),
       15,
       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
       "http://www.google.com/?foo&cp=15&" },
   };
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   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);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.cursor_position = test_data[i].cursor_position;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
@@ skipping 17 matching lines @@
       "http://www.google.com/?foo&oit=1&" },
     { ASCIIToUTF16("foo"),
       metrics::OmniboxInputType::URL,
       "{google:baseURL}?{searchTerms}&{google:inputType}",
       "http://www.google.com/?foo&oit=3&" },
     { ASCIIToUTF16("foo"),
       metrics::OmniboxInputType::FORCED_QUERY,
       "{google:baseURL}?{searchTerms}&{google:inputType}",
       "http://www.google.com/?foo&oit=5&" },
   };
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   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);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.input_type = test_data[i].input_type;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
@@ skipping 17 matching lines @@
       "http://www.google.com/?foo&url=http%3A%2F%2Fwww.google.com%2F&" },
     { ASCIIToUTF16("foo"),
       "",
       "{google:baseURL}?{searchTerms}&{google:currentPageUrl}",
       "http://www.google.com/?foo&" },
     { ASCIIToUTF16("foo"),
       "http://g.com/+-/*&=",
       "{google:baseURL}?{searchTerms}&{google:currentPageUrl}",
       "http://www.google.com/?foo&url=http%3A%2F%2Fg.com%2F%2B-%2F*%26%3D&" },
   };
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   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);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.current_page_url = test_data[i].current_page_url;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
@@ skipping 34 matching lines @@
     search_terms_args.original_query =
         test_data[i].original_query_for_suggestion;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, RLZ) {
-  base::string16 rlz_string;
-#if defined(ENABLE_RLZ)
-  std::string brand;
-  if (google_brand::GetBrand(&brand) && !brand.empty() &&
-      !google_brand::IsOrganic(brand)) {
-    RLZTracker::GetAccessPointRlz(RLZTracker::ChromeOmnibox(), &rlz_string);
-  }
-#elif defined(OS_ANDROID)
-  SearchTermsDataAndroid::rlz_parameter_value_.Get() =
-      ASCIIToUTF16("android_test");
-  rlz_string = SearchTermsDataAndroid::rlz_parameter_value_.Get();
-#endif
+  base::string16 rlz_string = search_terms_data_.GetRlzParameterValue(false);

[Peter Kasting, 2014/06/19 21:24:42]

These next two functions no longer check that the real RLZ string gets subbed
in.  Was that testing important?

[hashimoto, 2014/06/19 21:43:50]

IIUC the purpose of these tests are to verify that "{google:RLZ}" in the
template and |from_app_list| of SearchTermsArgs are correctly handled by
TemplateURL.
Even in the new code, these tests are serving for that purpose.

[Peter Kasting, 2014/06/19 22:08:36]

Right, I am concerned that the tests may be doing double duty as both what you
said, and actually verifying the RLZ code in sort of an end-to-end fashion.

You should probably ensure that there are separate tests of the RLZ code
elsewhere and/or that an RLZ owner signs off on this.

[hashimoto, 2014/06/19 22:37:10]

chrome/browser/rlz/rlz_unittest.cc is testing RLZTracker::GetAccessPointRlz()
and other RLZ functions.
Do you think this is sufficient?

 
   TemplateURLData data;
   data.SetURL("http://bar/?{google:RLZ}{searchTerms}");
   TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("x")), search_terms_data_));
   ASSERT_TRUE(result.is_valid());
-  std::string expected_url = "http://bar/?";
-  if (!rlz_string.empty())
-    expected_url += "rlz=" + base::UTF16ToUTF8(rlz_string) + "&";
-  expected_url += "x";
-  EXPECT_EQ(expected_url, result.spec());
+  EXPECT_EQ("http://bar/?rlz=" + base::UTF16ToUTF8(rlz_string) + "&x",
+            result.spec());
 }
 
-#if !defined(OS_ANDROID) && !defined(OS_IOS)
 TEST_F(TemplateURLTest, RLZFromAppList) {
-  base::string16 rlz_string;
-#if defined(ENABLE_RLZ)
-  std::string brand;
-  if (google_brand::GetBrand(&brand) && !brand.empty() &&
-      !google_brand::IsOrganic(brand)) {
-    RLZTracker::GetAccessPointRlz(RLZTracker::ChromeAppList(), &rlz_string);
-  }
-#endif
+  base::string16 rlz_string = search_terms_data_.GetRlzParameterValue(true);
 
   TemplateURLData data;
   data.SetURL("http://bar/?{google:RLZ}{searchTerms}");
   TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   TemplateURLRef::SearchTermsArgs args(ASCIIToUTF16("x"));
   args.from_app_list = true;
   GURL result(url.url_ref().ReplaceSearchTerms(args, search_terms_data_));
   ASSERT_TRUE(result.is_valid());
-  std::string expected_url = "http://bar/?";
-  if (!rlz_string.empty())
-    expected_url += "rlz=" + base::UTF16ToUTF8(rlz_string) + "&";
-  expected_url += "x";
-  EXPECT_EQ(expected_url, result.spec());
+  EXPECT_EQ("http://bar/?rlz=" + base::UTF16ToUTF8(rlz_string) + "&x",
+            result.spec());
 }
-#endif
 
 TEST_F(TemplateURLTest, HostAndSearchTermKey) {
   struct TestData {
     const std::string url;
     const std::string host;
     const std::string path;
     const std::string search_term_key;
   } test_data[] = {
     { "http://blah/?foo=bar&q={searchTerms}&b=x", "blah", "/", "q"},
 
@@ skipping 134 matching lines @@
   bool valid = false;
   EXPECT_EQ("{",
             url.url_ref().ParseURL("{{searchTerms}", &replacements, NULL,
                                    &valid));
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(1U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
   EXPECT_TRUE(valid);
 }
 
-#if defined(OS_ANDROID)
 TEST_F(TemplateURLTest, SearchClient) {
   const std::string base_url_str("http://google.com/?");
   const std::string terms_str("{searchTerms}&{google:searchClient}");
   const std::string full_url_str = base_url_str + terms_str;
   const base::string16 terms(ASCIIToUTF16(terms_str));
-  UIThreadSearchTermsData::SetGoogleBaseURL(base_url_str);
+  search_terms_data_.set_google_base_url(base_url_str);
 
   TemplateURLData data;
   data.SetURL(full_url_str);
   TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foobar"));
 
   // Check that the URL is correct when a client is not present.
   GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                search_terms_data_));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://google.com/?foobar&", result.spec());
 
   // Check that the URL is correct when a client is present.
-  SearchTermsDataAndroid::search_client_.Get() = "android_test";
+  search_terms_data_.set_search_client("search_client");
   GURL result_2(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
   ASSERT_TRUE(result_2.is_valid());
-  EXPECT_EQ("http://google.com/?foobar&client=android_test&", result_2.spec());
+  EXPECT_EQ("http://google.com/?foobar&client=search_client&", result_2.spec());
 }
-#endif
 
 TEST_F(TemplateURLTest, GetURLNoInstantURL) {
   TemplateURLData data;
   data.SetURL("http://google.com/?q={searchTerms}");
   data.suggestions_url = "http://google.com/suggest?q={searchTerms}";
   data.alternate_urls.push_back("http://google.com/alt?q={searchTerms}");
   data.alternate_urls.push_back("{google:baseURL}/alt/#q={searchTerms}");
   TemplateURL url(data);
   ASSERT_EQ(3U, url.URLCount());
   EXPECT_EQ("http://google.com/alt?q={searchTerms}", url.GetURL(0));
@@ skipping 290 matching lines @@
       search_terms_data_, &result));
 
   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
       GURL("http://google.com/alt/?q=#q=123"), search_terms,
       search_terms_data_, &result));
   EXPECT_EQ(GURL("http://google.com/alt/?q=#q=Bob Morane"), result);
 }
 
 // Test the |suggest_query_params| field of SearchTermsArgs.
 TEST_F(TemplateURLTest, SuggestQueryParams) {
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   // Pick a URL with replacements before, during, and after the query, to ensure
   // we don't goof up any of them.
   data.SetURL("{google:baseURL}search?q={searchTerms}"
       "#{google:originalQueryForSuggestion}x");
   TemplateURL url(data);
 
   // Baseline: no |suggest_query_params| field.
   TemplateURLRef::SearchTermsArgs search_terms(ASCIIToUTF16("abc"));
   search_terms.original_query = ASCIIToUTF16("def");
   search_terms.accepted_suggestion = 0;
   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 
   // Set the suggest_query_params.
   search_terms.suggest_query_params = "pq=xyz";
   EXPECT_EQ("http://www.google.com/search?pq=xyz&q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 
   // Add extra_query_params in the mix, and ensure it works.
   search_terms.append_extra_query_params = true;
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kExtraSearchQueryParams, "a=b");
   EXPECT_EQ("http://www.google.com/search?a=b&pq=xyz&q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 }
 
 // Test the |append_extra_query_params| field of SearchTermsArgs.
 TEST_F(TemplateURLTest, ExtraQueryParams) {
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   // Pick a URL with replacements before, during, and after the query, to ensure
   // we don't goof up any of them.
   data.SetURL("{google:baseURL}search?q={searchTerms}"
       "#{google:originalQueryForSuggestion}x");
   TemplateURL url(data);
 
   // Baseline: no command-line args, no |append_extra_query_params| flag.
   TemplateURLRef::SearchTermsArgs search_terms(ASCIIToUTF16("abc"));
   search_terms.original_query = ASCIIToUTF16("def");
@@ skipping 14 matching lines @@
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 
   // Turn off the flag.  Now the command-line arg should be ignored again.
   search_terms.append_extra_query_params = false;
   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
 }
 
 // Tests replacing pageClassification.
 TEST_F(TemplateURLTest, ReplacePageClassification) {
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   data.SetURL("{google:baseURL}?{google:pageClassification}q={searchTerms}");
   TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
 
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
@@ skipping 40 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(url_data); ++i) {
     EXPECT_EQ(url_data[i].result,
               search_provider.IsSearchURL(GURL(url_data[i].url),
                                           search_terms_data_));
   }
 }
 
 TEST_F(TemplateURLTest, ReflectsBookmarkBarPinned) {
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://www.google.com/");
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   data.SetURL("{google:baseURL}?{google:bookmarkBarPinned}q={searchTerms}");
   TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
 
   // Do not add the param when InstantExtended is suppressed on SRPs.
   url.url_ref_.showing_search_terms_ = false;
@@ skipping 10 matching lines @@
 
   url.url_ref_.showing_search_terms_ = true;
   search_terms_args.bookmark_bar_pinned = true;
   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                             search_terms_data_);
   EXPECT_EQ("http://www.google.com/?bmbp=1&q=foo", result);
 }
 
 TEST_F(TemplateURLTest, AnswersHasVersion) {
   TemplateURLData data;
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://bar/");
+  search_terms_data_.set_google_base_url("http://bar/");
   data.SetURL("http://bar/search?q={searchTerms}&{google:searchVersion}xssi=t");
 
   TemplateURL url(data);
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
 
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableAnswersInSuggest);
   TemplateURL url2(data);
   result = url2.url_ref().ReplaceSearchTerms(search_terms_args,
                                              search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&gs_rn=42&xssi=t", result);
 }
 
 TEST_F(TemplateURLTest, SessionToken) {
   TemplateURLData data;
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://bar/");
+  search_terms_data_.set_google_base_url("http://bar/");
   data.SetURL("http://bar/search?q={searchTerms}&{google:sessionToken}xssi=t");
 
   TemplateURL url(data);
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
   search_terms_args.session_token = "SESSIONTOKENGOESHERE";
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&psi=SESSIONTOKENGOESHERE&xssi=t", result);
 
   TemplateURL url2(data);
   search_terms_args.session_token = "";
   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                             search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
 }
 
 TEST_F(TemplateURLTest, ContextualSearchParameters) {
   TemplateURLData data;
-  UIThreadSearchTermsData::SetGoogleBaseURL("http://bar/");
+  search_terms_data_.set_google_base_url("http://bar/");
   data.SetURL("http://bar/_/contextualsearch?"
               "{google:contextualSearchVersion}"
               "{google:contextualSearchContextData}");
 
   TemplateURL url(data);
   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                         search_terms_data_);
   EXPECT_EQ("http://bar/_/contextualsearch?", result);
 
   TemplateURLRef::SearchTermsArgs::ContextualSearchParams params(
       1, 6, 11, "allen", "woody+allen+movies", "www.wikipedia.org",
       "utf-8");
   search_terms_args.contextual_search_params = params;
   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
                                             search_terms_data_);
   EXPECT_EQ("http://bar/_/contextualsearch?"
                 "ctxs=1&"
                 "ctxs_start=6&"
                 "ctxs_end=11&"
                 "q=allen&"
                 "ctxs_content=woody+allen+movies&"
                 "ctxs_url=www.wikipedia.org&"
             "ctxs_encoding=utf-8&", result);
 }