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 18 matching lines @@
 // Backend for LowerCaseEqualsASCII.
 template<typename Iter>
 inline bool DoLowerCaseEqualsASCII(Iter a_begin, Iter a_end, const char* b) {
   for (Iter it = a_begin; it != a_end; ++it, ++b) {
     if (!*b || ToLowerASCII(*it) != *b)
       return false;
   }
   return *b == 0;
 }
 
+bool g_kurl_compat_mode = false;
+
 const int kNumStandardURLSchemes = 8;
 const char* kStandardURLSchemes[kNumStandardURLSchemes] = {
   "http",
   "https",
   kFileScheme,  // Yes, file urls can have a hostname!
   "ftp",
   "gopher",
   "ws",  // WebSocket.
   "wss",  // WebSocket secure.
   kFileSystemScheme,
@@ skipping 177 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 (g_kurl_compat_mode && 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 123 matching lines @@
   InitStandardSchemes();
 }
 
 void Shutdown() {
   if (standard_schemes) {
     delete standard_schemes;
     standard_schemes = NULL;
   }
 }
 
+void SetKURLCompatMode(bool enable) {
+  g_kurl_compat_mode = enable;
+}
+
 void AddStandardScheme(const char* new_scheme) {
   // If this assert triggers, it means you've called AddStandardScheme after
   // LockStandardSchemes have been called (see the header file for
   // LockStandardSchemes for more).
   //
   // This normally means you're trying to set up a new standard scheme too late
   // in your application's init process. Locate where your app does this
   // initialization and calls LockStandardScheme, and add your new standard
   // scheme there.
   DCHECK(!standard_schemes_locked) <<
@@ skipping 196 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