• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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