Support URL fragment resolution againt non-hierarchical schemes

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 105 matching lines @@
   }
   if (found_scheme)
     *found_scheme = our_scheme;
   return DoCompareSchemeComponent(spec, our_scheme, compare);
 }
 
 template<typename CHAR>
 bool DoCanonicalize(const CHAR* in_spec, int in_spec_len,
                     url_canon::CharsetConverter* charset_converter,
                     url_canon::CanonOutput* output,
-                    url_parse::Parsed* output_parsed) {
+                    url_parse::Parsed* output_parsed,
+                    bool trim_tail = true) {
   // Remove any whitespace from the middle of the relative URL, possibly
   // copying to the new buffer.
   url_canon::RawCanonOutputT<CHAR> whitespace_buffer;
   int spec_len;
   const CHAR* spec = RemoveURLWhitespace(in_spec, in_spec_len,
                                          &whitespace_buffer, &spec_len);
 
   url_parse::Parsed parsed_input;
 #ifdef WIN32
   // For Windows, we allow things that look like absolute Windows paths to be
@@ skipping 44 matching lines @@
                                                  output, output_parsed);
 
   } else if (DoCompareSchemeComponent(spec, scheme, kMailtoScheme)) {
     // Mailto are treated like a standard url with only a scheme, path, query
     url_parse::ParseMailtoURL(spec, spec_len, &parsed_input);
     success = url_canon::CanonicalizeMailtoURL(spec, spec_len, parsed_input,
                                                output, output_parsed);
 
   } else {
     // "Weird" URLs like data: and javascript:
-    url_parse::ParsePathURL(spec, spec_len, &parsed_input);
+    url_parse::ParsePathURL(spec, spec_len, &parsed_input, trim_tail);
     success = url_canon::CanonicalizePathURL(spec, spec_len, parsed_input,
                                              output, output_parsed);
   }
   return success;
 }
 
 template<typename CHAR>
 bool DoResolveRelative(const char* base_spec,
                        int base_spec_len,
                        const url_parse::Parsed& base_parsed,
@@ skipping 222 matching lines @@
                           int str_len,
                           const char* compare,
                           url_parse::Component* found_scheme) {
   return DoFindAndCompareScheme(str, str_len, compare, found_scheme);
 }
 
 bool Canonicalize(const char* spec,
                   int spec_len,
                   url_canon::CharsetConverter* charset_converter,
                   url_canon::CanonOutput* output,
-                  url_parse::Parsed* output_parsed) {
+                  url_parse::Parsed* output_parsed,
+                  bool trim_tail) {
   return DoCanonicalize(spec, spec_len, charset_converter,
-                        output, output_parsed);
+                        output, output_parsed,
+                        trim_tail);
 }
 
 bool Canonicalize(const base::char16* spec,
                   int spec_len,
                   url_canon::CharsetConverter* charset_converter,
                   url_canon::CanonOutput* output,
-                  url_parse::Parsed* output_parsed) {
+                  url_parse::Parsed* output_parsed,
+                  bool trim_tail) {
   return DoCanonicalize(spec, spec_len, charset_converter,
-                        output, output_parsed);
+                        output, output_parsed, trim_tail);
 }
 
 bool ResolveRelative(const char* base_spec,
                      int base_spec_len,
                      const url_parse::Parsed& base_parsed,
                      const char* relative,
                      int relative_length,
                      url_canon::CharsetConverter* charset_converter,
                      url_canon::CanonOutput* output,
                      url_parse::Parsed* output_parsed) {
@@ skipping 129 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