Allow the history URL provider to handle input of type QUERY. This helps in ...

chrome/browser/autocomplete/history_url_provider.cc

 // Copyright (c) 2006-2008 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/histogram.h"
@@ skipping 108 matching lines @@
 }
 
 // Used by both autocomplete passes, and therefore called on multiple different
 // threads (though not simultaneously).
 void HistoryURLProvider::DoAutocomplete(history::HistoryBackend* backend,
                                         history::URLDatabase* db,
                                         HistoryURLProviderParams* params) {
   // Create a What You Typed match, which we'll need below.
   bool have_what_you_typed_match =
       params->input.canonicalized_url().is_valid() &&
-      (params->input.type() != AutocompleteInput::UNKNOWN);
+      (params->input.type() != AutocompleteInput::UNKNOWN) &&
+      (params->input.type() != AutocompleteInput::QUERY);
   AutocompleteMatch what_you_typed_match(SuggestExactInput(params->input,
                                                            params->trim_http));
 
   // Get the matching URLs from the DB
   typedef std::vector<history::URLRow> URLRowVector;
   URLRowVector url_matches;
   HistoryMatches history_matches;
   for (Prefixes::const_iterator i(prefixes_.begin()); i != prefixes_.end();
        ++i) {
     if (params->cancel)
@@ skipping 25 matching lines @@
   // Try to promote a match as an exact/inline autocomplete match.  This also
   // moves it to the front of |history_matches|, so skip over it when
   // converting the rest of the matches.
   size_t first_match = 1;
   size_t exact_suggestion = 0;
   // Checking |is_history_what_you_typed_match| tells us whether
   // SuggestExactInput() succeeded in constructing a valid match.
   if (what_you_typed_match.is_history_what_you_typed_match &&
       FixupExactSuggestion(db, params->input, &what_you_typed_match,
                            &history_matches)) {
-    // Got an exact match for the user's input.  Treat is as the best match
+    // Got an exact match for the user's input.  Treat it as the best match
     // regardless of the input type.
     exact_suggestion = 1;
     params->matches.push_back(what_you_typed_match);
   } else if (params->input.prevent_inline_autocomplete() ||
       history_matches.empty() ||
       !PromoteMatchForInlineAutocomplete(params, history_matches.front())) {
     // Failed to promote any URLs for inline autocompletion.  Use the What You
-    // Typed match, if we have it and the input wasn't UNKNOWN.
+    // Typed match, if we have it and the input looked like a URL.
     first_match = 0;
     if (have_what_you_typed_match)
       params->matches.push_back(what_you_typed_match);
   }
 
   // This is the end of the synchronous pass.
   if (!backend)
     return;
 
   // Remove redirects and trim list to size.  We want to provide up to
@@ skipping 263 matching lines @@
 
 // static
 int HistoryURLProvider::CalculateRelevance(AutocompleteInput::Type input_type,
                                            MatchType match_type,
                                            size_t match_number) {
   switch (match_type) {
     case INLINE_AUTOCOMPLETE:
       return 1400;
 
     case WHAT_YOU_TYPED:
-      return (input_type == AutocompleteInput::REQUESTED_URL) ? 1300 : 1200;
+      return 1200;
 
     default:
       return 900 + static_cast<int>(match_number);
   }
 }
 
 // static
 GURL HistoryURLProvider::ConvertToHostOnly(const HistoryMatch& match,
                                            const std::wstring& input) {
   // See if we should try to do host-only suggestions for this URL. Nonstandard
@@ skipping 107 matching lines @@
     matches->push_front(match);
   else
     matches->push_back(match);
 }
 
 void HistoryURLProvider::RunAutocompletePasses(
     const AutocompleteInput& input,
     bool fixup_input_and_run_pass_1) {
   matches_.clear();
 
-  if ((input.type() != AutocompleteInput::UNKNOWN) &&
-      (input.type() != AutocompleteInput::REQUESTED_URL) &&
-      (input.type() != AutocompleteInput::URL))
+  if ((input.type() == AutocompleteInput::INVALID) ||
+      (input.type() == AutocompleteInput::FORCED_QUERY))
     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 = !url_util::FindAndCompareScheme(
       WideToUTF8(input.text()), chrome::kHttpScheme, NULL);
-  if (input.canonicalized_url().is_valid())
+  // 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())
     matches_.push_back(SuggestExactInput(input, trim_http));
 
   // We'll need the history service to run both passes, so try to obtain it.
   HistoryService* const history_service = profile_ ?
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS) : history_service_;
   if (!history_service)
     return;
 
   // Create the data structure for the autocomplete passes.  We'll save this off
   // onto the |params_| member for later deletion below if we need to run pass
@@ skipping 210 matching lines @@
       history_match.input_location - offset, params->input.text().length(),
       match.contents.length(), ACMatchClassification::URL,
       &match.contents_class);
   match.description = info.title();
   AutocompleteMatch::ClassifyMatchInString(params->input.text(), info.title(),
                                            ACMatchClassification::NONE,
                                            &match.description_class);
 
   return match;
 }