Home | History | Annotate | Download | only in autocomplete 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/omnibox/autocomplete_provider.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/command_line.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/message_loop/message_loop.h"
     11 #include "base/strings/string16.h"
     12 #include "base/strings/string_number_conversions.h"
     13 #include "base/strings/string_util.h"
     14 #include "base/strings/utf_string_conversions.h"
     15 #include "chrome/browser/autocomplete/autocomplete_controller.h"
     16 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
     17 #include "chrome/browser/chrome_notification_types.h"
     18 #include "chrome/browser/search_engines/template_url_service_factory.h"
     19 #include "chrome/test/base/testing_browser_process.h"
     20 #include "chrome/test/base/testing_profile.h"
     21 #include "components/metrics/proto/omnibox_event.pb.h"
     22 #include "components/omnibox/autocomplete_input.h"
     23 #include "components/omnibox/autocomplete_match.h"
     24 #include "components/omnibox/autocomplete_provider_listener.h"
     25 #include "components/omnibox/keyword_provider.h"
     26 #include "components/omnibox/search_provider.h"
     27 #include "components/search_engines/search_engines_switches.h"
     28 #include "components/search_engines/template_url.h"
     29 #include "components/search_engines/template_url_service.h"
     30 #include "content/public/browser/notification_observer.h"
     31 #include "content/public/browser/notification_registrar.h"
     32 #include "content/public/browser/notification_source.h"
     33 #include "testing/gtest/include/gtest/gtest.h"
     34 
     35 static std::ostream& operator<<(std::ostream& os,
     36                                 const AutocompleteResult::const_iterator& it) {
     37   return os << static_cast<const AutocompleteMatch*>(&(*it));
     38 }
     39 
     40 namespace {
     41 const size_t kResultsPerProvider = 3;
     42 const char kTestTemplateURLKeyword[] = "t";
     43 }
     44 
     45 // Autocomplete provider that provides known results. Note that this is
     46 // refcounted so that it can also be a task on the message loop.
     47 class TestProvider : public AutocompleteProvider {
     48  public:
     49   TestProvider(int relevance, const base::string16& prefix,
     50                Profile* profile,
     51                const base::string16 match_keyword)
     52       : AutocompleteProvider(AutocompleteProvider::TYPE_SEARCH),
     53         listener_(NULL),
     54         profile_(profile),
     55         relevance_(relevance),
     56         prefix_(prefix),
     57         match_keyword_(match_keyword) {
     58   }
     59 
     60   virtual void Start(const AutocompleteInput& input,
     61                      bool minimal_changes) OVERRIDE;
     62 
     63   void set_listener(AutocompleteProviderListener* listener) {
     64     listener_ = listener;
     65   }
     66 
     67  private:
     68   virtual ~TestProvider() {}
     69 
     70   void Run();
     71 
     72   void AddResults(int start_at, int num);
     73   void AddResultsWithSearchTermsArgs(
     74       int start_at,
     75       int num,
     76       AutocompleteMatch::Type type,
     77       const TemplateURLRef::SearchTermsArgs& search_terms_args);
     78 
     79   AutocompleteProviderListener* listener_;
     80   Profile* profile_;
     81   int relevance_;
     82   const base::string16 prefix_;
     83   const base::string16 match_keyword_;
     84 };
     85 
     86 void TestProvider::Start(const AutocompleteInput& input,
     87                          bool minimal_changes) {
     88   if (minimal_changes)
     89     return;
     90 
     91   matches_.clear();
     92 
     93   // Generate 4 results synchronously, the rest later.
     94   AddResults(0, 1);
     95   AddResultsWithSearchTermsArgs(
     96       1, 1, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
     97       TemplateURLRef::SearchTermsArgs(base::ASCIIToUTF16("echo")));
     98   AddResultsWithSearchTermsArgs(
     99       2, 1, AutocompleteMatchType::NAVSUGGEST,
    100       TemplateURLRef::SearchTermsArgs(base::ASCIIToUTF16("nav")));
    101   AddResultsWithSearchTermsArgs(
    102       3, 1, AutocompleteMatchType::SEARCH_SUGGEST,
    103       TemplateURLRef::SearchTermsArgs(base::ASCIIToUTF16("query")));
    104 
    105   if (input.want_asynchronous_matches()) {
    106     done_ = false;
    107     base::MessageLoop::current()->PostTask(
    108         FROM_HERE, base::Bind(&TestProvider::Run, this));
    109   }
    110 }
    111 
    112 void TestProvider::Run() {
    113   DCHECK_GT(kResultsPerProvider, 0U);
    114   AddResults(1, kResultsPerProvider);
    115   done_ = true;
    116   DCHECK(listener_);
    117   listener_->OnProviderUpdate(true);
    118 }
    119 
    120 void TestProvider::AddResults(int start_at, int num) {
    121   AddResultsWithSearchTermsArgs(start_at,
    122                                 num,
    123                                 AutocompleteMatchType::URL_WHAT_YOU_TYPED,
    124                                 TemplateURLRef::SearchTermsArgs(
    125                                     base::string16()));
    126 }
    127 
    128 void TestProvider::AddResultsWithSearchTermsArgs(
    129     int start_at,
    130     int num,
    131     AutocompleteMatch::Type type,
    132     const TemplateURLRef::SearchTermsArgs& search_terms_args) {
    133   for (int i = start_at; i < num; i++) {
    134     AutocompleteMatch match(this, relevance_ - i, false, type);
    135 
    136     match.fill_into_edit = prefix_ + base::UTF8ToUTF16(base::IntToString(i));
    137     match.destination_url = GURL(base::UTF16ToUTF8(match.fill_into_edit));
    138     match.allowed_to_be_default_match = true;
    139 
    140     match.contents = match.fill_into_edit;
    141     match.contents_class.push_back(
    142         ACMatchClassification(0, ACMatchClassification::NONE));
    143     match.description = match.fill_into_edit;
    144     match.description_class.push_back(
    145         ACMatchClassification(0, ACMatchClassification::NONE));
    146     match.search_terms_args.reset(
    147         new TemplateURLRef::SearchTermsArgs(search_terms_args));
    148     if (!match_keyword_.empty()) {
    149       match.keyword = match_keyword_;
    150       TemplateURLService* service =
    151           TemplateURLServiceFactory::GetForProfile(profile_);
    152       ASSERT_TRUE(match.GetTemplateURL(service, false) != NULL);
    153     }
    154 
    155     matches_.push_back(match);
    156   }
    157 }
    158 
    159 class AutocompleteProviderTest : public testing::Test,
    160                                  public content::NotificationObserver {
    161  protected:
    162   struct KeywordTestData {
    163     const base::string16 fill_into_edit;
    164     const base::string16 keyword;
    165     const base::string16 expected_associated_keyword;
    166   };
    167 
    168   struct AssistedQueryStatsTestData {
    169     const AutocompleteMatch::Type match_type;
    170     const std::string expected_aqs;
    171   };
    172 
    173  protected:
    174    // Registers a test TemplateURL under the given keyword.
    175   void RegisterTemplateURL(const base::string16 keyword,
    176                            const std::string& template_url);
    177 
    178   // Resets |controller_| with two TestProviders.  |provider1_ptr| and
    179   // |provider2_ptr| are updated to point to the new providers if non-NULL.
    180   void ResetControllerWithTestProviders(bool same_destinations,
    181                                         TestProvider** provider1_ptr,
    182                                         TestProvider** provider2_ptr);
    183 
    184   // Runs a query on the input "a", and makes sure both providers' input is
    185   // properly collected.
    186   void RunTest();
    187 
    188   // Constructs an AutocompleteResult from |match_data|, sets the |controller_|
    189   // to pretend it was running against input |input|, calls the |controller_|'s
    190   // UpdateAssociatedKeywords, and checks that the matches have associated
    191   // keywords as expected.
    192   void RunKeywordTest(const base::string16& input,
    193                       const KeywordTestData* match_data,
    194                       size_t size);
    195 
    196   void RunAssistedQueryStatsTest(
    197       const AssistedQueryStatsTestData* aqs_test_data,
    198       size_t size);
    199 
    200   void RunQuery(const base::string16 query);
    201 
    202   void ResetControllerWithKeywordAndSearchProviders();
    203   void ResetControllerWithKeywordProvider();
    204   void RunExactKeymatchTest(bool allow_exact_keyword_match);
    205 
    206   void CopyResults();
    207 
    208   // Returns match.destination_url as it would be set by
    209   // AutocompleteController::UpdateMatchDestinationURL().
    210   GURL GetDestinationURL(AutocompleteMatch match,
    211                          base::TimeDelta query_formulation_time) const;
    212 
    213   AutocompleteResult result_;
    214   scoped_ptr<AutocompleteController> controller_;
    215 
    216  private:
    217   // content::NotificationObserver:
    218   virtual void Observe(int type,
    219                        const content::NotificationSource& source,
    220                        const content::NotificationDetails& details) OVERRIDE;
    221 
    222   base::MessageLoopForUI message_loop_;
    223   content::NotificationRegistrar registrar_;
    224   TestingProfile profile_;
    225 };
    226 
    227 void AutocompleteProviderTest::RegisterTemplateURL(
    228     const base::string16 keyword,
    229     const std::string& template_url) {
    230   if (TemplateURLServiceFactory::GetForProfile(&profile_) == NULL) {
    231     TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
    232         &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
    233   }
    234   TemplateURLData data;
    235   data.SetURL(template_url);
    236   data.SetKeyword(keyword);
    237   TemplateURL* default_t_url = new TemplateURL(data);
    238   TemplateURLService* turl_model =
    239       TemplateURLServiceFactory::GetForProfile(&profile_);
    240   turl_model->Add(default_t_url);
    241   turl_model->SetUserSelectedDefaultSearchProvider(default_t_url);
    242   turl_model->Load();
    243   TemplateURLID default_provider_id = default_t_url->id();
    244   ASSERT_NE(0, default_provider_id);
    245 }
    246 
    247 void AutocompleteProviderTest::ResetControllerWithTestProviders(
    248     bool same_destinations,
    249     TestProvider** provider1_ptr,
    250     TestProvider** provider2_ptr) {
    251   // TODO: Move it outside this method, after refactoring the existing
    252   // unit tests.  Specifically:
    253   //   (1) Make sure that AutocompleteMatch.keyword is set iff there is
    254   //       a corresponding call to RegisterTemplateURL; otherwise the
    255   //       controller flow will crash; this practically means that
    256   //       RunTests/ResetControllerXXX/RegisterTemplateURL should
    257   //       be coordinated with each other.
    258   //   (2) Inject test arguments rather than rely on the hardcoded values, e.g.
    259   //       don't rely on kResultsPerProvided and default relevance ordering
    260   //       (B > A).
    261   RegisterTemplateURL(base::ASCIIToUTF16(kTestTemplateURLKeyword),
    262                       "http://aqs/{searchTerms}/{google:assistedQueryStats}");
    263 
    264   AutocompleteController::Providers providers;
    265 
    266   // Construct two new providers, with either the same or different prefixes.
    267   TestProvider* provider1 = new TestProvider(
    268       kResultsPerProvider,
    269       base::ASCIIToUTF16("http://a"),
    270       &profile_,
    271       base::ASCIIToUTF16(kTestTemplateURLKeyword));
    272   providers.push_back(provider1);
    273 
    274   TestProvider* provider2 = new TestProvider(
    275       kResultsPerProvider * 2,
    276       same_destinations ? base::ASCIIToUTF16("http://a")
    277                         : base::ASCIIToUTF16("http://b"),
    278       &profile_,
    279       base::string16());
    280   providers.push_back(provider2);
    281 
    282   // Reset the controller to contain our new providers.
    283   controller_.reset(new AutocompleteController(
    284       &profile_, TemplateURLServiceFactory::GetForProfile(&profile_), NULL, 0));
    285   // We're going to swap the providers vector, but the old vector should be
    286   // empty so no elements need to be freed at this point.
    287   EXPECT_TRUE(controller_->providers_.empty());
    288   controller_->providers_.swap(providers);
    289   provider1->set_listener(controller_.get());
    290   provider2->set_listener(controller_.get());
    291 
    292   // The providers don't complete synchronously, so listen for "result updated"
    293   // notifications.
    294   registrar_.Add(this,
    295                  chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
    296                  content::Source<AutocompleteController>(controller_.get()));
    297 
    298   if (provider1_ptr)
    299     *provider1_ptr = provider1;
    300   if (provider2_ptr)
    301     *provider2_ptr = provider2;
    302 }
    303 
    304 void AutocompleteProviderTest::
    305     ResetControllerWithKeywordAndSearchProviders() {
    306   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
    307       &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
    308 
    309   // Reset the default TemplateURL.
    310   TemplateURLData data;
    311   data.SetURL("http://defaultturl/{searchTerms}");
    312   TemplateURL* default_t_url = new TemplateURL(data);
    313   TemplateURLService* turl_model =
    314       TemplateURLServiceFactory::GetForProfile(&profile_);
    315   turl_model->Add(default_t_url);
    316   turl_model->SetUserSelectedDefaultSearchProvider(default_t_url);
    317   TemplateURLID default_provider_id = default_t_url->id();
    318   ASSERT_NE(0, default_provider_id);
    319 
    320   // Create another TemplateURL for KeywordProvider.
    321   TemplateURLData data2;
    322   data2.short_name = base::ASCIIToUTF16("k");
    323   data2.SetKeyword(base::ASCIIToUTF16("k"));
    324   data2.SetURL("http://keyword/{searchTerms}");
    325   TemplateURL* keyword_t_url = new TemplateURL(data2);
    326   turl_model->Add(keyword_t_url);
    327   ASSERT_NE(0, keyword_t_url->id());
    328 
    329   controller_.reset(new AutocompleteController(
    330       &profile_, TemplateURLServiceFactory::GetForProfile(&profile_), NULL,
    331       AutocompleteProvider::TYPE_KEYWORD | AutocompleteProvider::TYPE_SEARCH));
    332 }
    333 
    334 void AutocompleteProviderTest::ResetControllerWithKeywordProvider() {
    335   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
    336       &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
    337 
    338   TemplateURLService* turl_model =
    339       TemplateURLServiceFactory::GetForProfile(&profile_);
    340 
    341   // Create a TemplateURL for KeywordProvider.
    342   TemplateURLData data;
    343   data.short_name = base::ASCIIToUTF16("foo.com");
    344   data.SetKeyword(base::ASCIIToUTF16("foo.com"));
    345   data.SetURL("http://foo.com/{searchTerms}");
    346   TemplateURL* keyword_t_url = new TemplateURL(data);
    347   turl_model->Add(keyword_t_url);
    348   ASSERT_NE(0, keyword_t_url->id());
    349 
    350   // Make a TemplateURL for KeywordProvider that a shorter version of the
    351   // first.
    352   data.short_name = base::ASCIIToUTF16("f");
    353   data.SetKeyword(base::ASCIIToUTF16("f"));
    354   data.SetURL("http://f.com/{searchTerms}");
    355   keyword_t_url = new TemplateURL(data);
    356   turl_model->Add(keyword_t_url);
    357   ASSERT_NE(0, keyword_t_url->id());
    358 
    359   // Create another TemplateURL for KeywordProvider.
    360   data.short_name = base::ASCIIToUTF16("bar.com");
    361   data.SetKeyword(base::ASCIIToUTF16("bar.com"));
    362   data.SetURL("http://bar.com/{searchTerms}");
    363   keyword_t_url = new TemplateURL(data);
    364   turl_model->Add(keyword_t_url);
    365   ASSERT_NE(0, keyword_t_url->id());
    366 
    367   controller_.reset(new AutocompleteController(
    368       &profile_, TemplateURLServiceFactory::GetForProfile(&profile_), NULL,
    369       AutocompleteProvider::TYPE_KEYWORD));
    370 }
    371 
    372 void AutocompleteProviderTest::RunTest() {
    373   RunQuery(base::ASCIIToUTF16("a"));
    374 }
    375 
    376 void AutocompleteProviderTest::RunKeywordTest(const base::string16& input,
    377                                               const KeywordTestData* match_data,
    378                                               size_t size) {
    379   ACMatches matches;
    380   for (size_t i = 0; i < size; ++i) {
    381     AutocompleteMatch match;
    382     match.relevance = 1000;  // Arbitrary non-zero value.
    383     match.allowed_to_be_default_match = true;
    384     match.fill_into_edit = match_data[i].fill_into_edit;
    385     match.transition = ui::PAGE_TRANSITION_KEYWORD;
    386     match.keyword = match_data[i].keyword;
    387     matches.push_back(match);
    388   }
    389 
    390   AutocompleteResult result;
    391   result.AppendMatches(matches);
    392   controller_->input_ = AutocompleteInput(
    393       input, base::string16::npos, base::string16(), GURL(),
    394       metrics::OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS,
    395       false, true, true, true, ChromeAutocompleteSchemeClassifier(&profile_));
    396   controller_->UpdateAssociatedKeywords(&result);
    397 
    398   for (size_t j = 0; j < result.size(); ++j) {
    399     EXPECT_EQ(match_data[j].expected_associated_keyword,
    400               result.match_at(j)->associated_keyword.get() ?
    401                   result.match_at(j)->associated_keyword->keyword :
    402                   base::string16());
    403   }
    404 }
    405 
    406 void AutocompleteProviderTest::RunAssistedQueryStatsTest(
    407     const AssistedQueryStatsTestData* aqs_test_data,
    408     size_t size) {
    409   // Prepare input.
    410   const size_t kMaxRelevance = 1000;
    411   ACMatches matches;
    412   for (size_t i = 0; i < size; ++i) {
    413     AutocompleteMatch match(NULL, kMaxRelevance - i, false,
    414                             aqs_test_data[i].match_type);
    415     match.allowed_to_be_default_match = true;
    416     match.keyword = base::ASCIIToUTF16(kTestTemplateURLKeyword);
    417     match.search_terms_args.reset(
    418         new TemplateURLRef::SearchTermsArgs(base::string16()));
    419     matches.push_back(match);
    420   }
    421   result_.Reset();
    422   result_.AppendMatches(matches);
    423 
    424   // Update AQS.
    425   controller_->UpdateAssistedQueryStats(&result_);
    426 
    427   // Verify data.
    428   for (size_t i = 0; i < size; ++i) {
    429     EXPECT_EQ(aqs_test_data[i].expected_aqs,
    430               result_.match_at(i)->search_terms_args->assisted_query_stats);
    431   }
    432 }
    433 
    434 void AutocompleteProviderTest::RunQuery(const base::string16 query) {
    435   result_.Reset();
    436   controller_->Start(AutocompleteInput(
    437       query, base::string16::npos, base::string16(), GURL(),
    438       metrics::OmniboxEventProto::INVALID_SPEC, true, false, true, true,
    439       ChromeAutocompleteSchemeClassifier(&profile_)));
    440 
    441   if (!controller_->done())
    442     // The message loop will terminate when all autocomplete input has been
    443     // collected.
    444     base::MessageLoop::current()->Run();
    445 }
    446 
    447 void AutocompleteProviderTest::RunExactKeymatchTest(
    448     bool allow_exact_keyword_match) {
    449   // Send the controller input which exactly matches the keyword provider we
    450   // created in ResetControllerWithKeywordAndSearchProviders().  The default
    451   // match should thus be a search-other-engine match iff
    452   // |allow_exact_keyword_match| is true.  Regardless, the match should
    453   // be from SearchProvider.  (It provides all verbatim search matches,
    454   // keyword or not.)
    455   controller_->Start(AutocompleteInput(
    456       base::ASCIIToUTF16("k test"), base::string16::npos, base::string16(),
    457       GURL(), metrics::OmniboxEventProto::INVALID_SPEC, true, false,
    458       allow_exact_keyword_match, false,
    459       ChromeAutocompleteSchemeClassifier(&profile_)));
    460   EXPECT_TRUE(controller_->done());
    461   EXPECT_EQ(AutocompleteProvider::TYPE_SEARCH,
    462       controller_->result().default_match()->provider->type());
    463   EXPECT_EQ(allow_exact_keyword_match ?
    464       AutocompleteMatchType::SEARCH_OTHER_ENGINE :
    465       AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
    466       controller_->result().default_match()->type);
    467 }
    468 
    469 void AutocompleteProviderTest::CopyResults() {
    470   result_.CopyFrom(controller_->result());
    471 }
    472 
    473 GURL AutocompleteProviderTest::GetDestinationURL(
    474     AutocompleteMatch match,
    475     base::TimeDelta query_formulation_time) const {
    476   controller_->UpdateMatchDestinationURLWithQueryFormulationTime(
    477       query_formulation_time, &match);
    478   return match.destination_url;
    479 }
    480 
    481 void AutocompleteProviderTest::Observe(
    482     int type,
    483     const content::NotificationSource& source,
    484     const content::NotificationDetails& details) {
    485   if (controller_->done()) {
    486     CopyResults();
    487     base::MessageLoop::current()->Quit();
    488   }
    489 }
    490 
    491 // Tests that the default selection is set properly when updating results.
    492 TEST_F(AutocompleteProviderTest, Query) {
    493   TestProvider* provider1 = NULL;
    494   TestProvider* provider2 = NULL;
    495   ResetControllerWithTestProviders(false, &provider1, &provider2);
    496   RunTest();
    497 
    498   // Make sure the default match gets set to the highest relevance match.  The
    499   // highest relevance matches should come from the second provider.
    500   EXPECT_EQ(kResultsPerProvider * 2, result_.size());
    501   ASSERT_NE(result_.end(), result_.default_match());
    502   EXPECT_EQ(provider2, result_.default_match()->provider);
    503 }
    504 
    505 // Tests assisted query stats.
    506 TEST_F(AutocompleteProviderTest, AssistedQueryStats) {
    507   ResetControllerWithTestProviders(false, NULL, NULL);
    508   RunTest();
    509 
    510   ASSERT_EQ(kResultsPerProvider * 2, result_.size());
    511 
    512   // Now, check the results from the second provider, as they should not have
    513   // assisted query stats set.
    514   for (size_t i = 0; i < kResultsPerProvider; ++i) {
    515     EXPECT_TRUE(
    516         result_.match_at(i)->search_terms_args->assisted_query_stats.empty());
    517   }
    518   // The first provider has a test keyword, so AQS should be non-empty.
    519   for (size_t i = kResultsPerProvider; i < kResultsPerProvider * 2; ++i) {
    520     EXPECT_FALSE(
    521         result_.match_at(i)->search_terms_args->assisted_query_stats.empty());
    522   }
    523 }
    524 
    525 TEST_F(AutocompleteProviderTest, RemoveDuplicates) {
    526   TestProvider* provider1 = NULL;
    527   TestProvider* provider2 = NULL;
    528   ResetControllerWithTestProviders(true, &provider1, &provider2);
    529   RunTest();
    530 
    531   // Make sure all the first provider's results were eliminated by the second
    532   // provider's.
    533   EXPECT_EQ(kResultsPerProvider, result_.size());
    534   for (AutocompleteResult::const_iterator i(result_.begin());
    535        i != result_.end(); ++i)
    536     EXPECT_EQ(provider2, i->provider);
    537 }
    538 
    539 TEST_F(AutocompleteProviderTest, AllowExactKeywordMatch) {
    540   ResetControllerWithKeywordAndSearchProviders();
    541   RunExactKeymatchTest(true);
    542   RunExactKeymatchTest(false);
    543 }
    544 
    545 // Ensures matches from (only) the default search provider respect any extra
    546 // query params set on the command line.
    547 TEST_F(AutocompleteProviderTest, ExtraQueryParams) {
    548   ResetControllerWithKeywordAndSearchProviders();
    549   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
    550       switches::kExtraSearchQueryParams, "a=b");
    551   RunExactKeymatchTest(true);
    552   CopyResults();
    553   ASSERT_EQ(2U, result_.size());
    554   EXPECT_EQ("http://keyword/test",
    555             result_.match_at(0)->destination_url.possibly_invalid_spec());
    556   EXPECT_EQ("http://defaultturl/k%20test?a=b",
    557             result_.match_at(1)->destination_url.possibly_invalid_spec());
    558 }
    559 
    560 // Test that redundant associated keywords are removed.
    561 TEST_F(AutocompleteProviderTest, RedundantKeywordsIgnoredInResult) {
    562   ResetControllerWithKeywordProvider();
    563 
    564   {
    565     KeywordTestData duplicate_url[] = {
    566       { base::ASCIIToUTF16("fo"), base::string16(), base::string16() },
    567       { base::ASCIIToUTF16("foo.com"), base::string16(),
    568         base::ASCIIToUTF16("foo.com") },
    569       { base::ASCIIToUTF16("foo.com"), base::string16(), base::string16() }
    570     };
    571 
    572     SCOPED_TRACE("Duplicate url");
    573     RunKeywordTest(base::ASCIIToUTF16("fo"), duplicate_url,
    574                    ARRAYSIZE_UNSAFE(duplicate_url));
    575   }
    576 
    577   {
    578     KeywordTestData keyword_match[] = {
    579       { base::ASCIIToUTF16("foo.com"), base::ASCIIToUTF16("foo.com"),
    580         base::string16() },
    581       { base::ASCIIToUTF16("foo.com"), base::string16(), base::string16() }
    582     };
    583 
    584     SCOPED_TRACE("Duplicate url with keyword match");
    585     RunKeywordTest(base::ASCIIToUTF16("fo"), keyword_match,
    586                    ARRAYSIZE_UNSAFE(keyword_match));
    587   }
    588 
    589   {
    590     KeywordTestData multiple_keyword[] = {
    591       { base::ASCIIToUTF16("fo"), base::string16(), base::string16() },
    592       { base::ASCIIToUTF16("foo.com"), base::string16(),
    593         base::ASCIIToUTF16("foo.com") },
    594       { base::ASCIIToUTF16("foo.com"), base::string16(), base::string16() },
    595       { base::ASCIIToUTF16("bar.com"), base::string16(),
    596         base::ASCIIToUTF16("bar.com") },
    597     };
    598 
    599     SCOPED_TRACE("Duplicate url with multiple keywords");
    600     RunKeywordTest(base::ASCIIToUTF16("fo"), multiple_keyword,
    601                    ARRAYSIZE_UNSAFE(multiple_keyword));
    602   }
    603 }
    604 
    605 // Test that exact match keywords trump keywords associated with
    606 // the match.
    607 TEST_F(AutocompleteProviderTest, ExactMatchKeywords) {
    608   ResetControllerWithKeywordProvider();
    609 
    610   {
    611     KeywordTestData keyword_match[] = {
    612       { base::ASCIIToUTF16("foo.com"), base::string16(),
    613         base::ASCIIToUTF16("foo.com") }
    614     };
    615 
    616     SCOPED_TRACE("keyword match as usual");
    617     RunKeywordTest(base::ASCIIToUTF16("fo"), keyword_match,
    618                    ARRAYSIZE_UNSAFE(keyword_match));
    619   }
    620 
    621   // The same result set with an input of "f" (versus "fo") should get
    622   // a different associated keyword because "f" is an exact match for
    623   // a keyword and that should trump the keyword normally associated with
    624   // this match.
    625   {
    626     KeywordTestData keyword_match[] = {
    627       { base::ASCIIToUTF16("foo.com"), base::string16(),
    628         base::ASCIIToUTF16("f") }
    629     };
    630 
    631     SCOPED_TRACE("keyword exact match");
    632     RunKeywordTest(base::ASCIIToUTF16("f"), keyword_match,
    633                    ARRAYSIZE_UNSAFE(keyword_match));
    634   }
    635 }
    636 
    637 TEST_F(AutocompleteProviderTest, UpdateAssistedQueryStats) {
    638   ResetControllerWithTestProviders(false, NULL, NULL);
    639 
    640   {
    641     AssistedQueryStatsTestData test_data[] = {
    642       //  MSVC doesn't support zero-length arrays, so supply some dummy data.
    643       { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, "" }
    644     };
    645     SCOPED_TRACE("No matches");
    646     // Note: We pass 0 here to ignore the dummy data above.
    647     RunAssistedQueryStatsTest(test_data, 0);
    648   }
    649 
    650   {
    651     AssistedQueryStatsTestData test_data[] = {
    652       { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, "chrome..69i57" }
    653     };
    654     SCOPED_TRACE("One match");
    655     RunAssistedQueryStatsTest(test_data, ARRAYSIZE_UNSAFE(test_data));
    656   }
    657 
    658   {
    659     AssistedQueryStatsTestData test_data[] = {
    660       { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
    661         "chrome..69i57j69i58j5l2j0l3j69i59" },
    662       { AutocompleteMatchType::URL_WHAT_YOU_TYPED,
    663         "chrome..69i57j69i58j5l2j0l3j69i59" },
    664       { AutocompleteMatchType::NAVSUGGEST,
    665         "chrome.2.69i57j69i58j5l2j0l3j69i59" },
    666       { AutocompleteMatchType::NAVSUGGEST,
    667         "chrome.3.69i57j69i58j5l2j0l3j69i59" },
    668       { AutocompleteMatchType::SEARCH_SUGGEST,
    669         "chrome.4.69i57j69i58j5l2j0l3j69i59" },
    670       { AutocompleteMatchType::SEARCH_SUGGEST,
    671         "chrome.5.69i57j69i58j5l2j0l3j69i59" },
    672       { AutocompleteMatchType::SEARCH_SUGGEST,
    673         "chrome.6.69i57j69i58j5l2j0l3j69i59" },
    674       { AutocompleteMatchType::SEARCH_HISTORY,
    675         "chrome.7.69i57j69i58j5l2j0l3j69i59" },
    676     };
    677     SCOPED_TRACE("Multiple matches");
    678     RunAssistedQueryStatsTest(test_data, ARRAYSIZE_UNSAFE(test_data));
    679   }
    680 }
    681 
    682 TEST_F(AutocompleteProviderTest, GetDestinationURL) {
    683   ResetControllerWithKeywordAndSearchProviders();
    684 
    685   // For the destination URL to have aqs parameters for query formulation time
    686   // and the field trial triggered bit, many conditions need to be satisfied.
    687   AutocompleteMatch match(NULL, 1100, false,
    688                           AutocompleteMatchType::SEARCH_SUGGEST);
    689   GURL url(GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456)));
    690   EXPECT_TRUE(url.path().empty());
    691 
    692   // The protocol needs to be https.
    693   RegisterTemplateURL(base::ASCIIToUTF16(kTestTemplateURLKeyword),
    694                       "https://aqs/{searchTerms}/{google:assistedQueryStats}");
    695   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
    696   EXPECT_TRUE(url.path().empty());
    697 
    698   // There needs to be a keyword provider.
    699   match.keyword = base::ASCIIToUTF16(kTestTemplateURLKeyword);
    700   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
    701   EXPECT_TRUE(url.path().empty());
    702 
    703   // search_terms_args needs to be set.
    704   match.search_terms_args.reset(
    705       new TemplateURLRef::SearchTermsArgs(base::string16()));
    706   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
    707   EXPECT_TRUE(url.path().empty());
    708 
    709   // assisted_query_stats needs to have been previously set.
    710   match.search_terms_args->assisted_query_stats =
    711       "chrome.0.69i57j69i58j5l2j0l3j69i59";
    712   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
    713   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j0j0&", url.path());
    714 
    715   // Test field trial triggered bit set.
    716   controller_->search_provider_->field_trial_triggered_in_session_ = true;
    717   EXPECT_TRUE(
    718       controller_->search_provider_->field_trial_triggered_in_session());
    719   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
    720   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j1j0&", url.path());
    721 
    722   // Test page classification set.
    723   controller_->input_.current_page_classification_ =
    724       metrics::OmniboxEventProto::OTHER;
    725   controller_->search_provider_->field_trial_triggered_in_session_ = false;
    726   EXPECT_FALSE(
    727       controller_->search_provider_->field_trial_triggered_in_session());
    728   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
    729   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j0j4&", url.path());
    730 
    731   // Test page classification and field trial triggered set.
    732   controller_->search_provider_->field_trial_triggered_in_session_ = true;
    733   EXPECT_TRUE(
    734       controller_->search_provider_->field_trial_triggered_in_session());
    735   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
    736   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j1j4&", url.path());
    737 }
    738