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