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