Make HistoryURLProvider::SuggestExactInput() non-static, and take only the

chrome/browser/autocomplete/history_url_provider.cc

 // 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.
 
 #include "chrome/browser/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 354 matching lines @@
       cull_redirects_(
           !OmniboxFieldTrial::InHUPCullRedirectsFieldTrial() ||
           !OmniboxFieldTrial::InHUPCullRedirectsFieldTrialExperimentGroup()),
       create_shorter_match_(
           !OmniboxFieldTrial::InHUPCreateShorterMatchFieldTrial() ||
           !OmniboxFieldTrial::
               InHUPCreateShorterMatchFieldTrialExperimentGroup()),
       search_url_database_(true) {
 }
 
-// static
+void HistoryURLProvider::Start(const AutocompleteInput& input,
+                               bool minimal_changes) {
+  // NOTE: We could try hard to do less work in the |minimal_changes| case
+  // here; some clever caching would let us reuse the raw matches from the
+  // history DB without re-querying.  However, we'd still have to go back to
+  // the history thread to mark these up properly, and if pass 2 is currently
+  // running, we'd need to wait for it to return to the main thread before
+  // doing this (we can't just write new data for it to read due to thread
+  // safety issues).  At that point it's just as fast, and easier, to simply
+  // re-run the query from scratch and ignore |minimal_changes|.
+
+  // Cancel any in-progress query.
+  Stop(false);
+
+  RunAutocompletePasses(input, true);
+}
+
+void HistoryURLProvider::Stop(bool clear_cached_results) {
+  done_ = true;
+
+  if (params_)
+    params_->cancel_flag.Set();
+}
+
 AutocompleteMatch HistoryURLProvider::SuggestExactInput(
-    AutocompleteProvider* provider,
-    const AutocompleteInput& input,
+    const string16& text,
+    const GURL& destination_url,
     bool trim_http) {
-  AutocompleteMatch match(provider, 0, false,
+  AutocompleteMatch match(this, 0, false,
                           AutocompleteMatchType::URL_WHAT_YOU_TYPED);
 
-  const GURL& url = input.canonicalized_url();
-  if (url.is_valid()) {
-    match.destination_url = url;
+  if (destination_url.is_valid()) {
+    match.destination_url = destination_url;
 
     // Trim off "http://" if the user didn't type it.
     // NOTE: We use TrimHttpPrefix() here rather than StringForURLDisplay() to
     // strip the scheme as we need to know the offset so we can adjust the
     // |match_location| below.  StringForURLDisplay() and TrimHttpPrefix() have
     // slightly different behavior as well (the latter will strip even without
     // two slashes after the scheme).
-    DCHECK(!trim_http || !HasHTTPScheme(input.text()));
-    string16 display_string(provider->StringForURLDisplay(url, false, false));
+    DCHECK(!trim_http || !HasHTTPScheme(text));
+    string16 display_string(StringForURLDisplay(destination_url, false, false));
     const size_t offset = trim_http ? TrimHttpPrefix(&display_string) : 0;
     match.fill_into_edit =
-        AutocompleteInput::FormattedStringWithEquivalentMeaning(url,
+        AutocompleteInput::FormattedStringWithEquivalentMeaning(destination_url,
                                                                 display_string);
     match.allowed_to_be_default_match = true;
     // NOTE: Don't set match.inline_autocompletion to something non-empty here;
     // it's surprising and annoying.
 
     // Try to highlight "innermost" match location.  If we fix up "w" into
     // "www.w.com", we want to highlight the fifth character, not the first.
     // This relies on match.destination_url being the non-prefix-trimmed version
     // of match.contents.
     match.contents = display_string;
-    const URLPrefix* best_prefix = URLPrefix::BestURLPrefix(
-        UTF8ToUTF16(match.destination_url.spec()), input.text());
+    const URLPrefix* best_prefix =
+        URLPrefix::BestURLPrefix(UTF8ToUTF16(destination_url.spec()), text);
     // It's possible for match.destination_url to not contain the user's input
     // at all (so |best_prefix| is NULL), for example if the input is
     // "view-source:x" and |destination_url| has an inserted "http://" in the
     // middle.
     if (best_prefix == NULL) {
-      AutocompleteMatch::ClassifyMatchInString(input.text(), match.contents,
+      AutocompleteMatch::ClassifyMatchInString(text, match.contents,
                                                ACMatchClassification::URL,
                                                &match.contents_class);
     } else {
       AutocompleteMatch::ClassifyLocationInString(
-          best_prefix->prefix.length() - offset, input.text().length(),
+          best_prefix->prefix.length() - offset, text.length(),
           match.contents.length(), ACMatchClassification::URL,
           &match.contents_class);
     }
 
     match.is_history_what_you_typed_match = true;
   }
 
   return match;
 }
 
-void HistoryURLProvider::Start(const AutocompleteInput& input,
-                               bool minimal_changes) {
-  // NOTE: We could try hard to do less work in the |minimal_changes| case
-  // here; some clever caching would let us reuse the raw matches from the
-  // history DB without re-querying.  However, we'd still have to go back to
-  // the history thread to mark these up properly, and if pass 2 is currently
-  // running, we'd need to wait for it to return to the main thread before
-  // doing this (we can't just write new data for it to read due to thread
-  // safety issues).  At that point it's just as fast, and easier, to simply
-  // re-run the query from scratch and ignore |minimal_changes|.
-
-  // Cancel any in-progress query.
-  Stop(false);
-
-  RunAutocompletePasses(input, true);
-}
-
-void HistoryURLProvider::Stop(bool clear_cached_results) {
-  done_ = true;
-
-  if (params_)
-    params_->cancel_flag.Set();
-}
-
 // Called on the history thread.
 void HistoryURLProvider::ExecuteWithDB(history::HistoryBackend* backend,
                                        history::URLDatabase* db,
                                        HistoryURLProviderParams* params) {
   // We may get called with a NULL database if it couldn't be properly
   // initialized.
   if (!db) {
     params->failed = true;
   } else if (!params->cancel_flag.IsSet()) {
     base::TimeTicks beginning_time = base::TimeTicks::Now();
@@ skipping 25 matching lines @@
   //  that is when their input can be opened as a URL.
   // Otherwise, this is just low-quality noise.  In the cases where we've parsed
   // as UNKNOWN, we'll still show an accidental search infobar if need be.
   bool have_what_you_typed_match =
       params->input.canonicalized_url().is_valid() &&
       (params->input.type() != AutocompleteInput::QUERY) &&
       ((params->input.type() != AutocompleteInput::UNKNOWN) ||
        (classifier.type() == VisitClassifier::UNVISITED_INTRANET) ||
        !params->trim_http ||
        (AutocompleteInput::NumNonHostComponents(params->input.parts()) > 0));
-  AutocompleteMatch what_you_typed_match(
-      SuggestExactInput(this, params->input, params->trim_http));
+  AutocompleteMatch what_you_typed_match(SuggestExactInput(
+      params->input.text(), params->input.canonicalized_url(),
+      params->trim_http));
   what_you_typed_match.relevance = CalculateRelevance(WHAT_YOU_TYPED, 0);
 
   // Get the matching URLs from the DB
   history::URLRows url_matches;
   history::HistoryMatches history_matches;
 
   if (search_url_database_) {
     const URLPrefixes& prefixes = URLPrefix::GetURLPrefixes();
     for (URLPrefixes::const_iterator i(prefixes.begin()); i != prefixes.end();
          ++i) {
@@ skipping 159 matching lines @@
     return;
 
   // Create a match for exactly what the user typed.  This will only be used as
   // a fallback in case we can't get the history service or URL DB; otherwise,
   // we'll run this again in DoAutocomplete() and use that result instead.
   const bool trim_http = !HasHTTPScheme(input.text());
   // Don't do this for queries -- while we can sometimes mark up a match for
   // this, it's not what the user wants, and just adds noise.
   if ((input.type() != AutocompleteInput::QUERY) &&
       input.canonicalized_url().is_valid()) {
-    AutocompleteMatch what_you_typed(SuggestExactInput(this, input, trim_http));
+    AutocompleteMatch what_you_typed(SuggestExactInput(
+        input.text(), input.canonicalized_url(), trim_http));
     what_you_typed.relevance = CalculateRelevance(WHAT_YOU_TYPED, 0);
     matches_.push_back(what_you_typed);
   }
 
   // We'll need the history service to run both passes, so try to obtain it.
   if (!profile_)
     return;
   HistoryService* const history_service =
       HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);
   if (!history_service)
@@ skipping 395 matching lines @@
         &match.contents_class);
   }
   match.description = info.title();
   AutocompleteMatch::ClassifyMatchInString(params.input.text(),
                                            info.title(),
                                            ACMatchClassification::NONE,
                                            &match.description_class);
   RecordAdditionalInfoFromUrlRow(info, &match);
   return match;
 }