Support URL fragment resolution againt non-hierarchical schemes

url/url_canon_relative.cc

 // Copyright 2013 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.
 
 // Canonicalizer functions for working with and resolving relative URLs.
 
 #include "base/logging.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
 #include "url/url_file.h"
@@ skipping 82 matching lines @@
   // shashes should be treated a a relative URL with a hostname.
   if (url_parse::DoesBeginWindowsDriveSpec(url, begin, url_len) ||
       url_parse::DoesBeginUNCPath(url, begin, url_len, true))
     return true;
 #endif  // WIN32
 
   // See if we've got a scheme, if not, we know this is a relative URL.
   // BUT: Just because we have a scheme, doesn't make it absolute.
   // "http:foo.html" is a relative URL with path "foo.html". If the scheme is
   // empty, we treat it as relative (":foo") like IE does.
-  url_parse::Component scheme;
-  if (!url_parse::ExtractScheme(url, url_len, &scheme) || scheme.len == 0) {
-    // Don't allow relative URLs if the base scheme doesn't support it.
-    if (!is_base_hierarchical)
+  url_parse::Parsed url_parsed;
+  url_parse::ParsePathURL(url, url_len, true, &url_parsed);

[brettw, 2013/11/20 00:03:51]

This codepath is called a lot and ParsePathURL and CountCharactersBefore aren't
super fast. Is there a way we can get what you need with less work?

[joth, 2013/11/21 00:08:45]

Done.

Reverted to the scheme lookup to as it was before (url_parse::ExtractScheme) and
looking for bare fragment by inspecting the first char of url for '#'

+  const url_parse::Component& scheme = url_parsed.scheme;
+  const bool scheme_is_empty = !scheme.is_nonempty();
+  if (scheme_is_empty) {
+    // No scheme. See if is a bare fragment.
+    if (url_parsed.ref.is_valid() &&
+        url_parsed.CountCharactersBefore(url_parse::Parsed::REF, true) ==
+        url_parsed.CountCharactersBefore(url_parse::Parsed::SCHEME, false)) {
+      // |url| is a bare fragement. This can be resolved against any base.
+    } else if (!is_base_hierarchical) {
+      // Don't allow relative URLs if the base scheme doesn't support it.
       return false;
+    }
 
     *relative_component = url_parse::MakeRange(begin, url_len);
     *is_relative = true;
     return true;
   }
 
   // If the scheme isn't valid, then it's relative.
   int scheme_end = scheme.end();
   for (int i = scheme.begin; i < scheme_end; i++) {
     if (!CanonicalSchemeChar(url[i])) {
@@ skipping 429 matching lines @@
                         const url_parse::Component& relative_component,
                         CharsetConverter* query_converter,
                         CanonOutput* output,
                         url_parse::Parsed* out_parsed) {
   return DoResolveRelativeURL<base::char16>(
       base_url, base_parsed, base_is_file, relative_url,
       relative_component, query_converter, output, out_parsed);
 }
 
 }  // namespace url_canon