A working implementation of AQS (Assisted Query Stats).

chrome/browser/autocomplete/search_provider_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 "chrome/browser/autocomplete/search_provider.h"
 
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 192 matching lines @@
     AutocompleteMatch* wyt_match) {
   QueryForInput(text, string16(), false);
   profile_.BlockUntilHistoryProcessesPendingRequests();
   ASSERT_NO_FATAL_FAILURE(FinishDefaultSuggestQuery());
   EXPECT_NE(profile_.GetPrefs()->GetBoolean(prefs::kInstantEnabled),
             provider_->done());
   if (!wyt_match)
     return;
   ASSERT_GE(provider_->matches().size(), 1u);
   EXPECT_TRUE(FindMatchWithDestination(GURL(
-      default_t_url_->url_ref().ReplaceSearchTerms(text,
-          TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16())), wyt_match));
+      default_t_url_->url_ref().ReplaceSearchTerms(
+          TemplateURLRef::SearchTermsArgs(text))),
+      wyt_match));
 }
 
 void SearchProviderTest::TearDown() {
   message_loop_.RunAllPending();
 
   // Shutdown the provider before the profile.
   provider_ = NULL;
 }
 
 GURL SearchProviderTest::AddSearchToHistory(TemplateURL* t_url,
                                             string16 term,
                                             int visit_count) {
   HistoryService* history =
       profile_.GetHistoryService(Profile::EXPLICIT_ACCESS);
-  GURL search(t_url->url_ref().ReplaceSearchTerms(term,
-      TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
+  GURL search(t_url->url_ref().ReplaceSearchTerms(
+      TemplateURLRef::SearchTermsArgs(term)));
   static base::Time last_added_time;
   last_added_time = std::max(base::Time::Now(),
       last_added_time + base::TimeDelta::FromMicroseconds(1));
   history->AddPageWithDetails(search, string16(), visit_count, visit_count,
       last_added_time, false, history::SOURCE_BROWSED);
   history->SetKeywordSearchTermsForURL(search, t_url->id(), term);
   return search;
 }
 
 bool SearchProviderTest::FindMatchWithContents(const string16& contents,
@@ skipping 38 matching lines @@
   string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, string16(), false);
 
   // Make sure the default providers suggest service was queried.
   TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(fetcher);
 
   // And the URL matches what we expected.
   GURL expected_url(default_t_url_->suggestions_url_ref().ReplaceSearchTerms(
-      term, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
+      TemplateURLRef::SearchTermsArgs(term)));
   ASSERT_TRUE(fetcher->GetOriginalURL() == expected_url);
 
   // Tell the SearchProvider the suggest query is done.
   fetcher->set_response_code(200);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   fetcher = NULL;
 
   // Run till the history results complete.
   RunTillProviderDone();
 
   // The SearchProvider is done. Make sure it has a result for the history
   // term term1.
   AutocompleteMatch term1_match;
   EXPECT_TRUE(FindMatchWithDestination(term1_url_, &term1_match));
   // Term1 should not have a description, it's set later.
   EXPECT_TRUE(term1_match.description.empty());
 
   AutocompleteMatch wyt_match;
   EXPECT_TRUE(FindMatchWithDestination(
-      GURL(default_t_url_->url_ref().ReplaceSearchTerms(term,
-          TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16())), &wyt_match));
+      GURL(default_t_url_->url_ref().ReplaceSearchTerms(
+          TemplateURLRef::SearchTermsArgs(term))), &wyt_match));
   EXPECT_TRUE(wyt_match.description.empty());
 
   // The match for term1 should be more relevant than the what you typed result.
   EXPECT_GT(term1_match.relevance, wyt_match.relevance);
 }
 
 TEST_F(SearchProviderTest, HonorPreventInlineAutocomplete) {
   string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, string16(), true);
 
@@ skipping 19 matching lines @@
   default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
   default_fetcher = NULL;
 
   // Make sure the keyword providers suggest service was queried.
   TestURLFetcher* keyword_fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kKeywordProviderURLFetcherID);
   ASSERT_TRUE(keyword_fetcher);
 
   // And the URL matches what we expected.
   GURL expected_url(keyword_t_url_->suggestions_url_ref().ReplaceSearchTerms(
-      term, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
+      TemplateURLRef::SearchTermsArgs(term)));
   ASSERT_TRUE(keyword_fetcher->GetOriginalURL() == expected_url);
 
   // Tell the SearchProvider the keyword suggest query is done.
   keyword_fetcher->set_response_code(200);
   keyword_fetcher->delegate()->OnURLFetchComplete(keyword_fetcher);
   keyword_fetcher = NULL;
 
   // Run till the history results complete.
   RunTillProviderDone();
 
@@ skipping 48 matching lines @@
   // Tell the provider instant is done.
   provider_->FinalizeInstantQuery(ASCIIToUTF16("foo"), ASCIIToUTF16("bar"));
 
   // The provider should now be done.
   EXPECT_TRUE(provider_->done());
 
   // There should be two matches, one for what you typed, the other for
   // 'foobar'.
   EXPECT_EQ(2u, provider_->matches().size());
   GURL instant_url(default_t_url_->url_ref().ReplaceSearchTerms(
-      ASCIIToUTF16("foobar"), TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
-      string16()));
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("foobar"))));
   AutocompleteMatch instant_match;
   EXPECT_TRUE(FindMatchWithDestination(instant_url, &instant_match));
 
   // And the 'foobar' match should not have a description, it'll be set later.
   EXPECT_TRUE(instant_match.description.empty());
 
   // Make sure the what you typed match has no description.
   AutocompleteMatch wyt_match;
   EXPECT_TRUE(FindMatchWithDestination(
-      GURL(default_t_url_->url_ref().ReplaceSearchTerms(ASCIIToUTF16("foo"),
-          TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16())), &wyt_match));
+      GURL(default_t_url_->url_ref().ReplaceSearchTerms(
+          TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("foo")))),
+          &wyt_match));
   EXPECT_TRUE(wyt_match.description.empty());
 
   // The instant search should be more relevant.
   EXPECT_GT(instant_match.relevance, wyt_match.relevance);
 }
 
 // Make sure that if FinalizeInstantQuery is invoked before suggest results
 // return, the suggest text from FinalizeInstantQuery is remembered.
 TEST_F(SearchProviderTest, RememberInstantQuery) {
   PrefService* service = profile_.GetPrefs();
   service->SetBoolean(prefs::kInstantEnabled, true);
 
   QueryForInput(ASCIIToUTF16("foo"), string16(), false);
 
   // Finalize the instant query immediately.
   provider_->FinalizeInstantQuery(ASCIIToUTF16("foo"), ASCIIToUTF16("bar"));
 
   // There should be two matches, one for what you typed, the other for
   // 'foobar'.
   EXPECT_EQ(2u, provider_->matches().size());
   GURL instant_url(default_t_url_->url_ref().ReplaceSearchTerms(
-      ASCIIToUTF16("foobar"), TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
-      string16()));
+      TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("foobar"))));
   AutocompleteMatch instant_match;
   EXPECT_TRUE(FindMatchWithDestination(instant_url, &instant_match));
 
   // Wait until history and the suggest query complete.
   profile_.BlockUntilHistoryProcessesPendingRequests();
   ASSERT_NO_FATAL_FAILURE(FinishDefaultSuggestQuery());
 
   // Provider should be done.
   EXPECT_TRUE(provider_->done());
 
@@ skipping 750 matching lines @@
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[0].style);
   EXPECT_EQ(4U, match.contents_class[1].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL |
             AutocompleteMatch::ACMatchClassification::MATCH,
             match.contents_class[1].style);
   EXPECT_EQ(5U, match.contents_class[2].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[2].style);
 }