Integrate most of GoogleURL in WTFURL
[WebKit-https.git] / Source / WTF / wtf / url / src / URLCanon.h
1 /*
2  * Copyright 2007 Google Inc. All rights reserved.
3  * Copyright 2012 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31 #ifndef URLCanon_h
32 #define URLCanon_h
33
34 #include "URLBuffer.h"
35 #include "URLParse.h"
36 #include <stdlib.h>
37 #include <wtf/unicode/Unicode.h>
38
39 #if USE(WTFURL)
40
41 namespace WTF {
42
43 namespace URLCanonicalizer {
44
45 // Character set converter ----------------------------------------------------
46 //
47 // Converts query strings into a custom encoding. The embedder can supply an
48 // implementation of this class to interface with their own character set
49 // conversion libraries.
50 //
51 // Embedders will want to see the unit test for the ICU version.
52
53 class CharsetConverter {
54 public:
55     CharsetConverter() { }
56     virtual ~CharsetConverter() { }
57
58     // Converts the given input string from UTF-16 to whatever output format the
59     // converter supports. This is used only for the query encoding conversion,
60     // which does not fail. Instead, the converter should insert "invalid
61     // character" characters in the output for invalid sequences, and do the
62     // best it can.
63     //
64     // If the input contains a character not representable in the output
65     // character set, the converter should append the HTML entity sequence in
66     // decimal, (such as "&#20320;") with escaping of the ampersand, number
67     // sign, and semicolon (in the previous example it would be
68     // "%26%2320320%3B"). This rule is based on what IE does in this situation.
69     virtual void ConvertFromUTF16(const UChar* input, int inputLength, URLBuffer<char>& output) = 0;
70 };
71
72 // Whitespace -----------------------------------------------------------------
73
74 // Searches for whitespace that should be removed from the middle of URLs, and
75 // removes it. Removed whitespace are tabs and newlines, but NOT spaces. Spaces
76 // are preserved, which is what most browsers do. A pointer to the output will
77 // be returned, and the length of that output will be in |outputLength|.
78 //
79 // This should be called before parsing if whitespace removal is desired (which
80 // it normally is when you are canonicalizing).
81 //
82 // If no whitespace is removed, this function will not use the buffer and will
83 // return a pointer to the input, to avoid the extra copy. If modification is
84 // required, the given |buffer| will be used and the returned pointer will
85 // point to the beginning of the buffer.
86 //
87 // Therefore, callers should not use the buffer, since it may actuall be empty,
88 // use the computed pointer and |outputLength| instead.
89 const char* removeURLWhitespace(const char* input, int inputLength, URLBuffer<char>&, int& outputLength);
90 const UChar* removeURLWhitespace(const UChar* input, int inputLength, URLBuffer<UChar>&, int& outputLength);
91
92 // IDN ------------------------------------------------------------------------
93
94 // Converts the Unicode input representing a hostname to ASCII using IDN rules.
95 // The output must fall in the ASCII range, but will be encoded in UTF-16.
96 //
97 // On success, the output will be filled with the ASCII host name and it will
98 // return true. Unlike most other canonicalization functions, this assumes that
99 // the output is empty. The beginning of the host will be at offset 0, and
100 // the length of the output will be set to the length of the new host name.
101 //
102 // On error, returns false. The output in this case is undefined.
103 bool IDNToASCII(const UChar* src, int sourceLength, URLBuffer<UChar>& output);
104
105 // Piece-by-piece canonicalizers ----------------------------------------------
106 //
107 // These individual canonicalizers append the canonicalized versions of the
108 // corresponding URL component to the given std::string. The spec and the
109 // previously-identified range of that component are the input. The range of
110 // the canonicalized component will be written to the output component.
111 //
112 // These functions all append to the output so they can be chained. Make sure
113 // the output is empty when you start.
114 //
115 // These functions returns boolean values indicating success. On failure, they
116 // will attempt to write something reasonable to the output so that, if
117 // displayed to the user, they will recognise it as something that's messed up.
118 // Nothing more should ever be done with these invalid URLs, however.
119
120 // Scheme: Appends the scheme and colon to the URL. The output component will
121 // indicate the range of characters up to but not including the colon.
122 //
123 // Canonical URLs always have a scheme. If the scheme is not present in the
124 // input, this will just write the colon to indicate an empty scheme. Does not
125 // append slashes which will be needed before any authority components for most
126 // URLs.
127 //
128 // The 8-bit version requires UTF-8 encoding.
129 bool canonicalizeScheme(const char* spec, const URLComponent& scheme, URLBuffer<char>&, URLComponent& ouputScheme);
130 bool canonicalizeScheme(const UChar* spec, const URLComponent& scheme, URLBuffer<char>&, URLComponent& ouputScheme);
131
132 // User info: username/password. If present, this will add the delimiters so
133 // the output will be "<username>:<password>@" or "<username>@". Empty
134 // username/password pairs, or empty passwords, will get converted to
135 // nonexistant in the canonical version.
136 //
137 // The components for the username and password refer to ranges in the
138 // respective source strings. Usually, these will be the same string, which
139 // is legal as long as the two components don't overlap.
140 //
141 // The 8-bit version requires UTF-8 encoding.
142 bool canonicalizeUserInfo(const char* usernameSource, const URLComponent& username, const char* passwordSource, const URLComponent& password,
143                           URLBuffer<char>&, URLComponent& outputUsername, URLComponent& outputPassword);
144 bool canonicalizeUserInfo(const UChar* usernameSource, const URLComponent& username, const UChar* passwordSource, const URLComponent& password,
145                           URLBuffer<char>&, URLComponent& outputUsername, URLComponent& outputPassword);
146
147
148 // This structure holds detailed state exported from the IP/Host canonicalizers.
149 // Additional fields may be added as callers require them.
150 struct CanonHostInfo {
151     CanonHostInfo()
152         : family(NEUTRAL)
153         , ipv4ComponentsCount(0)
154         , ouputHost()
155     {
156     }
157
158     // Convenience function to test if family is an IP address.
159     bool IsIPAddress() const { return family == IPV4 || family == IPV6; }
160
161     // This field summarizes how the input was classified by the canonicalizer.
162     enum Family {
163         // - Doesn't resemble an IP address. As far as the IP
164         // canonicalizer is concerned, it should be treated as a
165         //   hostname.
166         NEUTRAL,
167
168         // - Almost an IP, but was not canonicalized. This could be an
169         // IPv4 address where truncation occurred, or something
170         // containing the special characters :[] which did not parse
171         // as an IPv6 address. Never attempt to connect to this
172         // address, because it might actually succeed!
173         BROKEN,
174
175         IPV4, // - Successfully canonicalized as an IPv4 address.
176         IPV6, // - Successfully canonicalized as an IPv6 address.
177     };
178     Family family;
179
180     // If |family| is IPV4, then this is the number of nonempty dot-separated
181     // components in the input text, from 1 to 4. If |family| is not IPV4,
182     // this value is undefined.
183     int ipv4ComponentsCount;
184
185     // Location of host within the canonicalized output.
186     // canonicalizeIPAddress() only sets this field if |family| is IPV4 or IPV6.
187     URLComponent ouputHost;
188
189     // |address| contains the parsed IP Address (if any) in its first
190     // AddressLength() bytes, in network order. If IsIPAddress() is false
191     // AddressLength() will return zero and the content of |address| is undefined.
192     unsigned char address[16];
193
194     // Convenience function to calculate the length of an IP address corresponding
195     // to the current IP version in |family|, if any. For use with |address|.
196     int AddressLength() const
197     {
198         return family == IPV4 ? 4 : (family == IPV6 ? 16 : 0);
199     }
200 };
201
202 // Host.
203 //
204 // The 8-bit version requires UTF-8 encoding. Use this version when you only
205 // need to know whether canonicalization succeeded.
206 bool canonicalizeHost(const char* spec, const URLComponent& host, URLBuffer<char>&, URLComponent& ouputHost);
207 bool canonicalizeHost(const UChar* spec, const URLComponent& host, URLBuffer<char>&, URLComponent& ouputHost);
208
209 // IP addresses.
210 //
211 // Tries to interpret the given host name as an IPv4 or IPv6 address. If it is
212 // an IP address, it will canonicalize it as such, appending it to |output|.
213 // Additional status information is returned via the |*hostInfo| parameter.
214 // See the definition of CanonHostInfo above for details.
215 //
216 // This is called AUTOMATICALLY from the host canonicalizer, which ensures that
217 // the input is unescaped and name-prepped, etc. It should not normally be
218 // necessary or wise to call this directly.
219 void canonicalizeIPAddress(const char* spec, const URLComponent& host, URLBuffer<char>&, CanonHostInfo&);
220 void canonicalizeIPAddress(const UChar* spec, const URLComponent& host, URLBuffer<char>&, CanonHostInfo&);
221
222 // Port: this function will add the colon for the port if a port is present.
223 // The caller can pass URLParser::PORT_UNSPECIFIED as the
224 // defaultPortForScheme argument if there is no default port.
225 //
226 // The 8-bit version requires UTF-8 encoding.
227 bool canonicalizePort(const char* spec, const URLComponent& port, int defaultPortForScheme, URLBuffer<char>&, URLComponent& ouputPort);
228 bool canonicalizePort(const UChar* spec, const URLComponent& port, int defaultPortForScheme, URLBuffer<char>&, URLComponent& ouputPort);
229
230 // Returns the default port for the given canonical scheme, or PORT_UNSPECIFIED
231 // if the scheme is unknown.
232 int defaultPortForScheme(const char* scheme, int schemeLength);
233
234 // Path. If the input does not begin in a slash (including if the input is
235 // empty), we'll prepend a slash to the path to make it canonical.
236 //
237 // The 8-bit version assumes UTF-8 encoding, but does not verify the validity
238 // of the UTF-8 (i.e., you can have invalid UTF-8 sequences, invalid
239 // characters, etc.). Normally, URLs will come in as UTF-16, so this isn't
240 // an issue. Somebody giving us an 8-bit path is responsible for generating
241 // the path that the server expects (we'll escape high-bit characters), so
242 // if something is invalid, it's their problem.
243 bool CanonicalizePath(const char* spec, const URLComponent& path, URLBuffer<char>&, URLComponent* outputPath);
244 bool CanonicalizePath(const UChar* spec, const URLComponent& path, URLBuffer<char>&, URLComponent* outputPath);
245
246 // Canonicalizes the input as a file path. This is like CanonicalizePath except
247 // that it also handles Windows drive specs. For example, the path can begin
248 // with "c|\" and it will get properly canonicalized to "C:/".
249 // The string will be appended to |output| and |outputPath| will be updated.
250 //
251 // The 8-bit version requires UTF-8 encoding.
252 bool FileCanonicalizePath(const char* spec, const URLComponent& path, URLBuffer<char>&, URLComponent* outputPath);
253 bool FileCanonicalizePath(const UChar* spec, const URLComponent& path, URLBuffer<char>&, URLComponent* outputPath);
254
255 // Query: Prepends the ? if needed.
256 //
257 // The 8-bit version requires the input to be UTF-8 encoding. Incorrectly
258 // encoded characters (in UTF-8 or UTF-16) will be replaced with the Unicode
259 // "invalid character." This function can not fail, we always just try to do
260 // our best for crazy input here since web pages can set it themselves.
261 //
262 // This will convert the given input into the output encoding that the given
263 // character set converter object provides. The converter will only be called
264 // if necessary, for ASCII input, no conversions are necessary.
265 //
266 // The converter can be null. In this case, the output encoding will be UTF-8.
267 void CanonicalizeQuery(const char* spec, const URLComponent& query, CharsetConverter*, URLBuffer<char>&, URLComponent* outputQuery);
268 void CanonicalizeQuery(const UChar* spec, const URLComponent& query, CharsetConverter*, URLBuffer<char>&, URLComponent* outputQuery);
269
270 // Ref: Prepends the # if needed. The output will be UTF-8 (this is the only
271 // canonicalizer that does not produce ASCII output). The output is
272 // guaranteed to be valid UTF-8.
273 //
274 // This function will not fail. If the input is invalid UTF-8/UTF-16, we'll use
275 // the "Unicode replacement character" for the confusing bits and copy the rest.
276 void canonicalizeFragment(const char* spec, const URLComponent& path, URLBuffer<char>&, URLComponent& outputFragment);
277 void canonicalizeFragment(const UChar* spec, const URLComponent& path, URLBuffer<char>&, URLComponent& outputFragment);
278
279 // Full canonicalizer ---------------------------------------------------------
280 //
281 // These functions replace any string contents, rather than append as above.
282 // See the above piece-by-piece functions for information specific to
283 // canonicalizing individual components.
284 //
285 // The output will be ASCII except the reference fragment, which may be UTF-8.
286 //
287 // The 8-bit versions require UTF-8 encoding.
288
289 // Use for standard URLs with authorities and paths.
290 bool CanonicalizeStandardURL(const char* spec, int specLength, const URLSegments& parsed, CharsetConverter* queryConverter,
291                              URLBuffer<char>&, URLSegments* outputParsed);
292 bool CanonicalizeStandardURL(const UChar* spec, int specLength, const URLSegments& parsed, CharsetConverter* queryConverter,
293                              URLBuffer<char>&, URLSegments* outputParsed);
294
295 // Use for file URLs.
296 bool CanonicalizeFileURL(const char* spec, int specLength, const URLSegments& parsed, CharsetConverter* queryConverter,
297                          URLBuffer<char>&, URLSegments* outputParsed);
298 bool CanonicalizeFileURL(const UChar* spec, int specLength, const URLSegments& parsed, CharsetConverter* queryConverter,
299                          URLBuffer<char>&, URLSegments* outputParsed);
300
301 // Use for filesystem URLs.
302 bool canonicalizeFileSystemURL(const char* spec, const URLSegments& parsed, CharsetConverter* queryConverter,
303                                URLBuffer<char>&, URLSegments& outputParsed);
304 bool canonicalizeFileSystemURL(const UChar* spec, const URLSegments& parsed, CharsetConverter* queryConverter,
305                                URLBuffer<char>&, URLSegments& outputParsed);
306
307 // Use for path URLs such as javascript. This does not modify the path in any
308 // way, for example, by escaping it.
309 bool canonicalizePathURL(const char* spec, const URLSegments& parsed, URLBuffer<char>& output, URLSegments& ouputParsed);
310 bool canonicalizePathURL(const UChar* spec, const URLSegments& parsed, URLBuffer<char>& output, URLSegments& ouputParsed);
311
312 // Use for mailto URLs. This "canonicalizes" the url into a path and query
313 // component. It does not attempt to merge "to" fields. It uses UTF-8 for
314 // the query encoding if there is a query. This is because a mailto URL is
315 // really intended for an external mail program, and the encoding of a page,
316 // etc. which would influence a query encoding normally are irrelevant.
317 bool canonicalizeMailtoURL(const char* spec, const URLSegments& parsed, URLBuffer<char>&, URLSegments& outputParsed);
318 bool canonicalizeMailtoURL(const UChar* spec,  const URLSegments& parsed, URLBuffer<char>&, URLSegments& outputParsed);
319
320 // Part replacer --------------------------------------------------------------
321
322 // Internal structure used for storing separate strings for each component.
323 // The basic canonicalization functions use this structure internally so that
324 // component replacement (different strings for different components) can be
325 // treated on the same code path as regular canonicalization (the same string
326 // for each component).
327 //
328 // A URLSegments structure usually goes along with this. Those
329 // components identify offsets within these strings, so that they can all be
330 // in the same string, or spread arbitrarily across different ones.
331 //
332 // This structures does not own any data. It is the caller's responsibility to
333 // ensure that the data the pointers point to stays in scope and is not
334 // modified.
335 template<typename CharacterType>
336 struct URLComponentSource {
337     // Constructor normally used by callers wishing to replace components. This
338     // will make them all null, which is no replacement. The caller would then
339     // override the components they want to replace.
340     URLComponentSource()
341         : scheme(0)
342         , username(0)
343         , password(0)
344         , host(0)
345         , port(0)
346         , path(0)
347         , query(0)
348         , ref(0)
349     {
350     }
351
352     // Constructor normally used internally to initialize all the components to
353     // point to the same spec.
354     explicit URLComponentSource(const CharacterType* defaultValue)
355         : scheme(defaultValue)
356         , username(defaultValue)
357         , password(defaultValue)
358         , host(defaultValue)
359         , port(defaultValue)
360         , path(defaultValue)
361         , query(defaultValue)
362         , ref(defaultValue)
363     {
364     }
365
366     const CharacterType* scheme;
367     const CharacterType* username;
368     const CharacterType* password;
369     const CharacterType* host;
370     const CharacterType* port;
371     const CharacterType* path;
372     const CharacterType* query;
373     const CharacterType* ref;
374 };
375
376 // This structure encapsulates information on modifying a URL. Each component
377 // may either be left unchanged, replaced, or deleted.
378 //
379 // By default, each component is unchanged. For those components that should be
380 // modified, call either Set* or Clear* to modify it.
381 //
382 // The string passed to Set* functions DOES NOT GET COPIED AND MUST BE KEPT
383 // IN SCOPE BY THE CALLER for as long as this object exists!
384 //
385 // Prefer the 8-bit replacement version if possible since it is more efficient.
386 template<typename CharacterType>
387 class Replacements {
388 public:
389     Replacements()
390     {
391     }
392
393     // Scheme
394     void SetScheme(const CharacterType* s, const URLComponent& comp)
395     {
396         m_sources.scheme = s;
397         m_segments.scheme = comp;
398     }
399     // Note: we don't have a ClearScheme since this doesn't make any sense.
400     bool IsSchemeOverridden() const { return !!m_sources.scheme; }
401
402     // Username
403     void SetUsername(const CharacterType* s, const URLComponent& comp)
404     {
405         m_sources.username = s;
406         m_segments.username = comp;
407     }
408     void ClearUsername()
409     {
410         m_sources.username = Placeholder();
411         m_segments.username = URLComponent();
412     }
413     bool IsUsernameOverridden() const { return !!m_sources.username; }
414
415     // Password
416     void SetPassword(const CharacterType* s, const URLComponent& comp)
417     {
418         m_sources.password = s;
419         m_segments.password = comp;
420     }
421     void ClearPassword()
422     {
423         m_sources.password = Placeholder();
424         m_segments.password = URLComponent();
425     }
426     bool IsPasswordOverridden() const { return !!m_sources.password; }
427
428     // Host
429     void SetHost(const CharacterType* s, const URLComponent& comp)
430     {
431         m_sources.host = s;
432         m_segments.host = comp;
433     }
434     void ClearHost()
435     {
436         m_sources.host = Placeholder();
437         m_segments.host = URLComponent();
438     }
439     bool IsHostOverridden() const { return !!m_sources.host; }
440
441     // Port
442     void SetPort(const CharacterType* s, const URLComponent& comp)
443     {
444         m_sources.port = s;
445         m_segments.port = comp;
446     }
447     void ClearPort()
448     {
449         m_sources.port = Placeholder();
450         m_segments.port = URLComponent();
451     }
452     bool IsPortOverridden() const { return !!m_sources.port; }
453
454     // Path
455     void SetPath(const CharacterType* s, const URLComponent& comp)
456     {
457         m_sources.path = s;
458         m_segments.path = comp;
459     }
460     void ClearPath()
461     {
462         m_sources.path = Placeholder();
463         m_segments.path = URLComponent();
464     }
465     bool IsPathOverridden() const { return !m_sources.path; }
466
467     // Query
468     void SetQuery(const CharacterType* s, const URLComponent& comp)
469     {
470         m_sources.query = s;
471         m_segments.query = comp;
472     }
473     void ClearQuery()
474     {
475         m_sources.query = Placeholder();
476         m_segments.query = URLComponent();
477     }
478     bool IsQueryOverridden() const { return !m_sources.query; }
479
480     // Ref
481     void SetRef(const CharacterType* s, const URLComponent& comp)
482     {
483         m_sources.ref = s;
484         m_segments.fragment = comp;
485     }
486     void ClearRef()
487     {
488         m_sources.ref = Placeholder();
489         m_segments.fragment = URLComponent();
490     }
491     bool IsRefOverridden() const { return !m_sources.ref; }
492
493     // Getters for the itnernal data. See the variables below for how the
494     // information is encoded.
495     const URLComponentSource<CharacterType>& sources() const { return m_sources; }
496     const URLSegments& components() const { return m_segments; }
497
498 private:
499     // Returns a pointer to a static empty string that is used as a placeholder
500     // to indicate a component should be deleted (see below).
501     const CharacterType* Placeholder()
502     {
503         static const CharacterType emptyString = 0;
504         return &emptyString;
505     }
506
507     // We support three states:
508     //
509     // Action                 | Source                Component
510     // -----------------------+--------------------------------------------------
511     // Don't change component | null                  (unused)
512     // Replace component      | (replacement string)  (replacement component)
513     // Delete component       | (non-null)            (invalid component: (0,-1))
514     //
515     // We use a pointer to the empty string for the source when the component
516     // should be deleted.
517     URLComponentSource<CharacterType> m_sources;
518     URLSegments m_segments;
519 };
520
521 // The base must be an 8-bit canonical URL.
522 bool ReplaceStandardURL(const char* base,
523                         const URLSegments& baseParsed,
524                         const Replacements<char>&,
525                         CharsetConverter* queryConverter,
526                         URLBuffer<char>&,
527                         URLSegments* outputParsed);
528 bool ReplaceStandardURL(const char* base,
529                         const URLSegments& baseParsed,
530                         const Replacements<UChar>&,
531                         CharsetConverter* queryConverter,
532                         URLBuffer<char>&,
533                         URLSegments* outputParsed);
534
535 // Filesystem URLs can only have the path, query, or ref replaced.
536 // All other components will be ignored.
537 bool ReplaceFileSystemURL(const char* base,
538                           const URLSegments& baseParsed,
539                           const Replacements<char>&,
540                           CharsetConverter* queryConverter,
541                           URLBuffer<char>&,
542                           URLSegments* outputParsed);
543 bool ReplaceFileSystemURL(const char* base,
544                           const URLSegments& baseParsed,
545                           const Replacements<UChar>&,
546                           CharsetConverter* queryConverter,
547                           URLBuffer<char>&,
548                           URLSegments* outputParsed);
549
550 // Replacing some parts of a file URL is not permitted. Everything except
551 // the host, path, query, and ref will be ignored.
552 bool ReplaceFileURL(const char* base,
553                     const URLSegments& baseParsed,
554                     const Replacements<char>&,
555                     CharsetConverter* queryConverter,
556                     URLBuffer<char>&,
557                     URLSegments* outputParsed);
558 bool ReplaceFileURL(const char* base,
559                     const URLSegments& baseParsed,
560                     const Replacements<UChar>&,
561                     CharsetConverter* queryConverter,
562                     URLBuffer<char>&,
563                     URLSegments* outputParsed);
564
565 // Path URLs can only have the scheme and path replaced. All other components
566 // will be ignored.
567 bool ReplacePathURL(const char* base,
568                     const URLSegments& baseParsed,
569                     const Replacements<char>&,
570                     URLBuffer<char>&,
571                     URLSegments* outputParsed);
572 bool ReplacePathURL(const char* base,
573                     const URLSegments& baseParsed,
574                     const Replacements<UChar>&,
575                     URLBuffer<char>&,
576                     URLSegments* outputParsed);
577
578 // Mailto URLs can only have the scheme, path, and query replaced.
579 // All other components will be ignored.
580 bool replaceMailtoURL(const char* base, const URLSegments& baseParsed,
581                       const Replacements<char>&,
582                       URLBuffer<char>& output, URLSegments& outputParsed);
583 bool replaceMailtoURL(const char* base, const URLSegments& baseParsed,
584                       const Replacements<UChar>&,
585                       URLBuffer<char>& output, URLSegments& outputParsed);
586
587 // Relative URL ---------------------------------------------------------------
588
589 // Given an input URL or URL fragment |fragment|, determines if it is a
590 // relative or absolute URL and places the result into |*isRelative|. If it is
591 // relative, the relevant portion of the URL will be placed into
592 // |*relativeComponent| (there may have been trimmed whitespace, for example).
593 // This value is passed to resolveRelativeURL. If the input is not relative,
594 // this value is UNDEFINED (it may be changed by the function).
595 //
596 // Returns true on success (we successfully determined the URL is relative or
597 // not). Failure means that the combination of URLs doesn't make any sense.
598 //
599 // The base URL should always be canonical, therefore is ASCII.
600 bool isRelativeURL(const char* base, const URLSegments& baseParsed,
601                    const char* fragment, int fragmentLength,
602                    bool isBaseHierarchical,
603                    bool& isRelative, URLComponent& relativeComponent);
604 bool isRelativeURL(const char* base, const URLSegments& baseParsed,
605                    const UChar* fragment, int fragmentLength,
606                    bool isBaseHierarchical,
607                    bool& isRelative, URLComponent& relativeComponent);
608
609 // Given a canonical parsed source URL, a URL fragment known to be relative,
610 // and the identified relevant portion of the relative URL (computed by
611 // isRelativeURL), this produces a new parsed canonical URL in |output| and
612 // |outputParsed|.
613 //
614 // It also requires a flag indicating whether the base URL is a file: URL
615 // which triggers additional logic.
616 //
617 // The base URL should be canonical and have a host (may be empty for file
618 // URLs) and a path. If it doesn't have these, we can't resolve relative
619 // URLs off of it and will return the base as the output with an error flag.
620 // Becausee it is canonical is should also be ASCII.
621 //
622 // The query charset converter follows the same rules as CanonicalizeQuery.
623 //
624 // Returns true on success. On failure, the output will be "something
625 // reasonable" that will be consistent and valid, just probably not what
626 // was intended by the web page author or caller.
627 bool resolveRelativeURL(const char* baseURL, const URLSegments& baseParsed, bool baseIsFile,
628                         const char* relativeURL, const URLComponent& relativeComponent,
629                         CharsetConverter* queryConverter,
630                         URLBuffer<char>&, URLSegments* outputParsed);
631 bool resolveRelativeURL(const char* baseURL, const URLSegments& baseParsed, bool baseIsFile,
632                         const UChar* relativeURL, const URLComponent& relativeComponent,
633                         CharsetConverter* queryConverter,
634                         URLBuffer<char>&, URLSegments* outputParsed);
635
636 } // namespace URLCanonicalizer
637
638 } // namespace WTF
639
640 #endif // USE(WTFURL)
641
642 #endif // URLCanon_h