Support URL fragment resolution againt non-hierarchical schemes

url/url_util_unittest.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 "testing/gtest/include/gtest/gtest.h"
 #include "url/url_canon.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_parse.h"
 #include "url/url_test_utils.h"
 #include "url/url_util.h"
@@ skipping 75 matching lines @@
                               &new_parsed);
   url_util::ReplaceComponents("", 0, parsed, replacements, NULL, &output,
                               &new_parsed);
 }
 
 static std::string CheckReplaceScheme(const char* base_url,
                                       const char* scheme) {
   // Make sure the input is canonicalized.
   url_canon::RawCanonOutput<32> original;
   url_parse::Parsed original_parsed;
-  url_util::Canonicalize(base_url, strlen(base_url), NULL,
+  url_util::Canonicalize(base_url, strlen(base_url), true, NULL,
                          &original, &original_parsed);
 
   url_canon::Replacements<char> replacements;
   replacements.SetScheme(scheme, url_parse::Component(0, strlen(scheme)));
 
   std::string output_string;
   url_canon::StdStringCanonOutput output(&output_string);
   url_parse::Parsed output_parsed;
   url_util::ReplaceComponents(original.data(), original.length(),
                               original_parsed, replacements, NULL,
@@ skipping 156 matching lines @@
       // Resolving an absolute URL doesn't cause canonicalization of the
       // result.
     {"about:blank", "custom://Authority", true, "custom://Authority"},
       // Fragment URLs can be resolved against a non-standard base.
     {"scheme://Authority/path", "#fragment", true,
       "scheme://Authority/path#fragment"},
     {"scheme://Authority/", "#fragment", true, "scheme://Authority/#fragment"},
       // Resolving should fail if the base URL is authority-based but is
       // missing a path component (the '/' at the end).
     {"scheme://Authority", "path", false, ""},
+      // Test resolving a fragment (only) against any kind of base-URL.
+    {"about:blank", "#id42", true, "about:blank#id42" },
+    {"about:blank#oldfrag", "#newfrag", true, "about:blank#newfrag" },
+      // A surprising side effect of allowing fragments to resolve against
+      // any URL scheme is we might break javascript: URLs by doing so...
+    {"javascript:alert('foo#bar')", "#badfrag", true,
+      "javascript:alert('foo#badfrag" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(resolve_non_standard_cases); i++) {
     const ResolveRelativeCase& test_data = resolve_non_standard_cases[i];
     url_parse::Parsed base_parsed;
-    url_parse::ParsePathURL(test_data.base, strlen(test_data.base),
+    url_parse::ParsePathURL(test_data.base, strlen(test_data.base), false,
                             &base_parsed);
 
     std::string resolved;
     url_canon::StdStringCanonOutput output(&resolved);
     url_parse::Parsed resolved_parsed;
     bool valid =
         url_util::ResolveRelative(test_data.base, strlen(test_data.base),
                                   base_parsed,
                                   test_data.rel, strlen(test_data.rel),
                                   NULL, &output, &resolved_parsed);
     output.Complete();
 
     EXPECT_EQ(test_data.is_valid, valid) << i;
     if (test_data.is_valid && valid)
       EXPECT_EQ(test_data.out, resolved) << i;
   }
 }