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

chrome/browser/autocomplete/autocomplete.cc

 // Copyright (c) 2009 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/autocomplete.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/basictypes.h"
@@ skipping 164 matching lines @@
   if (registry_length == std::wstring::npos)
     return QUERY;  // Could be a broken IP address, etc.
 
   // See if the hostname is valid.  While IE and GURL allow hostnames to contain
   // many other characters (perhaps for weird intranet machines), it's extremely
   // unlikely that a user would be trying to type those in for anything other
   // than a search query.
   url_canon::CanonHostInfo host_info;
   const std::string canonicalized_host(net::CanonicalizeHost(host, &host_info));
   if ((host_info.family == url_canon::CanonHostInfo::NEUTRAL) &&
-      !net::IsCanonicalizedHostCompliant(canonicalized_host))
-    return QUERY;
+      !net::IsCanonicalizedHostCompliant(canonicalized_host)) {
+    // Invalid hostname.  There are several possible cases:
+    // * Our checker is too strict and the user pasted in a real-world URL
+    //   that's "invalid" but resolves.  To catch these, we return UNKNOWN when
+    //   the user explicitly typed a scheme, so we'll still search by default
+    //   but we'll show the accidental search infobar if necessary.
+    // * The user is typing a multi-word query.  If we see a space anywhere in
+    //   the hostname we assume this is a search and return QUERY.
+    // * Our checker is too strict and the user is typing a real-world hostname
+    //   that's "invalid" but resolves.  We return UNKNOWN if the TLD is known.
+    //   Note that we explicitly excluded hosts with spaces above so that
+    //   "toys at amazon.com" will be treated as a search.
+    // * The user is typing some garbage string.  Return QUERY.
+    //
+    // Thus we fall down in the following cases:
+    // * Trying to navigate to a hostname with spaces
+    // * Trying to navigate to a hostname with invalid characters and an unknown
+    //   TLD
+    // These are rare, though probably possible in intranets.
+    return (parts->scheme.is_nonempty() ||
+           ((registry_length != 0) && (host.find(' ') == std::wstring::npos))) ?
+        UNKNOWN : QUERY;
+  }
 
   // Presence of a port means this is likely a URL, if the port is really a port
   // number.  If it's just garbage after a colon, this is a query.
   if (parts->port.is_nonempty()) {
     int port;
     return (StringToInt(WideToUTF16(
                 text.substr(parts->port.begin, parts->port.len)), &port) &&
             (port >= 0) && (port <= 65535)) ? URL : QUERY;
   }
 
@@ skipping 744 matching lines @@
 void AutocompleteController::CheckIfDone() {
   for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
        ++i) {
     if (!(*i)->done()) {
       done_ = false;
       return;
     }
   }
   done_ = true;
 }