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 "chrome/browser/autocomplete/autocomplete_controller.h"
6
7 #include <set>
8 #include <string>
9
10 #include "base/command_line.h"
11 #include "base/format_macros.h"
12 #include "base/logging.h"
13 #include "base/metrics/histogram.h"
14 #include "base/strings/string_number_conversions.h"
15 #include "base/strings/stringprintf.h"
16 #include "base/time/time.h"
17 #include "chrome/browser/autocomplete/autocomplete_controller_delegate.h"
18 #include "chrome/browser/autocomplete/bookmark_provider.h"
19 #include "chrome/browser/autocomplete/builtin_provider.h"
20 #include "chrome/browser/autocomplete/extension_app_provider.h"
21 #include "chrome/browser/autocomplete/history_quick_provider.h"
22 #include "chrome/browser/autocomplete/history_url_provider.h"
23 #include "chrome/browser/autocomplete/keyword_provider.h"
24 #include "chrome/browser/autocomplete/search_provider.h"
25 #include "chrome/browser/autocomplete/shortcuts_provider.h"
26 #include "chrome/browser/autocomplete/zero_suggest_provider.h"
27 #include "chrome/browser/chrome_notification_types.h"
28 #include "chrome/browser/omnibox/omnibox_field_trial.h"
29 #include "chrome/browser/profiles/profile.h"
30 #include "chrome/browser/search/search.h"
31 #include "chrome/browser/search_engines/template_url.h"
32 #include "chrome/common/chrome_switches.h"
33 #include "content/public/browser/notification_service.h"
34 #include "grit/generated_resources.h"
35 #include "grit/theme_resources.h"
36 #include "ui/base/l10n/l10n_util.h"
37
38 #if defined(OS_CHROMEOS)
39 #include "chrome/browser/autocomplete/contact_provider_chromeos.h"
40 #include "chrome/browser/chromeos/contacts/contact_manager.h"
41 #endif
42
43 namespace {
44
45 // Converts the given match to a type (and possibly subtype) based on the AQS
46 // specification. For more details, see
47 // http://goto.google.com/binary-clients-logging.
AutocompleteMatchToAssistedQuery(const AutocompleteMatch::Type & match,size_t * type,size_t * subtype)48 void AutocompleteMatchToAssistedQuery(
49 const AutocompleteMatch::Type& match, size_t* type, size_t* subtype) {
50 // This type indicates a native chrome suggestion.
51 *type = 69;
52 // Default value, indicating no subtype.
53 *subtype = base::string16::npos;
54
55 switch (match) {
56 case AutocompleteMatchType::SEARCH_SUGGEST: {
57 *type = 0;
58 return;
59 }
60 case AutocompleteMatchType::SEARCH_SUGGEST_ENTITY: {
61 *subtype = 46;
62 return;
63 }
64 case AutocompleteMatchType::SEARCH_SUGGEST_INFINITE: {
65 *subtype = 33;
66 return;
67 }
68 case AutocompleteMatchType::SEARCH_SUGGEST_PERSONALIZED: {
69 *subtype = 35;
70 return;
71 }
72 case AutocompleteMatchType::SEARCH_SUGGEST_PROFILE: {
73 *subtype = 44;
74 return;
75 }
76 case AutocompleteMatchType::NAVSUGGEST: {
77 *type = 5;
78 return;
79 }
80 case AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED: {
81 *subtype = 57;
82 return;
83 }
84 case AutocompleteMatchType::URL_WHAT_YOU_TYPED: {
85 *subtype = 58;
86 return;
87 }
88 case AutocompleteMatchType::SEARCH_HISTORY: {
89 *subtype = 59;
90 return;
91 }
92 case AutocompleteMatchType::HISTORY_URL: {
93 *subtype = 60;
94 return;
95 }
96 case AutocompleteMatchType::HISTORY_TITLE: {
97 *subtype = 61;
98 return;
99 }
100 case AutocompleteMatchType::HISTORY_BODY: {
101 *subtype = 62;
102 return;
103 }
104 case AutocompleteMatchType::HISTORY_KEYWORD: {
105 *subtype = 63;
106 return;
107 }
108 case AutocompleteMatchType::BOOKMARK_TITLE: {
109 *subtype = 65;
110 return;
111 }
112 default: {
113 // This value indicates a native chrome suggestion with no named subtype
114 // (yet).
115 *subtype = 64;
116 }
117 }
118 }
119
120 // Appends available autocompletion of the given type, subtype, and number to
121 // the existing available autocompletions string, encoding according to the
122 // spec.
AppendAvailableAutocompletion(size_t type,size_t subtype,int count,std::string * autocompletions)123 void AppendAvailableAutocompletion(size_t type,
124 size_t subtype,
125 int count,
126 std::string* autocompletions) {
127 if (!autocompletions->empty())
128 autocompletions->append("j");
129 base::StringAppendF(autocompletions, "%" PRIuS, type);
130 // Subtype is optional - base::string16::npos indicates no subtype.
131 if (subtype != base::string16::npos)
132 base::StringAppendF(autocompletions, "i%" PRIuS, subtype);
133 if (count > 1)
134 base::StringAppendF(autocompletions, "l%d", count);
135 }
136
137 // Returns whether the autocompletion is trivial enough that we consider it
138 // an autocompletion for which the omnibox autocompletion code did not add
139 // any value.
IsTrivialAutocompletion(const AutocompleteMatch & match)140 bool IsTrivialAutocompletion(const AutocompleteMatch& match) {
141 return match.type == AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED ||
142 match.type == AutocompleteMatchType::URL_WHAT_YOU_TYPED ||
143 match.type == AutocompleteMatchType::SEARCH_OTHER_ENGINE;
144 }
145
146 // Whether this autocomplete match type supports custom descriptions.
AutocompleteMatchHasCustomDescription(const AutocompleteMatch & match)147 bool AutocompleteMatchHasCustomDescription(const AutocompleteMatch& match) {
148 return match.type == AutocompleteMatchType::SEARCH_SUGGEST_ENTITY ||
149 match.type == AutocompleteMatchType::SEARCH_SUGGEST_PROFILE;
150 }
151
152 } // namespace
153
154 const int AutocompleteController::kNoItemSelected = -1;
155
AutocompleteController(Profile * profile,AutocompleteControllerDelegate * delegate,int provider_types)156 AutocompleteController::AutocompleteController(
157 Profile* profile,
158 AutocompleteControllerDelegate* delegate,
159 int provider_types)
160 : delegate_(delegate),
161 history_url_provider_(NULL),
162 keyword_provider_(NULL),
163 search_provider_(NULL),
164 zero_suggest_provider_(NULL),
165 in_stop_timer_field_trial_(
166 OmniboxFieldTrial::InStopTimerFieldTrialExperimentGroup()),
167 done_(true),
168 in_start_(false),
169 in_zero_suggest_(false),
170 profile_(profile) {
171 // AND with the disabled providers, if any.
172 provider_types &= ~OmniboxFieldTrial::GetDisabledProviderTypes();
173 bool use_hqp = !!(provider_types & AutocompleteProvider::TYPE_HISTORY_QUICK);
174 // TODO(mrossetti): Permanently modify the HistoryURLProvider to not search
175 // titles once HQP is turned on permanently.
176
177 if (provider_types & AutocompleteProvider::TYPE_BUILTIN)
178 providers_.push_back(new BuiltinProvider(this, profile));
179 #if defined(OS_CHROMEOS)
180 if (provider_types & AutocompleteProvider::TYPE_CONTACT)
181 providers_.push_back(new ContactProvider(this, profile,
182 contacts::ContactManager::GetInstance()->GetWeakPtr()));
183 #endif
184 if (provider_types & AutocompleteProvider::TYPE_EXTENSION_APP)
185 providers_.push_back(new ExtensionAppProvider(this, profile));
186 if (use_hqp)
187 providers_.push_back(new HistoryQuickProvider(this, profile));
188 if (provider_types & AutocompleteProvider::TYPE_HISTORY_URL) {
189 history_url_provider_ = new HistoryURLProvider(this, profile);
190 providers_.push_back(history_url_provider_);
191 }
192 // Search provider/"tab to search" can be used on all platforms other than
193 // Android.
194 #if !defined(OS_ANDROID)
195 if (provider_types & AutocompleteProvider::TYPE_KEYWORD) {
196 keyword_provider_ = new KeywordProvider(this, profile);
197 providers_.push_back(keyword_provider_);
198 }
199 #endif
200 if (provider_types & AutocompleteProvider::TYPE_SEARCH) {
201 search_provider_ = new SearchProvider(this, profile);
202 providers_.push_back(search_provider_);
203 }
204 if (provider_types & AutocompleteProvider::TYPE_SHORTCUTS)
205 providers_.push_back(new ShortcutsProvider(this, profile));
206
207 // Create ZeroSuggest if it is enabled.
208 if (provider_types & AutocompleteProvider::TYPE_ZERO_SUGGEST) {
209 zero_suggest_provider_ = ZeroSuggestProvider::Create(this, profile);
210 if (zero_suggest_provider_)
211 providers_.push_back(zero_suggest_provider_);
212 }
213
214 if ((provider_types & AutocompleteProvider::TYPE_BOOKMARK) &&
215 !CommandLine::ForCurrentProcess()->HasSwitch(
216 switches::kDisableBookmarkAutocompleteProvider))
217 providers_.push_back(new BookmarkProvider(this, profile));
218
219 for (ACProviders::iterator i(providers_.begin()); i != providers_.end(); ++i)
220 (*i)->AddRef();
221 }
222
~AutocompleteController()223 AutocompleteController::~AutocompleteController() {
224 // The providers may have tasks outstanding that hold refs to them. We need
225 // to ensure they won't call us back if they outlive us. (Practically,
226 // calling Stop() should also cancel those tasks and make it so that we hold
227 // the only refs.) We also don't want to bother notifying anyone of our
228 // result changes here, because the notification observer is in the midst of
229 // shutdown too, so we don't ask Stop() to clear |result_| (and notify).
230 result_.Reset(); // Not really necessary.
231 Stop(false);
232
233 for (ACProviders::iterator i(providers_.begin()); i != providers_.end(); ++i)
234 (*i)->Release();
235
236 providers_.clear(); // Not really necessary.
237 }
238
Start(const AutocompleteInput & input)239 void AutocompleteController::Start(const AutocompleteInput& input) {
240 const base::string16 old_input_text(input_.text());
241 const AutocompleteInput::MatchesRequested old_matches_requested =
242 input_.matches_requested();
243 input_ = input;
244
245 // See if we can avoid rerunning autocomplete when the query hasn't changed
246 // much. When the user presses or releases the ctrl key, the desired_tld
247 // changes, and when the user finishes an IME composition, inline autocomplete
248 // may no longer be prevented. In both these cases the text itself hasn't
249 // changed since the last query, and some providers can do much less work (and
250 // get matches back more quickly). Taking advantage of this reduces flicker.
251 //
252 // NOTE: This comes after constructing |input_| above since that construction
253 // can change the text string (e.g. by stripping off a leading '?').
254 const bool minimal_changes = (input_.text() == old_input_text) &&
255 (input_.matches_requested() == old_matches_requested);
256
257 expire_timer_.Stop();
258 stop_timer_.Stop();
259
260 // Start the new query.
261 in_zero_suggest_ = false;
262 in_start_ = true;
263 base::TimeTicks start_time = base::TimeTicks::Now();
264 for (ACProviders::iterator i(providers_.begin()); i != providers_.end();
265 ++i) {
266 // TODO(mpearson): Remove timing code once bugs 178705 / 237703 / 168933
267 // are resolved.
268 base::TimeTicks provider_start_time = base::TimeTicks::Now();
269 (*i)->Start(input_, minimal_changes);
270 if (input.matches_requested() != AutocompleteInput::ALL_MATCHES)
271 DCHECK((*i)->done());
272 base::TimeTicks provider_end_time = base::TimeTicks::Now();
273 std::string name = std::string("Omnibox.ProviderTime.") + (*i)->GetName();
274 base::HistogramBase* counter = base::Histogram::FactoryGet(
275 name, 1, 5000, 20, base::Histogram::kUmaTargetedHistogramFlag);
276 counter->Add(static_cast<int>(
277 (provider_end_time - provider_start_time).InMilliseconds()));
278 }
279 if (input.matches_requested() == AutocompleteInput::ALL_MATCHES &&
280 (input.text().length() < 6)) {
281 base::TimeTicks end_time = base::TimeTicks::Now();
282 std::string name = "Omnibox.QueryTime." + base::IntToString(
283 input.text().length());
284 base::HistogramBase* counter = base::Histogram::FactoryGet(
285 name, 1, 1000, 50, base::Histogram::kUmaTargetedHistogramFlag);
286 counter->Add(static_cast<int>((end_time - start_time).InMilliseconds()));
287 }
288 in_start_ = false;
289 CheckIfDone();
290 // The second true forces saying the default match has changed.
291 // This triggers the edit model to update things such as the inline
292 // autocomplete state. In particular, if the user has typed a key
293 // since the last notification, and we're now re-running
294 // autocomplete, then we need to update the inline autocompletion
295 // even if the current match is for the same URL as the last run's
296 // default match. Likewise, the controller doesn't know what's
297 // happened in the edit since the last time it ran autocomplete.
298 // The user might have selected all the text and hit delete, then
299 // typed a new character. The selection and delete won't send any
300 // signals to the controller so it doesn't realize that anything was
301 // cleared or changed. Even if the default match hasn't changed, we
302 // need the edit model to update the display.
303 UpdateResult(false, true);
304
305 if (!done_) {
306 StartExpireTimer();
307 StartStopTimer();
308 }
309 }
310
Stop(bool clear_result)311 void AutocompleteController::Stop(bool clear_result) {
312 for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
313 ++i) {
314 (*i)->Stop(clear_result);
315 }
316
317 expire_timer_.Stop();
318 stop_timer_.Stop();
319 done_ = true;
320 if (clear_result && !result_.empty()) {
321 result_.Reset();
322 // NOTE: We pass in false since we're trying to only clear the popup, not
323 // touch the edit... this is all a mess and should be cleaned up :(
324 NotifyChanged(false);
325 }
326 }
327
StartZeroSuggest(const GURL & url,AutocompleteInput::PageClassification page_classification,const base::string16 & permanent_text)328 void AutocompleteController::StartZeroSuggest(
329 const GURL& url,
330 AutocompleteInput::PageClassification page_classification,
331 const base::string16& permanent_text) {
332 if (zero_suggest_provider_ != NULL) {
333 DCHECK(!in_start_); // We should not be already running a query.
334 in_zero_suggest_ = true;
335 zero_suggest_provider_->StartZeroSuggest(
336 url, page_classification, permanent_text);
337 }
338 }
339
StopZeroSuggest()340 void AutocompleteController::StopZeroSuggest() {
341 if (zero_suggest_provider_ != NULL) {
342 DCHECK(!in_start_); // We should not be already running a query.
343 zero_suggest_provider_->Stop(false);
344 }
345 }
346
DeleteMatch(const AutocompleteMatch & match)347 void AutocompleteController::DeleteMatch(const AutocompleteMatch& match) {
348 DCHECK(match.deletable);
349 match.provider->DeleteMatch(match); // This may synchronously call back to
350 // OnProviderUpdate().
351 // If DeleteMatch resulted in a callback to OnProviderUpdate and we're
352 // not done, we might attempt to redisplay the deleted match. Make sure
353 // we aren't displaying it by removing any old entries.
354 ExpireCopiedEntries();
355 }
356
ExpireCopiedEntries()357 void AutocompleteController::ExpireCopiedEntries() {
358 // The first true makes UpdateResult() clear out the results and
359 // regenerate them, thus ensuring that no results from the previous
360 // result set remain.
361 UpdateResult(true, false);
362 }
363
OnProviderUpdate(bool updated_matches)364 void AutocompleteController::OnProviderUpdate(bool updated_matches) {
365 if (in_zero_suggest_) {
366 // We got ZeroSuggest results before Start(). Show only those results,
367 // because results from other providers are stale.
368 result_.Reset();
369 result_.AppendMatches(zero_suggest_provider_->matches());
370 result_.SortAndCull(input_, profile_);
371 UpdateAssistedQueryStats(&result_);
372 NotifyChanged(true);
373 } else {
374 CheckIfDone();
375 // Multiple providers may provide synchronous results, so we only update the
376 // results if we're not in Start().
377 if (!in_start_ && (updated_matches || done_))
378 UpdateResult(false, false);
379 }
380 }
381
AddProvidersInfo(ProvidersInfo * provider_info) const382 void AutocompleteController::AddProvidersInfo(
383 ProvidersInfo* provider_info) const {
384 provider_info->clear();
385 for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
386 ++i) {
387 // Add per-provider info, if any.
388 (*i)->AddProviderInfo(provider_info);
389
390 // This is also a good place to put code to add info that you want to
391 // add for every provider.
392 }
393 }
394
ResetSession()395 void AutocompleteController::ResetSession() {
396 for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
397 ++i)
398 (*i)->ResetSession();
399 in_zero_suggest_ = false;
400 }
401
UpdateMatchDestinationURL(base::TimeDelta query_formulation_time,AutocompleteMatch * match) const402 void AutocompleteController::UpdateMatchDestinationURL(
403 base::TimeDelta query_formulation_time,
404 AutocompleteMatch* match) const {
405 TemplateURL* template_url = match->GetTemplateURL(profile_, false);
406 if (!template_url || !match->search_terms_args.get() ||
407 match->search_terms_args->assisted_query_stats.empty())
408 return;
409
410 // Append the query formulation time (time from when the user first typed a
411 // character into the omnibox to when the user selected a query) and whether
412 // a field trial has triggered to the AQS parameter.
413 TemplateURLRef::SearchTermsArgs search_terms_args(*match->search_terms_args);
414 search_terms_args.assisted_query_stats += base::StringPrintf(
415 ".%" PRId64 "j%dj%d",
416 query_formulation_time.InMilliseconds(),
417 (search_provider_ &&
418 search_provider_->field_trial_triggered_in_session()) ||
419 (zero_suggest_provider_ &&
420 zero_suggest_provider_->field_trial_triggered_in_session()),
421 input_.current_page_classification());
422 match->destination_url =
423 GURL(template_url->url_ref().ReplaceSearchTerms(search_terms_args));
424 }
425
UpdateResult(bool regenerate_result,bool force_notify_default_match_changed)426 void AutocompleteController::UpdateResult(
427 bool regenerate_result,
428 bool force_notify_default_match_changed) {
429 const bool last_default_was_valid = result_.default_match() != result_.end();
430 // The following three variables are only set and used if
431 // |last_default_was_valid|.
432 base::string16 last_default_fill_into_edit, last_default_keyword,
433 last_default_associated_keyword;
434 if (last_default_was_valid) {
435 last_default_fill_into_edit = result_.default_match()->fill_into_edit;
436 last_default_keyword = result_.default_match()->keyword;
437 if (result_.default_match()->associated_keyword != NULL)
438 last_default_associated_keyword =
439 result_.default_match()->associated_keyword->keyword;
440 }
441
442 if (regenerate_result)
443 result_.Reset();
444
445 AutocompleteResult last_result;
446 last_result.Swap(&result_);
447
448 for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
449 ++i)
450 result_.AppendMatches((*i)->matches());
451
452 // Sort the matches and trim to a small number of "best" matches.
453 result_.SortAndCull(input_, profile_);
454
455 // Need to validate before invoking CopyOldMatches as the old matches are not
456 // valid against the current input.
457 #ifndef NDEBUG
458 result_.Validate();
459 #endif
460
461 if (!done_) {
462 // This conditional needs to match the conditional in Start that invokes
463 // StartExpireTimer.
464 result_.CopyOldMatches(input_, last_result, profile_);
465 }
466
467 UpdateKeywordDescriptions(&result_);
468 UpdateAssociatedKeywords(&result_);
469 UpdateAssistedQueryStats(&result_);
470
471 const bool default_is_valid = result_.default_match() != result_.end();
472 base::string16 default_associated_keyword;
473 if (default_is_valid &&
474 (result_.default_match()->associated_keyword != NULL)) {
475 default_associated_keyword =
476 result_.default_match()->associated_keyword->keyword;
477 }
478 // We've gotten async results. Send notification that the default match
479 // updated if fill_into_edit, associated_keyword, or keyword differ. (The
480 // second can change if we've just started Chrome and the keyword database
481 // finishes loading while processing this request. The third can change
482 // if we swapped from interpreting the input as a search--which gets
483 // labeled with the default search provider's keyword--to a URL.)
484 // We don't check the URL as that may change for the default match
485 // even though the fill into edit hasn't changed (see SearchProvider
486 // for one case of this).
487 const bool notify_default_match =
488 (last_default_was_valid != default_is_valid) ||
489 (last_default_was_valid &&
490 ((result_.default_match()->fill_into_edit !=
491 last_default_fill_into_edit) ||
492 (default_associated_keyword != last_default_associated_keyword) ||
493 (result_.default_match()->keyword != last_default_keyword)));
494 if (notify_default_match)
495 last_time_default_match_changed_ = base::TimeTicks::Now();
496
497 NotifyChanged(force_notify_default_match_changed || notify_default_match);
498 }
499
UpdateAssociatedKeywords(AutocompleteResult * result)500 void AutocompleteController::UpdateAssociatedKeywords(
501 AutocompleteResult* result) {
502 if (!keyword_provider_)
503 return;
504
505 std::set<base::string16> keywords;
506 for (ACMatches::iterator match(result->begin()); match != result->end();
507 ++match) {
508 base::string16 keyword(
509 match->GetSubstitutingExplicitlyInvokedKeyword(profile_));
510 if (!keyword.empty()) {
511 keywords.insert(keyword);
512 continue;
513 }
514
515 // Only add the keyword if the match does not have a duplicate keyword with
516 // a more relevant match.
517 keyword = match->associated_keyword.get() ?
518 match->associated_keyword->keyword :
519 keyword_provider_->GetKeywordForText(match->fill_into_edit);
520 if (!keyword.empty() && !keywords.count(keyword)) {
521 keywords.insert(keyword);
522
523 if (!match->associated_keyword.get())
524 match->associated_keyword.reset(new AutocompleteMatch(
525 keyword_provider_->CreateVerbatimMatch(match->fill_into_edit,
526 keyword, input_)));
527 } else {
528 match->associated_keyword.reset();
529 }
530 }
531 }
532
UpdateKeywordDescriptions(AutocompleteResult * result)533 void AutocompleteController::UpdateKeywordDescriptions(
534 AutocompleteResult* result) {
535 base::string16 last_keyword;
536 for (AutocompleteResult::iterator i(result->begin()); i != result->end();
537 ++i) {
538 if ((i->provider->type() == AutocompleteProvider::TYPE_KEYWORD &&
539 !i->keyword.empty()) ||
540 (i->provider->type() == AutocompleteProvider::TYPE_SEARCH &&
541 AutocompleteMatch::IsSearchType(i->type))) {
542 if (AutocompleteMatchHasCustomDescription(*i))
543 continue;
544 i->description.clear();
545 i->description_class.clear();
546 DCHECK(!i->keyword.empty());
547 if (i->keyword != last_keyword) {
548 const TemplateURL* template_url = i->GetTemplateURL(profile_, false);
549 if (template_url) {
550 // For extension keywords, just make the description the extension
551 // name -- don't assume that the normal search keyword description is
552 // applicable.
553 i->description = template_url->AdjustedShortNameForLocaleDirection();
554 if (template_url->GetType() != TemplateURL::OMNIBOX_API_EXTENSION) {
555 i->description = l10n_util::GetStringFUTF16(
556 IDS_AUTOCOMPLETE_SEARCH_DESCRIPTION, i->description);
557 }
558 i->description_class.push_back(
559 ACMatchClassification(0, ACMatchClassification::DIM));
560 }
561 last_keyword = i->keyword;
562 }
563 } else {
564 last_keyword.clear();
565 }
566 }
567 }
568
UpdateAssistedQueryStats(AutocompleteResult * result)569 void AutocompleteController::UpdateAssistedQueryStats(
570 AutocompleteResult* result) {
571 if (result->empty())
572 return;
573
574 // Build the impressions string (the AQS part after ".").
575 std::string autocompletions;
576 int count = 0;
577 size_t last_type = base::string16::npos;
578 size_t last_subtype = base::string16::npos;
579 for (ACMatches::iterator match(result->begin()); match != result->end();
580 ++match) {
581 size_t type = base::string16::npos;
582 size_t subtype = base::string16::npos;
583 AutocompleteMatchToAssistedQuery(match->type, &type, &subtype);
584 if (last_type != base::string16::npos &&
585 (type != last_type || subtype != last_subtype)) {
586 AppendAvailableAutocompletion(
587 last_type, last_subtype, count, &autocompletions);
588 count = 1;
589 } else {
590 count++;
591 }
592 last_type = type;
593 last_subtype = subtype;
594 }
595 AppendAvailableAutocompletion(
596 last_type, last_subtype, count, &autocompletions);
597 // Go over all matches and set AQS if the match supports it.
598 for (size_t index = 0; index < result->size(); ++index) {
599 AutocompleteMatch* match = result->match_at(index);
600 const TemplateURL* template_url = match->GetTemplateURL(profile_, false);
601 if (!template_url || !match->search_terms_args.get())
602 continue;
603 std::string selected_index;
604 // Prevent trivial suggestions from getting credit for being selected.
605 if (!IsTrivialAutocompletion(*match))
606 selected_index = base::StringPrintf("%" PRIuS, index);
607 match->search_terms_args->assisted_query_stats =
608 base::StringPrintf("chrome.%s.%s",
609 selected_index.c_str(),
610 autocompletions.c_str());
611 match->destination_url = GURL(template_url->url_ref().ReplaceSearchTerms(
612 *match->search_terms_args));
613 }
614 }
615
NotifyChanged(bool notify_default_match)616 void AutocompleteController::NotifyChanged(bool notify_default_match) {
617 if (delegate_)
618 delegate_->OnResultChanged(notify_default_match);
619 if (done_) {
620 content::NotificationService::current()->Notify(
621 chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
622 content::Source<AutocompleteController>(this),
623 content::NotificationService::NoDetails());
624 }
625 }
626
CheckIfDone()627 void AutocompleteController::CheckIfDone() {
628 for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
629 ++i) {
630 if (!(*i)->done()) {
631 done_ = false;
632 return;
633 }
634 }
635 done_ = true;
636 }
637
StartExpireTimer()638 void AutocompleteController::StartExpireTimer() {
639 // Amount of time (in ms) between when the user stops typing and
640 // when we remove any copied entries. We do this from the time the
641 // user stopped typing as some providers (such as SearchProvider)
642 // wait for the user to stop typing before they initiate a query.
643 const int kExpireTimeMS = 500;
644
645 if (result_.HasCopiedMatches())
646 expire_timer_.Start(FROM_HERE,
647 base::TimeDelta::FromMilliseconds(kExpireTimeMS),
648 this, &AutocompleteController::ExpireCopiedEntries);
649 }
650
StartStopTimer()651 void AutocompleteController::StartStopTimer() {
652 if (!in_stop_timer_field_trial_)
653 return;
654
655 // Amount of time (in ms) between when the user stops typing and
656 // when we send Stop() to every provider. This is intended to avoid
657 // the disruptive effect of belated omnibox updates, updates that
658 // come after the user has had to time to read the whole dropdown
659 // and doesn't expect it to change.
660 const int kStopTimeMS = 1500;
661 stop_timer_.Start(FROM_HERE,
662 base::TimeDelta::FromMilliseconds(kStopTimeMS),
663 base::Bind(&AutocompleteController::Stop,
664 base::Unretained(this),
665 false));
666 }
667