Better handling of UNKNOWN versus QUERY in a couple ways....

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 109 matching lines @@
   params->message_loop->PostTask(FROM_HERE, NewRunnableMethod(
       this, &HistoryURLProvider::QueryComplete, params));
 }
 
 // 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.
+  //
+  // We display this to the user when there's a reasonable chance they actually
+  // care:
+  // * Their input can be opened as a URL, and
+  // * They hit ctrl-enter, or we parsed the input as a URL, or it starts with
+  //   an explicit "http:" or "https:".
+  // 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::UNKNOWN) &&
-      (params->input.type() != AutocompleteInput::QUERY);
+      (params->input.type() != AutocompleteInput::QUERY) &&
+      ((params->input.type() != AutocompleteInput::UNKNOWN) ||
+          !params->trim_http ||
+          url_util::FindAndCompareScheme(WideToUTF8(params->input.text()),
+                                         chrome::kHttpsScheme, NULL));
   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)
-      return;  // canceled in the middle of a query, give up
+      return;  // Canceled in the middle of a query, give up.
     // We only need max_matches results in the end, but before we get there we
     // need to promote lower-quality matches that are prefixes of
     // higher-quality matches, and remove lower-quality redirects.  So we ask
     // for more results than we need, of every prefix type, in hopes this will
     // give us far more than enough to work with.  CullRedirects() will then
     // reduce the list to the best max_matches results.
     db->AutocompleteForPrefix(i->prefix + params->input.text(),
                               max_matches() * 2, &url_matches);
     for (URLRowVector::const_iterator j(url_matches.begin());
          j != url_matches.end(); ++j) {
@@ skipping 22 matching lines @@
       FixupExactSuggestion(db, params->input, &what_you_typed_match,
                            &history_matches)) {
     // 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 looked like a URL.
+    // Typed match, if we have it.
     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 639 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;
 }