Add Android-specific parameters to search_engines/

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"
 #include "chrome/browser/search_engines/template_url.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(ENABLE_RLZ)
 #include "chrome/browser/google/google_util.h"
 #endif
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/search_engines/search_terms_data_android.h"
+#endif
+
 // TestSearchTermsData --------------------------------------------------------
 
 // Simple implementation of SearchTermsData.
 class TestSearchTermsData : public SearchTermsData {
  public:
   explicit TestSearchTermsData(const std::string& google_base_url);
 
   virtual std::string GoogleBaseURLValue() const OVERRIDE;
 
  private:
@@ skipping 440 matching lines @@
 }
 
 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(RLZTracker::CHROME_OMNIBOX, &rlz_string);
   }
+#elif defined(OS_ANDROID)
+  SearchTermsDataAndroid::SetRlzParameterValue(ASCIIToUTF16("android_test"));
+  rlz_string = SearchTermsDataAndroid::GetRlzParameterValue();
 #endif
 
   TemplateURLData data;
   data.SetURL("http://bar/?{google:RLZ}{searchTerms}");
   TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
   GURL result(url.url_ref().ReplaceSearchTerms(
       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("x"))));
   ASSERT_TRUE(result.is_valid());
@@ skipping 145 matching lines @@
   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);
 }
 
+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 string16 terms(ASCIIToUTF16(terms_str));
+  UIThreadSearchTermsData::SetGoogleBaseURL(base_url_str);
+
+  TemplateURLData data;
+  data.SetURL(full_url_str);
+  TemplateURL url(NULL, data);
+  EXPECT_TRUE(url.url_ref().IsValid());
+  ASSERT_TRUE(url.url_ref().SupportsReplacement());
+  TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foobar"));
+
+  // Check that the URL is correct when a client is not present.

[Peter Kasting, 2012/12/06 07:02:37]

This test relies on non-Android having no client.  I'd rather not hardcode that
kind of assumption.

Unfortunately, I can't think of a good way to write the test so it's still
meaningful in that case.  Checking if SearchTermsData returns an empty client
string and then checking that calling ReplaceSearchTerms() substitutes the empty
string makes the test somewhat vacuous.

Perhaps the test should just be entirely "#if defined(OS_ANDROID)" with a
comment that for now only Android uses the search client?  I dunno.

[gone, 2012/12/06 20:59:49]

I've moved the OS_ANDROID flag to encapsulate the whole test.  If desktop Chrome
ever starts adding in this flag, we can revisit where the guards can go...

+  GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args));
+  ASSERT_TRUE(result.is_valid());
+  EXPECT_EQ("http://google.com/?foobar&", result.spec());
+
+#if defined(OS_ANDROID)
+  // Check that the URL is correct when a client is present.
+  SearchTermsDataAndroid::SetSearchClient("android_test");
+  GURL result_2(url.url_ref().ReplaceSearchTerms(search_terms_args));
+  ASSERT_TRUE(result_2.is_valid());
+  EXPECT_EQ("http://google.com/?foobar&client=android_test&", 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(NULL, data);
   ASSERT_EQ(3U, url.URLCount());
   EXPECT_EQ("http://google.com/alt?q={searchTerms}", url.GetURL(0));
   EXPECT_EQ("{google:baseURL}/alt/#q={searchTerms}", url.GetURL(1));
@@ skipping 80 matching lines @@
   EXPECT_EQ(string16(), result);
 
   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
       GURL("http://google.com/alt/?q=123#q="), &result));
   EXPECT_EQ(string16(), result);
 
   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
       GURL("http://google.com/alt/?q=#q=123"), &result));
   EXPECT_EQ(ASCIIToUTF16("123"), result);
 }