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