Don't call AutocompleteInput::Parse() on a background thread, part 1.

chrome/browser/autocomplete/history_url_provider.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROME_BROWSER_AUTOCOMPLETE_HISTORY_URL_PROVIDER_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_HISTORY_URL_PROVIDER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 72 matching lines @@
 // checks periodically.  If it finds the flag set, it stops what it's doing
 // immediately and calls back to the main thread.  (We don't delete the params
 // on the history thread, because we should only do that when we can safely
 // NULL out params_, and that must be done on the main thread.)
 
 // Used to communicate autocomplete parameters between threads via the history
 // service.
 struct HistoryURLProviderParams {
   HistoryURLProviderParams(const AutocompleteInput& input,
                            bool trim_http,
+                           const AutocompleteMatch& what_you_typed_match,
                            const std::string& languages,
                            TemplateURL* default_search_provider,
                            const SearchTermsData& search_terms_data);
   ~HistoryURLProviderParams();
 
   base::MessageLoop* message_loop;
 
   // A copy of the autocomplete input. We need the copy since this object will
   // live beyond the original query while it runs on the history thread.
   AutocompleteInput input;
 
   // Should inline autocompletion be disabled? This is initalized from
   // |input.prevent_inline_autocomplete()|, but set to false is the input
   // contains trailing white space.
   bool prevent_inline_autocomplete;
 
   // Set when "http://" should be trimmed from the beginning of the URLs.
   bool trim_http;
 
+  // A match corresponding to what the user typed.
+  AutocompleteMatch what_you_typed_match;
+
   // Set by the main thread to cancel this request.  If this flag is set when
   // the query runs, the query will be abandoned.  This allows us to avoid
   // running queries that are no longer needed.  Since we don't care if we run
   // the extra queries, the lack of signaling is not a problem.
   base::CancellationFlag cancel_flag;
 
   // Set by ExecuteWithDB() on the history thread when the query could not be
   // performed because the history system failed to properly init the database.
   // If this is set when the main thread is called back, it avoids changing
   // |matches_| at all, so it won't delete the default match Start() creates.
@@ skipping 92 matching lines @@
   // called on multiple different threads (though not simultaneously).
   void DoAutocomplete(history::HistoryBackend* backend,
                       history::URLDatabase* db,
                       HistoryURLProviderParams* params);
 
   // Dispatches the results to the autocomplete controller. Called on the
   // main thread by ExecuteWithDB when the results are available.
   // Frees params_gets_deleted on exit.
   void QueryComplete(HistoryURLProviderParams* params_gets_deleted);
 
-  // Given a |match| containing the "what you typed" suggestion created by
-  // SuggestExactInput(), looks up its info in the DB.  If found, fills in the
-  // title from the DB, promotes the match's priority to that of an inline
+  // Looks up the info for params->what_you_typed_match in the DB.  If found,
+  // fills in the title, promotes the match's priority to that of an inline
   // autocomplete match (maybe it should be slightly better?), and places it on
-  // the front of |matches| (so we pick the right matches to throw away
-  // when culling redirects to/from it).  Returns whether a match was promoted.
+  // the front of |matches| (so we pick the right matches to throw away when
+  // culling redirects to/from it).  Returns whether a match was promoted.
   bool FixupExactSuggestion(history::URLDatabase* db,
-                            const AutocompleteInput& input,
                             const VisitClassifier& classifier,
-                            AutocompleteMatch* match,
+                            HistoryURLProviderParams* params,
                             history::HistoryMatches* matches) const;
 
   // Helper function for FixupExactSuggestion, this returns true if the input
   // corresponds to some intranet URL where the user has previously visited the
   // host in question.  In this case the input should be treated as a URL.
   bool CanFindIntranetURL(history::URLDatabase* db,
                           const AutocompleteInput& input) const;
 
-  // Determines if |match| is suitable for inline autocomplete.  If so, and if
-  // |params| is non-NULL, promotes the match.  Returns whether |match| is
-  // suitable for inline autocomplete.
+  // Determines if |match| is suitable for inline autocomplete.  If so, promotes
+  // the match.  Returns whether |match| was promoted.
   bool PromoteMatchForInlineAutocomplete(const history::HistoryMatch& match,
                                          HistoryURLProviderParams* params);
 
   // Sees if a shorter version of the best match should be created, and if so
   // places it at the front of |matches|.  This can suggest history URLs that
   // are prefixes of the best match (if they've been visited enough, compared to
   // the best match), or create host-only suggestions even when they haven't
   // been visited before: if the user visited http://example.com/asdf once,
   // we'll suggest http://example.com/ even if they've never been to it.
   void PromoteOrCreateShorterSuggestion(
       history::URLDatabase* db,
       const HistoryURLProviderParams& params,
       bool have_what_you_typed_match,
-      const AutocompleteMatch& what_you_typed_match,
       history::HistoryMatches* matches);
 
   // Removes results that have been rarely typed or visited, and not any time
   // recently.  The exact parameters for this heuristic can be found in the
   // function body. Also culls results corresponding to queries from the default
   // search engine. These are low-quality, difficult-to-understand matches for
   // users, and the SearchProvider should surface past queries in a better way
   // anyway.
   void CullPoorMatches(const HistoryURLProviderParams& params,
                        history::HistoryMatches* matches) const;
@@ skipping 44 matching lines @@
   // Used in PromoteOrCreateShorterSuggestion().  If true, we may create
   // shorter suggestions even when they haven't been visited before:
   // if the user visited http://example.com/asdf once, we'll suggest
   // http://example.com/ even if they've never been to it.
   bool create_shorter_match_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryURLProvider);
 };
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_HISTORY_URL_PROVIDER_H_