WebKit changes needed for supporting filesystem URLs natively in GURL/KURL.

Source/WebCore/platform/KURLGoogle.cpp

 /*
  * Copyright (C) 2004, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009, 2011 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.
@@ skipping 156 matching lines @@
     , m_utf8IsASCII(true)
     , m_stringIsValid(false)
 {
 }
 
 KURLGooglePrivate::KURLGooglePrivate(WTF::HashTableDeletedValueType)
     : m_string(WTF::HashTableDeletedValue)
 {
 }
  
+KURLGooglePrivate::KURLGooglePrivate(const KURLGooglePrivate& o)
+    : m_isValid(o.m_isValid)
+    , m_protocolIsInHTTPFamily(o.m_protocolIsInHTTPFamily)
+    , m_parsed(o.m_parsed)
+    , m_utf8(o.m_utf8)
+    , m_utf8IsASCII(o.m_utf8IsASCII)
+    , m_stringIsValid(o.m_stringIsValid)
+    , m_string(o.m_string)
+{
+    if (o.m_inner_url.get())
+        m_inner_url = adoptPtr(new KURL(o.m_inner_url->copy()));

[abarth-chromium, 2011/12/20 07:03:15]

m_innerURL.  Can we avoid calling the KURL parser here?  I would have expecetd
the m_innerURL to be kept as a KURL and we can make a copy of it without needing
to invoke the parser.

[ericu, 2011/12/20 23:55:34]

I'm not sure what you mean.  m_inner_url is a KURL, and I don't see an
invocation of the parser here, just KURL's compiler-generated copy constructor.

+}
+
+KURLGooglePrivate& KURLGooglePrivate::operator=(const KURLGooglePrivate& o)
+{
+    m_isValid = o.m_isValid;
+    m_protocolIsInHTTPFamily = o.m_protocolIsInHTTPFamily;
+    m_parsed = o.m_parsed;
+    m_utf8 = o.m_utf8;
+    m_utf8IsASCII = o.m_utf8IsASCII;
+    m_stringIsValid = o.m_stringIsValid;
+    m_string = o.m_string;
+    if (o.m_inner_url.get())
+        m_inner_url = adoptPtr(new KURL(o.m_inner_url->copy()));
+    else
+        m_inner_url.clear();
+    return *this;
+}
+
 // Setters for the data. Using the ASCII version when you know the
 // data is ASCII will be slightly more efficient. The UTF-8 version
 // will always be correct if the caller is unsure.
 void KURLGooglePrivate::setUtf8(const CString& str)
 {
     const char* data = str.data();
     unsigned dataLength = str.length();
 
     // The m_utf8IsASCII must always be correct since the DeprecatedString
     // getter must create it with the proper constructor. This test can be
     // removed when DeprecatedString is gone, but it still might be a
     // performance win.
     m_utf8IsASCII = true;
     for (unsigned i = 0; i < dataLength; i++) {
         if (static_cast<unsigned char>(data[i]) >= 0x80) {
             m_utf8IsASCII = false;
             break;
         }
     }
 
     m_utf8 = str;
     m_stringIsValid = false;
     initProtocolIsInHTTPFamily();
+    initInnerURL();
 }
 
 void KURLGooglePrivate::setAscii(const CString& str)
 {
     m_utf8 = str;
     m_utf8IsASCII = true;
     m_stringIsValid = false;
     initProtocolIsInHTTPFamily();
+    initInnerURL();
 }
 
 void KURLGooglePrivate::init(const KURL& base,
                              const String& relative,
                              const TextEncoding* queryEncoding)
 {
     init(base, relative.characters(), relative.length(), queryEncoding);
 }
 
 template <typename CHAR>
@@ skipping 33 matching lines @@
         if (m_parsed.ref.is_nonempty())
             setUtf8(CString(output.data(), output.length()));
         else
             setAscii(CString(output.data(), output.length()));
     } else {
         // WebCore expects resolved URLs to be empty rather than null.
         setUtf8(CString("", 0));
     }
 }
 
+void KURLGooglePrivate::initInnerURL() {
+    if (!m_isValid) {
+        m_inner_url.clear();
+        return;
+    }
+    url_parse::Parsed* inner_parsed = m_parsed.inner_parsed();

[abarth-chromium, 2011/12/20 07:03:15]

innerParsed

[ericu, 2011/12/20 23:55:34]

Done.

+    if (inner_parsed)
+        m_inner_url = adoptPtr(new KURL(
+            ParsedURLString,
+            String(
+                m_utf8.data() + inner_parsed->scheme.begin,
+                inner_parsed->Length() - inner_parsed->scheme.begin)));

[abarth-chromium, 2011/12/20 07:03:15]

There's no 80 column limit in WebKit.  You can go nuts and have excitingly long
lines!

[ericu, 2011/12/20 23:55:34]

s/excitingly/excruciatingly/, but OK ;'>.

+    else
+        m_inner_url.clear();
+}
+
 void KURLGooglePrivate::initProtocolIsInHTTPFamily()
 {
     if (!m_isValid) {
         m_protocolIsInHTTPFamily = false;
         return;
     }
 
     const char* scheme = m_utf8.data() + m_parsed.scheme.begin;
     if (m_parsed.scheme.len == 4)
         m_protocolIsInHTTPFamily = lowerCaseEqualsASCII(scheme, scheme + 4, "http");
     else if (m_parsed.scheme.len == 5)
         m_protocolIsInHTTPFamily = lowerCaseEqualsASCII(scheme, scheme + 5, "https");
     else
         m_protocolIsInHTTPFamily = false;
 }
 
 void KURLGooglePrivate::copyTo(KURLGooglePrivate* dest) const
 {
     dest->m_isValid = m_isValid;
     dest->m_protocolIsInHTTPFamily = m_protocolIsInHTTPFamily;
     dest->m_parsed = m_parsed;
 
     // Don't copy the 16-bit string since that will be regenerated as needed.
     dest->m_utf8 = CString(m_utf8.data(), m_utf8.length());
     dest->m_utf8IsASCII = m_utf8IsASCII;
     dest->m_stringIsValid = false;
     dest->m_string = String(); // Clear the invalid string to avoid cross thread ref counting.
+    if (m_inner_url) {
+      dest->m_inner_url = adoptPtr(new KURL(m_inner_url->copy()));
+    }
+    else
+      dest->m_inner_url.clear();
 }
 
 String KURLGooglePrivate::componentString(const url_parse::Component& comp) const
 {
     if (!m_isValid || comp.len <= 0) {
         // KURL returns a null string if the URL is itself a null string, and an
         // empty string for other nonexistent entities.
         if (utf8String().isNull())
             return String();
         return String("", 0);
@@ skipping 522 matching lines @@
         reinterpret_cast<const UChar*>(notEncodedString.characters()),
         notEncodedString.length(),
         URLEncodedEntitiesForUnencodables);
     const char* input = utf8.data();
     int inputLength = utf8.length();
     url_canon::RawCanonOutputT<char> buffer;
     if (buffer.length() < inputLength * 3)
         buffer.Resize(inputLength * 3);
 
     url_util::EncodeURIComponent(input, inputLength, &buffer);
-    return String(buffer.data(), buffer.length());
+    String escaped(buffer.data(), buffer.length());
+    // Unescape '/'; it's safe and much prettier.
+    escaped.replace("%2F", "/");
+    return escaped;
 }
 
 bool KURL::isHierarchical() const
 {
     if (!m_url.m_parsed.scheme.is_nonempty())
         return false;
     return url_util::IsStandard(
         &m_url.utf8String().data()[m_url.m_parsed.scheme.begin],
         m_url.m_parsed.scheme);
 }
@@ skipping 102 matching lines @@
     
     if (a.port() != b.port())
         return false;
 
     return true;
 }
 
 } // namespace WebCore
 
 #endif // USE(GOOGLEURL)