Support URL fragment resolution againt non-hierarchical schemes

url/gurl.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.
 
 #ifdef WIN32
 #include <windows.h>
 #else
 #include <pthread.h>
 #endif
 
 #include <algorithm>
 #include <ostream>
 
 #include "url/gurl.h"
 
 #include "base/logging.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_util.h"
 
 namespace {
 
 // External template that can handle initialization of either character type.
 // The input spec is given, and the canonical version will be placed in
 // |*canonical|, along with the parsing of the canonical spec in |*parsed|.
 template<typename STR>
 bool InitCanonical(const STR& input_spec,
                    std::string* canonical,
-                   url_parse::Parsed* parsed) {
+                   url_parse::Parsed* parsed,
+                   bool trim_tail = true) {
   // Reserve enough room in the output for the input, plus some extra so that
   // we have room if we have to escape a few things without reallocating.
   canonical->reserve(input_spec.size() + 32);
   url_canon::StdStringCanonOutput output(canonical);
   bool success = url_util::Canonicalize(
       input_spec.data(), static_cast<int>(input_spec.length()),
-      NULL, &output, parsed);
+      NULL, &output, parsed, trim_tail);
 
   output.Complete();  // Must be done before using string.
   return success;
 }
 
 static std::string* empty_string = NULL;
 static GURL* empty_gurl = NULL;
 
 #ifdef WIN32
 
@@ skipping 93 matching lines @@
   // what we would have produced. Skip checking for invalid URLs have no meaning
   // and we can't always canonicalize then reproducabely.
   if (is_valid_) {
     url_parse::Component scheme;
     if (!url_util::FindAndCompareScheme(spec_.data(), spec_.length(),
                                         "filesystem", &scheme) ||
         scheme.begin == parsed_.scheme.begin) {
       // We can't do this check on the inner_url of a filesystem URL, as
       // canonical_spec actually points to the start of the outer URL, so we'd
       // end up with infinite recursion in this constructor.
-      GURL test_url(spec_);
+      std::string test_spec;
+      url_parse::Parsed test_parsed;
+      bool test_is_valid = InitCanonical(spec_, &test_spec,
+                                         &test_parsed, false);
 
-      DCHECK(test_url.is_valid_ == is_valid_);
-      DCHECK(test_url.spec_ == spec_);
+      DCHECK_EQ(test_is_valid, is_valid_);
 
-      DCHECK(test_url.parsed_.scheme == parsed_.scheme);
-      DCHECK(test_url.parsed_.username == parsed_.username);
-      DCHECK(test_url.parsed_.password == parsed_.password);
-      DCHECK(test_url.parsed_.host == parsed_.host);
-      DCHECK(test_url.parsed_.port == parsed_.port);
-      DCHECK(test_url.parsed_.path == parsed_.path);
-      DCHECK(test_url.parsed_.query == parsed_.query);
-      DCHECK(test_url.parsed_.ref == parsed_.ref);
+      DCHECK_EQ(test_spec, spec_);
+      DCHECK(test_parsed.scheme == parsed_.scheme);
+      DCHECK(test_parsed.username == parsed_.username);
+      DCHECK(test_parsed.password == parsed_.password);
+      DCHECK(test_parsed.host == parsed_.host);
+      DCHECK(test_parsed.port == parsed_.port);
+      DCHECK(test_parsed.path == parsed_.path);
+      DCHECK(test_parsed.query == parsed_.query);
+      DCHECK(test_parsed.ref == parsed_.ref);
     }
   }
 #endif
 }
 
 GURL::~GURL() {
   delete inner_url_;
 }
 
 GURL& GURL::operator=(const GURL& other) {
@@ skipping 340 matching lines @@
 void GURL::Swap(GURL* other) {
   spec_.swap(other->spec_);
   std::swap(is_valid_, other->is_valid_);
   std::swap(parsed_, other->parsed_);
   std::swap(inner_url_, other->inner_url_);
 }
 
 std::ostream& operator<<(std::ostream& out, const GURL& url) {
   return out << url.possibly_invalid_spec();
 }