Support URL fragment resolution againt non-hierarchical schemes

url/url_canon_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 <errno.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/icu/source/common/unicode/ucnv.h"
 #include "url/url_canon.h"
 #include "url/url_canon_icu.h"
@@ skipping 1591 matching lines @@
       // Replace one or the other
     {"data:foo", "javascript", NULL, NULL, NULL, NULL, NULL, NULL, NULL, "javascript:foo"},
     {"data:foo", NULL, NULL, NULL, NULL, NULL, "bar", NULL, NULL, "data:bar"},
     {"data:foo", NULL, NULL, NULL, NULL, NULL, kDeleteComp, NULL, NULL, "data:"},
   };
 
   for (size_t i = 0; i < arraysize(replace_cases); i++) {
     const ReplaceCase& cur = replace_cases[i];
     int base_len = static_cast<int>(strlen(cur.base));
     url_parse::Parsed parsed;
-    url_parse::ParsePathURL(cur.base, base_len, &parsed);
+    url_parse::ParsePathURL(cur.base, base_len, false, &parsed);
 
     url_canon::Replacements<char> r;
     typedef url_canon::Replacements<char> R;  // Clean up syntax.
     SetupReplComp(&R::SetScheme, &R::ClearRef, &r, cur.scheme);
     SetupReplComp(&R::SetUsername, &R::ClearUsername, &r, cur.username);
     SetupReplComp(&R::SetPassword, &R::ClearPassword, &r, cur.password);
     SetupReplComp(&R::SetHost, &R::ClearHost, &r, cur.host);
     SetupReplComp(&R::SetPort, &R::ClearPort, &r, cur.port);
     SetupReplComp(&R::SetPath, &R::ClearPath, &r, cur.path);
     SetupReplComp(&R::SetQuery, &R::ClearQuery, &r, cur.query);
@@ skipping 200 matching lines @@
     const char* expected;
   } path_cases[] = {
     {"javascript:", "javascript:"},
     {"JavaScript:Foo", "javascript:Foo"},
     {":\":This /is interesting;?#", ":\":This /is interesting;?#"},
   };
 
   for (size_t i = 0; i < ARRAYSIZE(path_cases); i++) {
     int url_len = static_cast<int>(strlen(path_cases[i].input));
     url_parse::Parsed parsed;
-    url_parse::ParsePathURL(path_cases[i].input, url_len, &parsed);
+    url_parse::ParsePathURL(path_cases[i].input, url_len, true, &parsed);
 
     url_parse::Parsed out_parsed;
     std::string out_str;
     url_canon::StdStringCanonOutput output(&out_str);
     bool success = url_canon::CanonicalizePathURL(path_cases[i].input, url_len,
                                                   parsed, &output,
                                                   &out_parsed);
     output.Complete();
 
     EXPECT_TRUE(success);
     EXPECT_EQ(path_cases[i].expected, out_str);
 
     EXPECT_EQ(0, out_parsed.host.begin);
     EXPECT_EQ(-1, out_parsed.host.len);
 
     // When we end with a colon at the end, there should be no path.
     if (path_cases[i].input[url_len - 1] == ':') {
-      EXPECT_EQ(0, out_parsed.path.begin);
-      EXPECT_EQ(-1, out_parsed.path.len);
+      EXPECT_EQ(0, out_parsed.GetContent().begin);
+      EXPECT_EQ(-1, out_parsed.GetContent().len);
     }
   }
 }
 
 TEST(URLCanonTest, CanonicalizeMailtoURL) {
   struct URLCase {
     const char* input;
     const char* expected;
     bool expected_success;
     url_parse::Component expected_path;
@@ skipping 286 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE(rel_cases); i++) {
     const RelativeCase& cur_case = rel_cases[i];
 
     url_parse::Parsed parsed;
     int base_len = static_cast<int>(strlen(cur_case.base));
     if (cur_case.is_base_file)
       url_parse::ParseFileURL(cur_case.base, base_len, &parsed);
     else if (cur_case.is_base_hier)
       url_parse::ParseStandardURL(cur_case.base, base_len, &parsed);
     else
-      url_parse::ParsePathURL(cur_case.base, base_len, &parsed);
+      url_parse::ParsePathURL(cur_case.base, base_len, false, &parsed);
 
     // First see if it is relative.
     int test_len = static_cast<int>(strlen(cur_case.test));
     bool is_relative;
     url_parse::Component relative_component;
     bool succeed_is_rel = url_canon::IsRelativeURL(
         cur_case.base, parsed, cur_case.test, test_len, cur_case.is_base_hier,
         &is_relative, &relative_component);
 
     EXPECT_EQ(cur_case.succeed_relative, succeed_is_rel) <<
@@ skipping 11 matching lines @@
           cur_case.test, relative_component, NULL, &output, &resolved_parsed);
       output.Complete();
 
       EXPECT_EQ(cur_case.succeed_resolve, succeed_resolve);
       EXPECT_EQ(cur_case.resolved, resolved) << " on " << cur_case.test;
 
       // Verify that the output parsed structure is the same as parsing a
       // the URL freshly.
       url_parse::Parsed ref_parsed;
       int resolved_len = static_cast<int>(resolved.size());
-      if (cur_case.is_base_file)
+      if (cur_case.is_base_file) {
         url_parse::ParseFileURL(resolved.c_str(), resolved_len, &ref_parsed);
-      else if (cur_case.is_base_hier)
-        url_parse::ParseStandardURL(resolved.c_str(), resolved_len, &ref_parsed);
-      else
-        url_parse::ParsePathURL(resolved.c_str(), resolved_len, &ref_parsed);
+      } else if (cur_case.is_base_hier) {
+        url_parse::ParseStandardURL(resolved.c_str(), resolved_len,
+                                    &ref_parsed);
+      } else {
+        url_parse::ParsePathURL(resolved.c_str(), resolved_len, false,
+                                &ref_parsed);
+      }
       EXPECT_TRUE(ParsedIsEqual(ref_parsed, resolved_parsed));
     }
   }
 }
 
 // It used to be when we did a replacement with a long buffer of UTF-16
 // characters, we would get invalid data in the URL. This is because the buffer
 // it used to hold the UTF-8 data was resized, while some pointers were still
 // kept to the old buffer that was removed.
 TEST(URLCanonTest, ReplacementOverflow) {
@@ skipping 22 matching lines @@
   url_canon::StdStringCanonOutput repl_output(&repl_str);
   url_canon::ReplaceFileURL(src, parsed, repl, NULL, &repl_output, &repl_parsed);
   repl_output.Complete();
 
   // Generate the expected string and check.
   std::string expected("file:///foo?");
   for (size_t i = 0; i < new_query.length(); i++)
     expected.push_back('a');
   EXPECT_TRUE(expected == repl_str);
 }