Allow fragments to resolve relatively against any scheme

url/url_util.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.
 
 #include "url/url_util.h"
 
 #include <string.h>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 215 matching lines @@
       base_parsed.scheme.is_nonempty() &&
       DoIsStandard(base_spec, base_parsed.scheme);
 
   bool is_relative;
   url_parse::Component relative_component;
   if (!url_canon::IsRelativeURL(base_spec, base_parsed,
                                 relative, relative_length,
                                 (base_is_hierarchical || standard_base_scheme),
                                 &is_relative,
                                 &relative_component)) {
+    if (relative_length && *relative == '#') {
+      // Allow a fragemnt on its own to resolve against any base URL (even non-
+      // hierarchical). First attempt to re-parse the path portion of the base
+      // URL using a more relaxed algorithm for matching fragment sections.
+      url_parse::Parsed base_reparsed = base_parsed;
+      if (base_reparsed.path.is_valid() &&
+          !base_reparsed.query.is_valid() &&
+          !base_reparsed.ref.is_valid()) {
+        const int path_end =  base_reparsed.path.end();
+        for (int i = base_reparsed.path.begin; i < path_end; ++i) {
+          if (base_spec[i] == '#') {
+            base_reparsed.path.len = i - base_reparsed.path.begin;
+            base_reparsed.ref = url_parse::MakeRange(i, path_end);
+            break;
+          }
+        }
+      }
+      return url_canon::ResolveRelativeURL(base_spec, base_reparsed,
+                                           false, relative,
+                                           url_parse::MakeRange(0, relative_length),
+                                           charset_converter,
+                                           output, output_parsed);
+    }
     // Error resolving.
     return false;
   }
 
   // Pretend for a moment that |base_spec| is a standard URL. Normally
   // non-standard URLs are treated as PathURLs, but if the base has an
   // authority we would like to preserve it.
   if (is_relative && base_is_authority_based && !standard_base_scheme) {
     url_parse::Parsed base_parsed_authority;
     ParseStandardURL(base_spec, base_spec_len, &base_parsed_authority);
@@ skipping 339 matching lines @@
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 bool CompareSchemeComponent(const base::char16* spec,
                             const url_parse::Component& component,
                             const char* compare_to) {
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
 }  // namespace url_util