A working implementation of AQS (Assisted Query Stats).

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 75 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];
     TemplateURLData data;
     data.SetURL(value.url);
     TemplateURL url(NULL, data);
     EXPECT_TRUE(url.url_ref().IsValid());
     ASSERT_TRUE(url.url_ref().SupportsReplacement());
-    GURL result(url.url_ref().ReplaceSearchTerms(value.terms,
-        TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
+    GURL result(url.url_ref().ReplaceSearchTerms(
+        TemplateURLRef::SearchTermsArgs(value.terms)));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(value.output, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, URLRefTestCount) {
   TemplateURLData data;
   data.SetURL("http://foo{searchTerms}{count?}");
   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()));
+  GURL result(url.url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X"))));
   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(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()));
+  GURL result(url.url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X"))));
   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(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()));
+  GURL result(url.url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X"))));
   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(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()));
+  GURL result(url.url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X"))));
   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(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()));
+  GURL result(url.url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X"))));
   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}bar");
   TemplateURL url(NULL, data);
@@ skipping 11 matching lines @@
   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(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()));
+  GURL result(url.url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X"))));
   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(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()));
+  GURL result(url.url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X"))));
   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(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));
+    GURL result(url.url_ref().ReplaceSearchTermsUsingTermsData(
+        TemplateURLRef::SearchTermsArgs(value.terms), search_terms_data));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(value.output, result.spec());
   }
 }
 
 TEST_F(TemplateURLTest, URLRefTermToWide) {
   struct ToWideCase {
     const char* encoded_search_term;
     const string16 expected_decoded_term;
   } to_wide_cases[] = {
@@ skipping 83 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(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()));
+    GURL result(url.url_ref().ReplaceSearchTerms(
+        TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X"))));
     ASSERT_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 {
@@ skipping 16 matching lines @@
       "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(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()));
+    GURL result(url.url_ref().ReplaceSearchTerms(
+        TemplateURLRef::SearchTermsArgs(test_data[i].search_term)));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
+}
+
+// Tests replacing assisted query stats (AQS) in various scenarios.
+TEST_F(TemplateURLTest, ReplaceAssistedQueryStats) {
+  struct TestData {
+    const string16 search_term;
+    const std::string aqs;
+    const std::string base_url;
+    const std::string url;
+    const std::string expected_result;
+  } test_data[] = {
+    // No HTTPS, no AQS.
+    { ASCIIToUTF16("foo"),
+      "chrome.0.0l6",
+      "http://foo/",
+      "{google:baseURL}?{searchTerms}{google:assistedQueryStats}",
+      "http://foo/?foo" },
+    // HTTPS available, AQS should be replaced.
+    { ASCIIToUTF16("foo"),
+      "chrome.0.0l6",
+      "https://foo/",
+      "{google:baseURL}?{searchTerms}{google:assistedQueryStats}",
+      "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.

[Peter Kasting, 2012/06/22 23:18:11]

We should also test that a non-Google base URL _with_ HTTPS allows AQS.

[Bart N, 2012/06/23 01:06:30]

Done.

+    { ASCIIToUTF16("foo"),
+      "chrome.0.0l6",
+      "",
+      "http://foo?{searchTerms}{google:assistedQueryStats}",
+      "http://foo/?foo" },
+  };
+  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(NULL, data);
+    EXPECT_TRUE(url.url_ref().IsValid());
+    ASSERT_TRUE(url.url_ref().SupportsReplacement());
+    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);
+    GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args));
+    ASSERT_TRUE(result.is_valid());
+    EXPECT_EQ(test_data[i].expected_result, result.spec());
+  }
 }
 
 TEST_F(TemplateURLTest, Suggestions) {
   struct TestData {
     const int accepted_suggestion;
     const string16 original_query_for_suggestion;
     const std::string expected_result;
   } test_data[] = {
     { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16(),
       "http://bar/foo?q=foobar" },
     { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, ASCIIToUTF16("foo"),
       "http://bar/foo?q=foobar" },
     { TemplateURLRef::NO_SUGGESTION_CHOSEN, string16(),
       "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(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));
+    TemplateURLRef::SearchTermsArgs search_terms_args(
+        ASCIIToUTF16("foobar"));
+    search_terms_args.accepted_suggestion = test_data[i].accepted_suggestion;
+    search_terms_args.original_query =
+        test_data[i].original_query_for_suggestion;
+    GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args));
     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(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()));
+  GURL result(url.url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("x"))));
   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());
 }
 #endif
 
 TEST_F(TemplateURLTest, HostAndSearchTermKey) {
@@ skipping 136 matching lines @@
   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);
 }