Add full support for filesystem URLs.

chrome/browser/autocomplete/autocomplete.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/autocomplete.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 72 matching lines @@
 
   GURL canonicalized_url;
   type_ = Parse(text_, desired_tld, &parts_, &scheme_, &canonicalized_url);
 
   if (type_ == INVALID)
     return;
 
   if (((type_ == UNKNOWN) || (type_ == REQUESTED_URL) || (type_ == URL)) &&
       canonicalized_url.is_valid() &&
       (!canonicalized_url.IsStandard() || canonicalized_url.SchemeIsFile() ||
+       canonicalized_url.SchemeIsFileSystem() ||
        !canonicalized_url.host().empty()))
     canonicalized_url_ = canonicalized_url;
 
   RemoveForcedQueryStringIfNecessary(type_, &text_);
 }
 
 AutocompleteInput::~AutocompleteInput() {
 }
 
 // static
@@ skipping 51 matching lines @@
                                                  UTF16ToUTF8(desired_tld));
   }
 
   if (LowerCaseEqualsASCII(parsed_scheme, chrome::kFileScheme)) {
     // A user might or might not type a scheme when entering a file URL.  In
     // either case, |parsed_scheme| will tell us that this is a file URL, but
     // |parts->scheme| might be empty, e.g. if the user typed "C:\foo".
     return URL;
   }
 
+  if (LowerCaseEqualsASCII(parsed_scheme, chrome::kFileSystemScheme)) {
+    // This could theoretically be a strange search, but let's check.
+    // If it's got an inner_url with a scheme, it's a URL, whether it's valid or
+    // not.
+    if (parts->inner_parsed() && parts->inner_parsed()->scheme.is_valid())
+      return URL;
+  }
+
   // If the user typed a scheme, and it's HTTP or HTTPS, we know how to parse it
   // well enough that we can fall through to the heuristics below.  If it's
   // something else, we can just determine our action based on what we do with
   // any input of this scheme.  In theory we could do better with some schemes
   // (e.g. "ftp" or "view-source") but I'll wait to spend the effort on that
   // until I run into some cases that really need it.
   if (parts->scheme.is_nonempty() &&
       !LowerCaseEqualsASCII(parsed_scheme, chrome::kHttpScheme) &&
       !LowerCaseEqualsASCII(parsed_scheme, chrome::kHttpsScheme)) {
     // See if we know how to handle the URL internally.
@@ skipping 269 matching lines @@
         scheme->reset();
       }
       if (real_parts.host.is_nonempty()) {
         *host = url_parse::Component(
             after_scheme_and_colon + real_parts.host.begin,
             real_parts.host.len);
       } else {
         host->reset();
       }
     }
+  } else if (LowerCaseEqualsASCII(scheme_str, chrome::kFileSystemScheme) &&
+             parts.inner_parsed() && parts.inner_parsed()->scheme.is_valid()) {
+    *host = parts.inner_parsed()->host;
   }
 }
 
 // static
 string16 AutocompleteInput::FormattedStringWithEquivalentMeaning(
     const GURL& url,
     const string16& formatted_url) {
   if (!net::CanStripTrailingSlash(url))
     return formatted_url;
   const string16 url_with_path(formatted_url + char16('/'));
@@ skipping 616 matching lines @@
     const AutocompleteResult& result)
     : text(text),
       input_type(input_type),
       selected_index(selected_index),
       tab_id(tab_id),
       elapsed_time_since_user_first_modified_omnibox(
           elapsed_time_since_user_first_modified_omnibox),
       inline_autocompleted_length(inline_autocompleted_length),
       result(result) {
 }