Make ResolveRelative work with all hierarchical URLs.

src/url_util_unittest.cc

 // Copyright 2008, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 231 matching lines @@
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(encode_cases); i++) {
     const char* input = encode_cases[i].input;
     url_canon::RawCanonOutputT<char> buffer;
     url_util::EncodeURIComponent(input, strlen(input), &buffer);
     std::string output(buffer.data(), buffer.length());
     EXPECT_EQ(encode_cases[i].output, output);
   }
 }
 
+TEST(URLUtilTest, TestResolveRelativeWithNonStandardBase) {
+  // This tests non-standard (in the sense that GURL::IsStandard() == false)
+  // hierarchical schemes.
+  struct ResolveRelativeCase {
+    const char* base;
+    const char* rel;
+    bool is_valid;
+    const char* out;
+  } resolve_non_standard_cases[] = {
+      // Resolving a relative path against a non-hierarchical URL should fail.
+    {"scheme:opaque_data", "/path", false, ""},
+      // Resolving a relative path against a non-standard authority-based base
+      // URL doesn't alter the authority section.
+    {"scheme://Authority/", "../path", true, "scheme://Authority/path"},
+      // A non-standard hierarchical base is resolved with path URL
+      // canoncialization rules.
+    {"data:/Blah:Blah/", "file.html", true, "data:/Blah:Blah/file.html"},
+    {"data:/Path/../part/part2", "file.html", true, "data:/Path/../part/file.html"},
+      // Path URL canonicalization rules also apply to non-standard authority-
+      // based URLs.
+    {"custom://Authority/", "file.html", true, "custom://Authority/file.html"},
+    {"custom://Authority/", "other://Auth/", true, "other://Auth/"},
+    {"custom://Authority/", "../../file.html", true, "custom://Authority/file.html"},
+    {"custom://Authority/path/", "file.html", true, "custom://Authority/path/file.html"},
+    {"custom://Authority:NoCanon/path/", "file.html", true, "custom://Authority:NoCanon/path/file.html"},
+      // It's still possible to get an invalid path URL.
+    {"custom://Invalid:!#Auth/", "file.html", false, ""},
+      // A path with an authority section gets canonicalized under standard URL
+      // rules, even though the base was non-standard.
+    {"content://content.Provider/", "//other.Provider", true, "content://other.provider/"},
+      // Resolving an absolute URL doesn't cause canonicalization of the
+      // result.
+    {"about:blank", "custom://Authority", true, "custom://Authority"},

[mkosiba (inactive), 2012/12/18 18:54:07]

For now we're going to live with this and ask app developers to append a slash
at the end of their custom scheme and/or content:// scheme base URL.

This will need to be re-visited some time later (http://crbug.com/166675) but
I'd like to see if this change sticks before I try and fix this.

+      // Resolving should fail if the base URL is authority-based but is
+      // missing a path component (the '/' at the end).
+    {"scheme://Authority", "path", false, ""},
+  };
+
+  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),
+                            &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;
+  }
+}