Deleted check for if Aes128Gcm12Encrypter::IsSupported or not beacuse we
[chromium-blink-merge.git] / url / gurl.cc
blob229df5dca2dbd6d1ab3de26c96d4d3afca49b60b
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifdef WIN32
6 #include <windows.h>
7 #else
8 #include <pthread.h>
9 #endif
11 #include <algorithm>
12 #include <ostream>
14 #include "url/gurl.h"
16 #include "base/logging.h"
17 #include "url/url_canon_stdstring.h"
18 #include "url/url_util.h"
20 namespace {
22 // External template that can handle initialization of either character type.
23 // The input spec is given, and the canonical version will be placed in
24 // |*canonical|, along with the parsing of the canonical spec in |*parsed|.
25 template<typename STR>
26 bool InitCanonical(const STR& input_spec,
27 std::string* canonical,
28 url_parse::Parsed* parsed) {
29 // Reserve enough room in the output for the input, plus some extra so that
30 // we have room if we have to escape a few things without reallocating.
31 canonical->reserve(input_spec.size() + 32);
32 url_canon::StdStringCanonOutput output(canonical);
33 bool success = url_util::Canonicalize(
34 input_spec.data(), static_cast<int>(input_spec.length()),
35 NULL, &output, parsed);
37 output.Complete(); // Must be done before using string.
38 return success;
41 static std::string* empty_string = NULL;
42 static GURL* empty_gurl = NULL;
44 #ifdef WIN32
46 // Returns a static reference to an empty string for returning a reference
47 // when there is no underlying string.
48 const std::string& EmptyStringForGURL() {
49 // Avoid static object construction/destruction on startup/shutdown.
50 if (!empty_string) {
51 // Create the string. Be careful that we don't break in the case that this
52 // is being called from multiple threads. Statics are not threadsafe.
53 std::string* new_empty_string = new std::string;
54 if (InterlockedCompareExchangePointer(
55 reinterpret_cast<PVOID*>(&empty_string), new_empty_string, NULL)) {
56 // The old value was non-NULL, so no replacement was done. Another
57 // thread did the initialization out from under us.
58 delete new_empty_string;
61 return *empty_string;
64 #else
66 static pthread_once_t empty_string_once = PTHREAD_ONCE_INIT;
67 static pthread_once_t empty_gurl_once = PTHREAD_ONCE_INIT;
69 void EmptyStringForGURLOnce(void) {
70 empty_string = new std::string;
73 const std::string& EmptyStringForGURL() {
74 // Avoid static object construction/destruction on startup/shutdown.
75 pthread_once(&empty_string_once, EmptyStringForGURLOnce);
76 return *empty_string;
79 #endif // WIN32
81 } // namespace
83 GURL::GURL() : is_valid_(false), inner_url_(NULL) {
86 GURL::GURL(const GURL& other)
87 : spec_(other.spec_),
88 is_valid_(other.is_valid_),
89 parsed_(other.parsed_),
90 inner_url_(NULL) {
91 if (other.inner_url_)
92 inner_url_ = new GURL(*other.inner_url_);
93 // Valid filesystem urls should always have an inner_url_.
94 DCHECK(!is_valid_ || !SchemeIsFileSystem() || inner_url_);
97 GURL::GURL(const std::string& url_string) : inner_url_(NULL) {
98 is_valid_ = InitCanonical(url_string, &spec_, &parsed_);
99 if (is_valid_ && SchemeIsFileSystem()) {
100 inner_url_ =
101 new GURL(spec_.data(), parsed_.Length(), *parsed_.inner_parsed(), true);
105 GURL::GURL(const base::string16& url_string) : inner_url_(NULL) {
106 is_valid_ = InitCanonical(url_string, &spec_, &parsed_);
107 if (is_valid_ && SchemeIsFileSystem()) {
108 inner_url_ =
109 new GURL(spec_.data(), parsed_.Length(), *parsed_.inner_parsed(), true);
113 GURL::GURL(const char* canonical_spec, size_t canonical_spec_len,
114 const url_parse::Parsed& parsed, bool is_valid)
115 : spec_(canonical_spec, canonical_spec_len),
116 is_valid_(is_valid),
117 parsed_(parsed),
118 inner_url_(NULL) {
119 InitializeFromCanonicalSpec();
122 GURL::GURL(std::string canonical_spec,
123 const url_parse::Parsed& parsed, bool is_valid)
124 : is_valid_(is_valid),
125 parsed_(parsed),
126 inner_url_(NULL) {
127 spec_.swap(canonical_spec);
128 InitializeFromCanonicalSpec();
131 void GURL::InitializeFromCanonicalSpec() {
132 if (is_valid_ && SchemeIsFileSystem()) {
133 inner_url_ =
134 new GURL(spec_.data(), parsed_.Length(), *parsed_.inner_parsed(), true);
137 #ifndef NDEBUG
138 // For testing purposes, check that the parsed canonical URL is identical to
139 // what we would have produced. Skip checking for invalid URLs have no meaning
140 // and we can't always canonicalize then reproducabely.
141 if (is_valid_) {
142 url_parse::Component scheme;
143 if (!url_util::FindAndCompareScheme(spec_.data(), spec_.length(),
144 "filesystem", &scheme) ||
145 scheme.begin == parsed_.scheme.begin) {
146 // We can't do this check on the inner_url of a filesystem URL, as
147 // canonical_spec actually points to the start of the outer URL, so we'd
148 // end up with infinite recursion in this constructor.
149 GURL test_url(spec_);
151 DCHECK(test_url.is_valid_ == is_valid_);
152 DCHECK(test_url.spec_ == spec_);
154 DCHECK(test_url.parsed_.scheme == parsed_.scheme);
155 DCHECK(test_url.parsed_.username == parsed_.username);
156 DCHECK(test_url.parsed_.password == parsed_.password);
157 DCHECK(test_url.parsed_.host == parsed_.host);
158 DCHECK(test_url.parsed_.port == parsed_.port);
159 DCHECK(test_url.parsed_.path == parsed_.path);
160 DCHECK(test_url.parsed_.query == parsed_.query);
161 DCHECK(test_url.parsed_.ref == parsed_.ref);
164 #endif
167 GURL::~GURL() {
168 delete inner_url_;
171 GURL& GURL::operator=(const GURL& other) {
172 spec_ = other.spec_;
173 is_valid_ = other.is_valid_;
174 parsed_ = other.parsed_;
175 delete inner_url_;
176 inner_url_ = NULL;
177 if (other.inner_url_)
178 inner_url_ = new GURL(*other.inner_url_);
179 // Valid filesystem urls should always have an inner_url_.
180 DCHECK(!is_valid_ || !SchemeIsFileSystem() || inner_url_);
181 return *this;
184 const std::string& GURL::spec() const {
185 if (is_valid_ || spec_.empty())
186 return spec_;
188 DCHECK(false) << "Trying to get the spec of an invalid URL!";
189 return EmptyStringForGURL();
192 GURL GURL::Resolve(const std::string& relative) const {
193 return ResolveWithCharsetConverter(relative, NULL);
195 GURL GURL::Resolve(const base::string16& relative) const {
196 return ResolveWithCharsetConverter(relative, NULL);
199 // Note: code duplicated below (it's inconvenient to use a template here).
200 GURL GURL::ResolveWithCharsetConverter(
201 const std::string& relative,
202 url_canon::CharsetConverter* charset_converter) const {
203 // Not allowed for invalid URLs.
204 if (!is_valid_)
205 return GURL();
207 GURL result;
209 // Reserve enough room in the output for the input, plus some extra so that
210 // we have room if we have to escape a few things without reallocating.
211 result.spec_.reserve(spec_.size() + 32);
212 url_canon::StdStringCanonOutput output(&result.spec_);
214 if (!url_util::ResolveRelative(
215 spec_.data(), static_cast<int>(spec_.length()), parsed_,
216 relative.data(), static_cast<int>(relative.length()),
217 charset_converter, &output, &result.parsed_)) {
218 // Error resolving, return an empty URL.
219 return GURL();
222 output.Complete();
223 result.is_valid_ = true;
224 if (result.SchemeIsFileSystem()) {
225 result.inner_url_ = new GURL(result.spec_.data(), result.parsed_.Length(),
226 *result.parsed_.inner_parsed(), true);
228 return result;
231 // Note: code duplicated above (it's inconvenient to use a template here).
232 GURL GURL::ResolveWithCharsetConverter(
233 const base::string16& relative,
234 url_canon::CharsetConverter* charset_converter) const {
235 // Not allowed for invalid URLs.
236 if (!is_valid_)
237 return GURL();
239 GURL result;
241 // Reserve enough room in the output for the input, plus some extra so that
242 // we have room if we have to escape a few things without reallocating.
243 result.spec_.reserve(spec_.size() + 32);
244 url_canon::StdStringCanonOutput output(&result.spec_);
246 if (!url_util::ResolveRelative(
247 spec_.data(), static_cast<int>(spec_.length()), parsed_,
248 relative.data(), static_cast<int>(relative.length()),
249 charset_converter, &output, &result.parsed_)) {
250 // Error resolving, return an empty URL.
251 return GURL();
254 output.Complete();
255 result.is_valid_ = true;
256 if (result.SchemeIsFileSystem()) {
257 result.inner_url_ = new GURL(result.spec_.data(), result.parsed_.Length(),
258 *result.parsed_.inner_parsed(), true);
260 return result;
263 // Note: code duplicated below (it's inconvenient to use a template here).
264 GURL GURL::ReplaceComponents(
265 const url_canon::Replacements<char>& replacements) const {
266 GURL result;
268 // Not allowed for invalid URLs.
269 if (!is_valid_)
270 return GURL();
272 // Reserve enough room in the output for the input, plus some extra so that
273 // we have room if we have to escape a few things without reallocating.
274 result.spec_.reserve(spec_.size() + 32);
275 url_canon::StdStringCanonOutput output(&result.spec_);
277 result.is_valid_ = url_util::ReplaceComponents(
278 spec_.data(), static_cast<int>(spec_.length()), parsed_, replacements,
279 NULL, &output, &result.parsed_);
281 output.Complete();
282 if (result.is_valid_ && result.SchemeIsFileSystem()) {
283 result.inner_url_ = new GURL(spec_.data(), result.parsed_.Length(),
284 *result.parsed_.inner_parsed(), true);
286 return result;
289 // Note: code duplicated above (it's inconvenient to use a template here).
290 GURL GURL::ReplaceComponents(
291 const url_canon::Replacements<base::char16>& replacements) const {
292 GURL result;
294 // Not allowed for invalid URLs.
295 if (!is_valid_)
296 return GURL();
298 // Reserve enough room in the output for the input, plus some extra so that
299 // we have room if we have to escape a few things without reallocating.
300 result.spec_.reserve(spec_.size() + 32);
301 url_canon::StdStringCanonOutput output(&result.spec_);
303 result.is_valid_ = url_util::ReplaceComponents(
304 spec_.data(), static_cast<int>(spec_.length()), parsed_, replacements,
305 NULL, &output, &result.parsed_);
307 output.Complete();
308 if (result.is_valid_ && result.SchemeIsFileSystem()) {
309 result.inner_url_ = new GURL(spec_.data(), result.parsed_.Length(),
310 *result.parsed_.inner_parsed(), true);
312 return result;
315 GURL GURL::GetOrigin() const {
316 // This doesn't make sense for invalid or nonstandard URLs, so return
317 // the empty URL
318 if (!is_valid_ || !IsStandard())
319 return GURL();
321 if (SchemeIsFileSystem())
322 return inner_url_->GetOrigin();
324 url_canon::Replacements<char> replacements;
325 replacements.ClearUsername();
326 replacements.ClearPassword();
327 replacements.ClearPath();
328 replacements.ClearQuery();
329 replacements.ClearRef();
331 return ReplaceComponents(replacements);
334 GURL GURL::GetWithEmptyPath() const {
335 // This doesn't make sense for invalid or nonstandard URLs, so return
336 // the empty URL.
337 if (!is_valid_ || !IsStandard())
338 return GURL();
340 // We could optimize this since we know that the URL is canonical, and we are
341 // appending a canonical path, so avoiding re-parsing.
342 GURL other(*this);
343 if (parsed_.path.len == 0)
344 return other;
346 // Clear everything after the path.
347 other.parsed_.query.reset();
348 other.parsed_.ref.reset();
350 // Set the path, since the path is longer than one, we can just set the
351 // first character and resize.
352 other.spec_[other.parsed_.path.begin] = '/';
353 other.parsed_.path.len = 1;
354 other.spec_.resize(other.parsed_.path.begin + 1);
355 return other;
358 bool GURL::IsStandard() const {
359 return url_util::IsStandard(spec_.data(), parsed_.scheme);
362 bool GURL::SchemeIs(const char* lower_ascii_scheme) const {
363 if (parsed_.scheme.len <= 0)
364 return lower_ascii_scheme == NULL;
365 return url_util::LowerCaseEqualsASCII(spec_.data() + parsed_.scheme.begin,
366 spec_.data() + parsed_.scheme.end(),
367 lower_ascii_scheme);
370 bool GURL::SchemeIsHTTPOrHTTPS() const {
371 return SchemeIs("http") || SchemeIs("https");
374 int GURL::IntPort() const {
375 if (parsed_.port.is_nonempty())
376 return url_parse::ParsePort(spec_.data(), parsed_.port);
377 return url_parse::PORT_UNSPECIFIED;
380 int GURL::EffectiveIntPort() const {
381 int int_port = IntPort();
382 if (int_port == url_parse::PORT_UNSPECIFIED && IsStandard())
383 return url_canon::DefaultPortForScheme(spec_.data() + parsed_.scheme.begin,
384 parsed_.scheme.len);
385 return int_port;
388 std::string GURL::ExtractFileName() const {
389 url_parse::Component file_component;
390 url_parse::ExtractFileName(spec_.data(), parsed_.path, &file_component);
391 return ComponentString(file_component);
394 std::string GURL::PathForRequest() const {
395 DCHECK(parsed_.path.len > 0) << "Canonical path for requests should be non-empty";
396 if (parsed_.ref.len >= 0) {
397 // Clip off the reference when it exists. The reference starts after the #
398 // sign, so we have to subtract one to also remove it.
399 return std::string(spec_, parsed_.path.begin,
400 parsed_.ref.begin - parsed_.path.begin - 1);
402 // Compute the actual path length, rather than depending on the spec's
403 // terminator. If we're an inner_url, our spec continues on into our outer
404 // url's path/query/ref.
405 int path_len = parsed_.path.len;
406 if (parsed_.query.is_valid())
407 path_len = parsed_.query.end() - parsed_.path.begin;
409 return std::string(spec_, parsed_.path.begin, path_len);
412 std::string GURL::HostNoBrackets() const {
413 // If host looks like an IPv6 literal, strip the square brackets.
414 url_parse::Component h(parsed_.host);
415 if (h.len >= 2 && spec_[h.begin] == '[' && spec_[h.end() - 1] == ']') {
416 h.begin++;
417 h.len -= 2;
419 return ComponentString(h);
422 bool GURL::HostIsIPAddress() const {
423 if (!is_valid_ || spec_.empty())
424 return false;
426 url_canon::RawCanonOutputT<char, 128> ignored_output;
427 url_canon::CanonHostInfo host_info;
428 url_canon::CanonicalizeIPAddress(spec_.c_str(), parsed_.host,
429 &ignored_output, &host_info);
430 return host_info.IsIPAddress();
433 #ifdef WIN32
435 const GURL& GURL::EmptyGURL() {
436 // Avoid static object construction/destruction on startup/shutdown.
437 if (!empty_gurl) {
438 // Create the string. Be careful that we don't break in the case that this
439 // is being called from multiple threads.
440 GURL* new_empty_gurl = new GURL;
441 if (InterlockedCompareExchangePointer(
442 reinterpret_cast<PVOID*>(&empty_gurl), new_empty_gurl, NULL)) {
443 // The old value was non-NULL, so no replacement was done. Another
444 // thread did the initialization out from under us.
445 delete new_empty_gurl;
448 return *empty_gurl;
451 #else
453 void EmptyGURLOnce(void) {
454 empty_gurl = new GURL;
457 const GURL& GURL::EmptyGURL() {
458 // Avoid static object construction/destruction on startup/shutdown.
459 pthread_once(&empty_gurl_once, EmptyGURLOnce);
460 return *empty_gurl;
463 #endif // WIN32
465 bool GURL::DomainIs(const char* lower_ascii_domain,
466 int domain_len) const {
467 // Return false if this URL is not valid or domain is empty.
468 if (!is_valid_ || !domain_len)
469 return false;
471 // FileSystem URLs have empty parsed_.host, so check this first.
472 if (SchemeIsFileSystem() && inner_url_)
473 return inner_url_->DomainIs(lower_ascii_domain, domain_len);
475 if (!parsed_.host.is_nonempty())
476 return false;
478 // Check whether the host name is end with a dot. If yes, treat it
479 // the same as no-dot unless the input comparison domain is end
480 // with dot.
481 const char* last_pos = spec_.data() + parsed_.host.end() - 1;
482 int host_len = parsed_.host.len;
483 if ('.' == *last_pos && '.' != lower_ascii_domain[domain_len - 1]) {
484 last_pos--;
485 host_len--;
488 // Return false if host's length is less than domain's length.
489 if (host_len < domain_len)
490 return false;
492 // Compare this url whether belong specific domain.
493 const char* start_pos = spec_.data() + parsed_.host.begin +
494 host_len - domain_len;
496 if (!url_util::LowerCaseEqualsASCII(start_pos,
497 last_pos + 1,
498 lower_ascii_domain,
499 lower_ascii_domain + domain_len))
500 return false;
502 // Check whether host has right domain start with dot, make sure we got
503 // right domain range. For example www.google.com has domain
504 // "google.com" but www.iamnotgoogle.com does not.
505 if ('.' != lower_ascii_domain[0] && host_len > domain_len &&
506 '.' != *(start_pos - 1))
507 return false;
509 return true;
512 void GURL::Swap(GURL* other) {
513 spec_.swap(other->spec_);
514 std::swap(is_valid_, other->is_valid_);
515 std::swap(parsed_, other->parsed_);
516 std::swap(inner_url_, other->inner_url_);
519 std::ostream& operator<<(std::ostream& out, const GURL& url) {
520 return out << url.possibly_invalid_spec();