Add full support for filesystem URLs.

chrome/browser/autocomplete/autocomplete.cc

 // Copyright (c) 2011 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 42 matching lines @@
   // to have a scheme.
   url_parse::Parsed local_parts;
   if (!parts)
     parts = &local_parts;
   const string16 parsed_scheme(URLFixerUpper::SegmentURL(text, parts));
   if (scheme)
     *scheme = parsed_scheme;
   if (canonicalized_url) {
     *canonicalized_url = URLFixerUpper::FixupURL(UTF16ToUTF8(text),
                                                  UTF16ToUTF8(desired_tld));
+    return URL;
   }
 
   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.
+    ParseFileSystemURL(text.data(), text.length(), parts);
+    // 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 594 matching lines @@
   }
   done_ = true;
 }
 
 void AutocompleteController::StartExpireTimer() {
   if (result_.HasCopiedMatches())
     expire_timer_.Start(FROM_HERE,
                         base::TimeDelta::FromMilliseconds(kExpireTimeMS),
                         this, &AutocompleteController::ExpireCopiedEntries);
 }