Integrate most of GoogleURL in WTFURL
[WebKit-https.git] / Source / WTF / wtf / url / src / URLUtil.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
32 #ifndef URLUtil_h
33 #define URLUtil_h
34
35 #include "URLBuffer.h"
36 #include "URLCanon.h"
37 #include "URLParse.h"
38 #include <wtf/unicode/Unicode.h>
39
40 #if USE(WTFURL)
41
42 namespace WTF {
43
44 namespace URLUtilities {
45
46 // Locates the scheme in the given string and places it into |foundScheme|,
47 // which may be 0 to indicate the caller does not care about the range.
48 //
49 // Returns whether the given |compare| scheme matches the scheme found in the
50 // input (if any). The |compare| scheme must be a valid canonical scheme or
51 // the result of the comparison is undefined.
52 bool FindAndCompareScheme(const char* str, int strLength, const char* compare, URLComponent* foundScheme);
53 bool FindAndCompareScheme(const UChar* str, int strLength, const char* compare, URLComponent* foundScheme);
54
55 // Returns true if the given string represents a standard URL. This means that
56 // either the scheme is in the list of known standard schemes.
57 bool isStandard(const char* spec, const URLComponent& scheme);
58 bool isStandard(const UChar* spec, const URLComponent& scheme);
59
60 // URL library wrappers -------------------------------------------------------
61
62 // Parses the given spec according to the extracted scheme type. Normal users
63 // should use the URL object, although this may be useful if performance is
64 // critical and you don't want to do the heap allocation for the std::string.
65 //
66 // As with the URLCanonicalizer::Canonicalize* functions, the charset converter can
67 // be 0 to use UTF-8 (it will be faster in this case).
68 //
69 // Returns true if a valid URL was produced, false if not. On failure, the
70 // output and parsed structures will still be filled and will be consistent,
71 // but they will not represent a loadable URL.
72 bool canonicalize(const char* spec, int specLength, URLCanonicalizer::CharsetConverter*,
73                   URLBuffer<char>&, URLSegments& ouputParsed);
74 bool canonicalize(const UChar* spec, int specLength, URLCanonicalizer::CharsetConverter*,
75                   URLBuffer<char>&, URLSegments& ouputParsed);
76
77 // Resolves a potentially relative URL relative to the given parsed base URL.
78 // The base MUST be valid. The resulting canonical URL and parsed information
79 // will be placed in to the given out variables.
80 //
81 // The relative need not be relative. If we discover that it's absolute, this
82 // will produce a canonical version of that URL. See Canonicalize() for more
83 // about the charsetConverter.
84 //
85 // Returns true if the output is valid, false if the input could not produce
86 // a valid URL.
87 bool resolveRelative(const char* baseSpec, const URLSegments& baseParsed,
88                      const char* relative, int relativeLength,
89                      URLCanonicalizer::CharsetConverter*,
90                      URLBuffer<char>&, URLSegments* ouputParsed);
91 bool resolveRelative(const char* baseSpec, const URLSegments& baseParsed,
92                      const UChar* relative, int relativeLength,
93                      URLCanonicalizer::CharsetConverter*,
94                      URLBuffer<char>&, URLSegments* ouputParsed);
95
96 // Replaces components in the given VALID input url. The new canonical URL info
97 // is written to output and outputParsed.
98 //
99 // Returns true if the resulting URL is valid.
100 bool ReplaceComponents(const char* spec, int specLength, const URLSegments& parsed,
101                        const URLCanonicalizer::Replacements<char>&,
102                        URLCanonicalizer::CharsetConverter*,
103                        URLBuffer<char>&, URLSegments* outputParsed);
104 bool ReplaceComponents(const char* spec, int specLength, const URLSegments& parsed,
105                        const URLCanonicalizer::Replacements<UChar>&,
106                        URLCanonicalizer::CharsetConverter*,
107                        URLBuffer<char>&, URLSegments* outputParsed);
108
109 // String helper functions ----------------------------------------------------
110
111 // Compare the lower-case form of the given string against the given ASCII
112 // string. This is useful for doing checking if an input string matches some
113 // token, and it is optimized to avoid intermediate string copies.
114 //
115 // The versions of this function that don't take a bEnd assume that the b
116 // string is zero terminated.
117 bool LowerCaseEqualsASCII(const char* aBegin, const char* aEnd, const char* b);
118 bool LowerCaseEqualsASCII(const char* aBegin, const char* aEnd, const char* bBegin, const char* bEnd);
119 bool LowerCaseEqualsASCII(const UChar* aBegin, const UChar* aEnd, const char* b);
120
121 // Unescapes the given string using URL escaping rules.
122 void DecodeURLEscapeSequences(const char* input, int length, URLBuffer<UChar>&);
123
124 // Escapes the given string as defined by the JS method encodeURIComponent.
125 // See https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/encodeURIComponent
126 void EncodeURIComponent(const char* input, int length, URLBuffer<char>&);
127
128
129 } // namespace URLUtilities
130
131 } // namespace WTF
132
133 #endif // USE(WTFURL)
134
135 #endif // URLUtil_h