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[] = {

[brettw, 2012/12/13 21:31:44]

It would be helpful to see what's going on here if you also added the base case
of no slash after the colon. Even though this is covered elsewhere, it makes it
easier to follow how the slashes change the behavior since so much of following
what's going on is just looking at the unit tests.

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

Done.

+      // 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/"},
+  };
+
+  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;
+  }
+}