Add support for real full filesystem URL parsing and canonicalization.

src/gurl.h

 // Copyright 2007, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 192 matching lines @@
   // this URL is not a standard URL, then the result will be an empty,
   // invalid GURL. If the URL has neither username nor password, this
   // degenerates to GetWithEmptyPath().
   //
   // It is an error to get the origin of an invalid URL. The result
   // will be the empty URL.
   GURL_API GURL GetOrigin() const;
 
   // Returns true if the scheme for the current URL is a known "standard"
   // scheme. Standard schemes have an authority and a path section. This
-  // includes file:, which some callers may want to filter out explicitly by
-  // calling SchemeIsFile.
+  // includes file: and filesystem:, which some callers may want to filter out
+  // explicitly by calling SchemeIsFile[System].
   GURL_API bool IsStandard() const;
 
   // Returns true if the given parameter (should be lower-case ASCII to match
   // the canonicalized scheme) is the scheme for this URL. This call is more
   // efficient than getting the scheme and comparing it because no copies or
   // object constructions are done.
   GURL_API bool SchemeIs(const char* lower_ascii_scheme) const;
 
   // We often need to know if this is a file URL. File URLs are "standard", but
   // are often treated separately by some programs.
   bool SchemeIsFile() const {
     return SchemeIs("file");
   }
 
+  // FileSystem URLs need to be treated differently in some cases.
+  bool SchemeIsFileSystem() const {
+    return SchemeIs("filesystem");
+  }
+
   // If the scheme indicates a secure connection
   bool SchemeIsSecure() const {
-    return SchemeIs("https");
+    return SchemeIs("https") ||
+        (SchemeIsFileSystem() && inner_url() && inner_url()->SchemeIsSecure());
   }
 
   // Returns true if the hostname is an IP address. Note: this function isn't
   // as cheap as a simple getter because it re-parses the hostname to verify.
   // This currently identifies only IPv4 addresses (bug 822685).
   GURL_API bool HostIsIPAddress() const;
 
   // Getters for various components of the URL. The returned string will be
   // empty if the component is empty or is not present.
   std::string scheme() const {  // Not including the colon. See also SchemeIs.
@@ skipping 98 matching lines @@
 
   // Swaps the contents of this GURL object with the argument without doing
   // any memory allocations.
   GURL_API void Swap(GURL* other);
 
   // Returns a reference to a singleton empty GURL. This object is for callers
   // who return references but don't have anything to return in some cases.
   // This function may be called from any thread.
   GURL_API static const GURL& EmptyGURL();
 
+  // Returns the inner URL of a nested URL [currently only non-null for
+  // filesystem: URLs].
+  const GURL* inner_url() const {
+    return inner_url_;
+  }
+
  private:
   // Returns the substring of the input identified by the given component.
   std::string ComponentString(const url_parse::Component& comp) const {
     if (comp.len <= 0)
       return std::string();
     return std::string(spec_, comp.begin, comp.len);
   }
 
   // The actual text of the URL, in canonical ASCII form.
   std::string spec_;
 
   // Set when the given URL is valid. Otherwise, we may still have a spec and
   // components, but they may not identify valid resources (for example, an
   // invalid port number, invalid characters in the scheme, etc.).
   bool is_valid_;
 
   // Identified components of the canonical spec.
   url_parse::Parsed parsed_;
 
+  // Used for nested schemes [currently only filesystem:].
+  GURL* inner_url_;

[abarth, 2011/11/16 22:02:43]

Should this be a scoped_ptr?

[ericu, 2011/11/16 22:13:37]

I was wondering about that myself.  I'd love to use one, but googleurl doesn't
use them anywhere, so I wanted to ask Brett if that was a style choice or just
that it hadn't needed any.  I see that scoped_ptr.h is in the repo, but it's
only used in logging code in base, not in the src directory.

+
   // TODO bug 684583: Add encoding for query params.
 };
 
 // Stream operator so GURL can be used in assertion statements.
 GURL_API std::ostream& operator<<(std::ostream& out, const GURL& url);
 
 #endif  // GOOGLEURL_SRC_GURL_H__