Use the new CanonicalizeHostVerbose() function.

chrome/browser/autocomplete/autocomplete.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/autocomplete.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/basictypes.h"
@@ skipping 146 matching lines @@
   // It's not clear that we can reach here with an empty "host" (maybe on some
   // kinds of garbage input?), but if we did, it couldn't be a URL.
   if (!parts->host.is_nonempty())
     return QUERY;
   // (We use the registry length later below but ask for it here so we can check
   // the host's validity at this point.)
   const std::wstring host(text.substr(parts->host.begin, parts->host.len));
   const size_t registry_length =
       net::RegistryControlledDomainService::GetRegistryLength(host, false);
   if (registry_length == std::wstring::npos)
-    return QUERY;  // It's not clear to me that we can reach this...
+    return QUERY;  // Could be a broken IP address, etc.
 
   // A space in the "host" means this is a query.  (Technically, IE and GURL
   // allow hostnames with spaces for wierd intranet machines, but it's supposed
   // to be illegal and I'm not worried about users trying to type these in.)
   if (host.find(' ') != std::wstring::npos)
     return QUERY;
 
   // Presence of a password/port mean this is almost certainly a URL.  We don't
   // treat usernames (without passwords) as indicating a URL, because this could
   // be an email address like "user@mail.com" which is more likely a search than
   // an HTTP auth login attempt.
   if (parts->password.is_nonempty() || parts->port.is_nonempty())
     return URL;
 
   // See if the host is an IP address.
-  bool is_ip_address;
-  const std::string canon_host(net::CanonicalizeHost(host, &is_ip_address));
-  if (is_ip_address) {
-    // If the user typed a valid IPv6 address, treat it as a URL.
-    if (canon_host[0] == '[')
-      return URL;
-
+  url_canon::CanonHostInfo host_info;
+  net::CanonicalizeHost(host, &host_info);
+  if (host_info.family == url_canon::CanonHostInfo::IPV4) {
     // If the user originally typed a host that looks like an IP address (a
     // dotted quad), they probably want to open it.  If the original input was
     // something else (like a single number), they probably wanted to search for
     // it.  This is true even if the URL appears to have a path: "1.2/45" is
     // more likely a search (for the answer to a math problem) than a URL.
-    url_parse::Component components[4];
-    const bool found_ipv4 =
-        url_canon::FindIPv4Components(WideToUTF8(text).c_str(),
-                                      parts->host, components);
-    DCHECK(found_ipv4);
-    for (size_t i = 0; i < arraysize(components); ++i) {
-      if (!components[i].is_nonempty())
-        return desired_tld.empty() ? UNKNOWN : REQUESTED_URL;
-    }
+    if (host_info.num_ipv4_components == 4)
+      return URL;
+    return desired_tld.empty() ? UNKNOWN : REQUESTED_URL;
+  }
+
+  if (host_info.family == url_canon::CanonHostInfo::IPV6) {
+    // If the user typed a valid bracketed IPv6 address, treat it as a URL.
     return URL;
   }
 
   // The host doesn't look like a number, so see if the user's given us a path.
   if (parts->path.is_nonempty()) {
     // Most inputs with paths are URLs, even ones without known registries (e.g.
     // intranet URLs).  However, if there's no known registry, and the path has
     // a space, this is more likely a query with a slash in the first term (e.g.
     // "ps/2 games") than a URL.  We can still open URLs with spaces in the path
     // by escaping the space, and we will still inline autocomplete them if
@@ skipping 681 matching lines @@
     match.contents_class.push_back(
         ACMatchClassification(keyword_offset + input_.text().size(),
                               ACMatchClassification::NONE));
   }
   match.destination_url =
       HistoryUI::GetHistoryURLWithSearchText(input_.text());
   match.transition = PageTransition::AUTO_BOOKMARK;
   match.provider = history_contents_provider_;
   latest_result_.AddMatch(match);
 }