2009-12-02 Fumitoshi Ukai <ukai@chromium.org>
[WebKit-https.git] / WebCore / platform / KURLGoogle.cpp
1 /*
2  * Copyright (C) 2004, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2008, 2009 Google 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 #include "config.h"
33
34 #if USE(GOOGLEURL)
35 #include "KURL.h"
36
37 #ifndef NDEBUG
38 #include <stdio.h>
39 #endif
40
41 #include "CString.h"
42 #include "NotImplemented.h"
43 #include "TextEncoding.h"
44 #include <wtf/Vector.h>
45
46 #include <googleurl/src/url_canon_internal.h>
47 #include <googleurl/src/url_util.h>
48
49 using WTF::isASCIILower;
50 using WTF::toASCIILower;
51
52 namespace WebCore {
53
54 // Wraps WebCore's text encoding in a character set converter for the
55 // canonicalizer.
56 class KURLCharsetConverter : public url_canon::CharsetConverter {
57 public:
58     // The encoding parameter may be NULL, but in this case the object must not
59     // be called.
60     KURLCharsetConverter(const TextEncoding* encoding)
61         : m_encoding(encoding)
62     {
63     }
64
65     virtual void ConvertFromUTF16(const url_parse::UTF16Char* input, int inputLength,
66                                   url_canon::CanonOutput* output)
67     {
68         CString encoded = m_encoding->encode(input, inputLength, URLEncodedEntitiesForUnencodables);
69         output->Append(encoded.data(), static_cast<int>(encoded.length()));
70     }
71
72 private:
73     const TextEncoding* m_encoding;
74 };
75
76 // Note that this function must be named differently than the one in KURL.cpp
77 // since our unit tests evilly include both files, and their local definition
78 // will be ambiguous.
79 static inline void assertProtocolIsGood(const char* protocol)
80 {
81 #ifndef NDEBUG
82     const char* p = protocol;
83     while (*p) {
84         ASSERT(*p > ' ' && *p < 0x7F && !(*p >= 'A' && *p <= 'Z'));
85         ++p;
86     }
87 #endif
88 }
89
90 // Returns the characters for the given string, or a pointer to a static empty
91 // string if the input string is NULL. This will always ensure we have a non-
92 // NULL character pointer since ReplaceComponents has special meaning for NULL.
93 static inline const url_parse::UTF16Char* CharactersOrEmpty(const String& str)
94 {
95     static const url_parse::UTF16Char zero = 0;
96     return str.characters() ?
97            reinterpret_cast<const url_parse::UTF16Char*>(str.characters()) :
98            &zero;
99 }
100
101 static inline bool isUnicodeEncoding(const TextEncoding* encoding)
102 {
103     return encoding->encodingForFormSubmission() == UTF8Encoding();
104 }
105
106 static bool lowerCaseEqualsASCII(const char* begin, const char* end, const char* str)
107 {
108     while (begin != end && *str) {
109         ASSERT(toASCIILower(*str) == *str);
110         if (toASCIILower(*begin++) != *str++)
111             return false;
112     }
113
114     // Both strings are equal (ignoring case) if and only if all of the characters were equal,
115     // and the end of both has been reached.
116     return begin == end && !*str;
117 }
118
119 static inline bool isSchemeFirstChar(char c)
120 {
121     return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
122 }
123
124 static inline bool isSchemeChar(char c)
125 {
126     return isSchemeFirstChar(c) || (c >= '0' && c <= '9') || c == '.' || c == '-' || c == '*';
127 }
128
129
130 // KURLGooglePrivate -----------------------------------------------------------
131
132 KURLGooglePrivate::KURLGooglePrivate()
133     : m_isValid(false)
134     , m_protocolInHTTPFamily(false)
135     , m_utf8IsASCII(true)
136     , m_stringIsValid(false)
137 {
138 }
139
140 KURLGooglePrivate::KURLGooglePrivate(const url_parse::Parsed& parsed, bool isValid)
141     : m_isValid(isValid)
142     , m_protocolInHTTPFamily(false)
143     , m_parsed(parsed)
144     , m_utf8IsASCII(true)
145     , m_stringIsValid(false)
146 {
147 }
148
149 // Setters for the data. Using the ASCII version when you know the
150 // data is ASCII will be slightly more efficient. The UTF-8 version
151 // will always be correct if the caller is unsure.
152 void KURLGooglePrivate::setUtf8(const CString& str)
153 {
154     const char* data = str.data();
155     unsigned dataLength = str.length();
156
157     // The m_utf8IsASCII must always be correct since the DeprecatedString
158     // getter must create it with the proper constructor. This test can be
159     // removed when DeprecatedString is gone, but it still might be a
160     // performance win.
161     m_utf8IsASCII = true;
162     for (unsigned i = 0; i < dataLength; i++) {
163         if (static_cast<unsigned char>(data[i]) >= 0x80) {
164             m_utf8IsASCII = false;
165             break;
166         }
167     }
168
169     m_utf8 = str;
170     m_stringIsValid = false;
171     initProtocolInHTTPFamily();
172 }
173
174 void KURLGooglePrivate::setAscii(const CString& str)
175 {
176     m_utf8 = str;
177     m_utf8IsASCII = true;
178     m_stringIsValid = false;
179     initProtocolInHTTPFamily();
180 }
181
182 void KURLGooglePrivate::init(const KURL& base,
183                              const String& relative,
184                              const TextEncoding* queryEncoding)
185 {
186     init(base, relative.characters(), relative.length(), queryEncoding);
187 }
188
189 // Note: code mostly duplicated below.
190 void KURLGooglePrivate::init(const KURL& base, const char* rel, int relLength,
191                              const TextEncoding* queryEncoding)
192 {
193     // As a performance optimization, we do not use the charset converter if
194     // encoding is UTF-8 or other Unicode encodings. Note that this is
195     // per HTML5 2.5.3 (resolving URL). The URL canonicalizer will be
196     // more efficient with no charset converter object because it
197     // can do UTF-8 internally with no extra copies.
198
199     // We feel free to make the charset converter object every time since it's
200     // just a wrapper around a reference.
201     KURLCharsetConverter charsetConverterObject(queryEncoding);
202     KURLCharsetConverter* charsetConverter =
203         (!queryEncoding || isUnicodeEncoding(queryEncoding)) ? 0 :
204         &charsetConverterObject;
205
206     url_canon::RawCanonOutputT<char> output;
207     const CString& baseStr = base.m_url.utf8String();
208     m_isValid = url_util::ResolveRelative(baseStr.data(), baseStr.length(),
209                                           base.m_url.m_parsed, rel, relLength,
210                                           charsetConverter,
211                                           &output, &m_parsed);
212
213     // See FIXME in KURLGooglePrivate in the header. If canonicalization has not
214     // changed the string, we can avoid an extra allocation by using assignment.
215     //
216     // When KURL encounters an error such that the URL is invalid and empty
217     // (for example, resolving a relative URL on a non-hierarchical base), it
218     // will produce an isNull URL, and calling setUtf8 will produce an empty
219     // non-null URL. This is unlikely to affect anything, but we preserve this
220     // just in case.
221     if (m_isValid || output.length()) {
222         // Without ref, the whole url is guaranteed to be ASCII-only.
223         if (m_parsed.ref.is_nonempty())
224             setUtf8(CString(output.data(), output.length()));
225         else
226             setAscii(CString(output.data(), output.length()));
227     } else {
228         // WebCore expects resolved URLs to be empty rather than NULL.
229         setUtf8(CString("", 0));
230     }
231 }
232
233 // Note: code mostly duplicated above. See FIXMEs and comments there.
234 void KURLGooglePrivate::init(const KURL& base, const UChar* rel, int relLength,
235                              const TextEncoding* queryEncoding)
236 {
237     KURLCharsetConverter charsetConverterObject(queryEncoding);
238     KURLCharsetConverter* charsetConverter =
239         (!queryEncoding || isUnicodeEncoding(queryEncoding)) ? 0 :
240         &charsetConverterObject;
241
242     url_canon::RawCanonOutputT<char> output;
243     const CString& baseStr = base.m_url.utf8String();
244     m_isValid = url_util::ResolveRelative(baseStr.data(), baseStr.length(),
245                                           base.m_url.m_parsed, rel, relLength,
246                                           charsetConverter,
247                                           &output, &m_parsed);
248
249
250     if (m_isValid || output.length()) {
251         if (m_parsed.ref.is_nonempty())
252             setUtf8(CString(output.data(), output.length()));
253         else
254             setAscii(CString(output.data(), output.length()));
255     } else
256         setUtf8(CString("", 0));
257 }
258
259 void KURLGooglePrivate::initProtocolInHTTPFamily()
260 {
261     if (!m_isValid) {
262         m_protocolInHTTPFamily = false;
263         return;
264     }
265
266     const char* scheme = m_utf8.data() + m_parsed.scheme.begin;
267     if (m_parsed.scheme.len == 4)
268         m_protocolInHTTPFamily = lowerCaseEqualsASCII(scheme, scheme + 4, "http");
269     else if (m_parsed.scheme.len == 5)
270         m_protocolInHTTPFamily = lowerCaseEqualsASCII(scheme, scheme + 5, "https");
271     else
272         m_protocolInHTTPFamily = false;
273 }
274
275 void KURLGooglePrivate::copyTo(KURLGooglePrivate* dest) const
276 {
277     dest->m_isValid = m_isValid;
278     dest->m_protocolInHTTPFamily = m_protocolInHTTPFamily;
279     dest->m_parsed = m_parsed;
280
281     // Don't copy the 16-bit string since that will be regenerated as needed.
282     dest->m_utf8 = CString(m_utf8.data(), m_utf8.length());
283     dest->m_utf8IsASCII = m_utf8IsASCII;
284     dest->m_stringIsValid = false;
285 }
286
287 String KURLGooglePrivate::componentString(const url_parse::Component& comp) const
288 {
289     if (!m_isValid || comp.len <= 0) {
290         // KURL returns a NULL string if the URL is itself a NULL string, and an
291         // empty string for other nonexistant entities.
292         if (utf8String().isNull())
293             return String();
294         return String("", 0);
295     }
296     // begin and len are in terms of bytes which do not match
297     // if string() is UTF-16 and input contains non-ASCII characters.
298     // However, the only part in urlString that can contain non-ASCII
299     // characters is 'ref' at the end of the string. In that case,
300     // begin will always match the actual value and len (in terms of
301     // byte) will be longer than what's needed by 'mid'. However, mid
302     // truncates len to avoid go past the end of a string so that we can
303     // get away withtout doing anything here.
304     return string().substring(comp.begin, comp.len);
305 }
306
307 void KURLGooglePrivate::replaceComponents(const Replacements& replacements)
308 {
309     url_canon::RawCanonOutputT<char> output;
310     url_parse::Parsed newParsed;
311
312     m_isValid = url_util::ReplaceComponents(utf8String().data(),
313                                             utf8String().length(), m_parsed, replacements, 0, &output, &newParsed);
314
315     m_parsed = newParsed;
316     if (m_parsed.ref.is_nonempty())
317         setUtf8(CString(output.data(), output.length()));
318     else
319         setAscii(CString(output.data(), output.length()));
320 }
321
322 const String& KURLGooglePrivate::string() const
323 {
324     if (!m_stringIsValid) {
325         // Must special case the NULL case, since constructing the
326         // string like we do below will generate an empty rather than
327         // a NULL string.
328         if (m_utf8.isNull())
329             m_string = String();
330         else if (m_utf8IsASCII)
331             m_string = String(m_utf8.data(), m_utf8.length());
332         else
333             m_string = String::fromUTF8(m_utf8.data(), m_utf8.length());
334         m_stringIsValid = true;
335     }
336     return m_string;
337 }
338
339 // KURL ------------------------------------------------------------------------
340
341 // Creates with NULL-terminated string input representing an absolute URL.
342 // WebCore generally calls this only with hardcoded strings, so the input is
343 // ASCII. We treat is as UTF-8 just in case.
344 KURL::KURL(ParsedURLStringTag, const char *url)
345 {
346     // FIXME The Mac code checks for beginning with a slash and converting to a
347     // file: URL. We will want to add this as well once we can compile on a
348     // system like that.
349     m_url.init(KURL(), url, strlen(url), 0);
350
351     // The one-argument constructors should never generate a NULL string.
352     // This is a funny quirk of KURL.cpp (probably a bug) which we preserve.
353     if (m_url.utf8String().isNull())
354         m_url.setAscii(CString("", 0));
355 }
356
357 // Initializes with a string representing an absolute URL. No encoding
358 // information is specified. This generally happens when a KURL is converted
359 // to a string and then converted back. In this case, the URL is already
360 // canonical and in proper escaped form so needs no encoding. We treat it was
361 // UTF-8 just in case.
362 KURL::KURL(ParsedURLStringTag, const String& url)
363 {
364     if (!url.isNull())
365         m_url.init(KURL(), url, 0);
366     else {
367         // WebCore expects us to preserve the nullness of strings when this
368         // constructor is used. In all other cases, it expects a non-null
369         // empty string, which is what init() will create.
370         m_url.m_isValid = false;
371         m_url.m_protocolInHTTPFamily = false;
372     }
373 }
374
375 // Constructs a new URL given a base URL and a possibly relative input URL.
376 // This assumes UTF-8 encoding.
377 KURL::KURL(const KURL& base, const String& relative)
378 {
379     m_url.init(base, relative, 0);
380 }
381
382 // Constructs a new URL given a base URL and a possibly relative input URL.
383 // Any query portion of the relative URL will be encoded in the given encoding.
384 KURL::KURL(const KURL& base,
385            const String& relative,
386            const TextEncoding& encoding)
387 {
388     m_url.init(base, relative, &encoding.encodingForFormSubmission());
389 }
390
391 KURL::KURL(const CString& canonicalSpec,
392            const url_parse::Parsed& parsed, bool isValid)
393     : m_url(parsed, isValid)
394 {
395     // We know the reference fragment is the only part that can be UTF-8, so
396     // we know it's ASCII when there is no ref.
397     if (parsed.ref.is_nonempty())
398         m_url.setUtf8(canonicalSpec);
399     else
400         m_url.setAscii(canonicalSpec);
401 }
402
403 #if PLATFORM(CF)
404 KURL::KURL(CFURLRef)
405 {
406     notImplemented();
407     invalidate();
408 }
409
410 CFURLRef KURL::createCFURL() const
411 {
412     notImplemented();
413     return 0;
414 }
415 #endif
416
417 KURL KURL::copy() const
418 {
419     KURL result = *this;
420     m_url.copyTo(&result.m_url);
421     return result;
422 }
423
424 bool KURL::isNull() const
425 {
426     return m_url.utf8String().isNull();
427 }
428
429 bool KURL::isEmpty() const
430 {
431     return !m_url.utf8String().length();
432 }
433
434 bool KURL::isValid() const
435 {
436     return m_url.m_isValid;
437 }
438
439 bool KURL::hasPort() const
440 {
441     return hostEnd() < pathStart();
442 }
443
444 bool KURL::protocolInHTTPFamily() const
445 {
446     return m_url.m_protocolInHTTPFamily;
447 }
448
449 bool KURL::hasPath() const
450 {
451     // Note that http://www.google.com/" has a path, the path is "/". This can
452     // return false only for invalid or nonstandard URLs.
453     return m_url.m_parsed.path.len >= 0;
454 }
455
456 // We handle "parameters" separated by a semicolon, while KURL.cpp does not,
457 // which can lead to different results in some cases.
458 String KURL::lastPathComponent() const
459 {
460     // When the output ends in a slash, WebCore has different expectations than
461     // the GoogleURL library. For "/foo/bar/" the library will return the empty
462     // string, but WebCore wants "bar".
463     url_parse::Component path = m_url.m_parsed.path;
464     if (path.len > 0 && m_url.utf8String().data()[path.end() - 1] == '/')
465         path.len--;
466
467     url_parse::Component file;
468     url_parse::ExtractFileName(m_url.utf8String().data(), path, &file);
469
470     // Bug: https://bugs.webkit.org/show_bug.cgi?id=21015 this function returns
471     // a null string when the path is empty, which we duplicate here.
472     if (!file.is_nonempty())
473         return String();
474     return m_url.componentString(file);
475 }
476
477 String KURL::protocol() const
478 {
479     return m_url.componentString(m_url.m_parsed.scheme);
480 }
481
482 String KURL::host() const
483 {
484     // Note: KURL.cpp unescapes here.
485     return m_url.componentString(m_url.m_parsed.host);
486 }
487
488 // Returns 0 when there is no port or it is invalid.
489 //
490 // We treat URL's with out-of-range port numbers as invalid URLs, and they will
491 // be rejected by the canonicalizer. KURL.cpp will allow them in parsing, but
492 // return 0 from this port() function, so we mirror that behavior here.
493 unsigned short KURL::port() const
494 {
495     if (!m_url.m_isValid || m_url.m_parsed.port.len <= 0)
496         return 0;
497     int port = url_parse::ParsePort(m_url.utf8String().data(), m_url.m_parsed.port);
498     if (port == url_parse::PORT_UNSPECIFIED)
499         return 0;
500     return static_cast<unsigned short>(port);
501 }
502
503 // Returns the empty string if there is no password.
504 String KURL::pass() const
505 {
506     // Bug: https://bugs.webkit.org/show_bug.cgi?id=21015 this function returns
507     // a null string when the password is empty, which we duplicate here.
508     if (!m_url.m_parsed.password.is_nonempty())
509         return String();
510
511     // Note: KURL.cpp unescapes here.
512     return m_url.componentString(m_url.m_parsed.password);
513 }
514
515 // Returns the empty string if there is no username.
516 String KURL::user() const
517 {
518     // Note: KURL.cpp unescapes here.
519     return m_url.componentString(m_url.m_parsed.username);
520 }
521
522 String KURL::fragmentIdentifier() const
523 {
524     // Empty but present refs ("foo.com/bar#") should result in the empty
525     // string, which m_url.componentString will produce. Nonexistant refs should be
526     // the NULL string.
527     if (!m_url.m_parsed.ref.is_valid())
528         return String();
529
530     // Note: KURL.cpp unescapes here.
531     return m_url.componentString(m_url.m_parsed.ref);
532 }
533
534 bool KURL::hasFragmentIdentifier() const
535 {
536     // Note: KURL.cpp unescapes here.
537     // FIXME determine if KURL.cpp agrees about an empty ref
538     return m_url.m_parsed.ref.len >= 0;
539 }
540
541 String KURL::baseAsString() const
542 {
543     // FIXME: There is probably a more efficient way to do this?
544     return string().left(pathAfterLastSlash());
545 }
546
547 String KURL::query() const
548 {
549     if (m_url.m_parsed.query.len >= 0)
550         return m_url.componentString(m_url.m_parsed.query);
551
552     // Bug: https://bugs.webkit.org/show_bug.cgi?id=21015 this function returns
553     // an empty string when the query is empty rather than a null (not sure
554     // which is right).
555     // Returns a null if the query is not specified, instead of empty.
556     if (m_url.m_parsed.query.is_valid())
557         return String("", 0);
558     return String();
559 }
560
561 String KURL::path() const
562 {
563     // Note: KURL.cpp unescapes here.
564     return m_url.componentString(m_url.m_parsed.path);
565 }
566
567 void KURL::setProtocol(const String& protocol)
568 {
569     KURLGooglePrivate::Replacements replacements;
570     replacements.SetScheme(CharactersOrEmpty(protocol),
571                            url_parse::Component(0, protocol.length()));
572     m_url.replaceComponents(replacements);
573 }
574
575 void KURL::setHost(const String& host)
576 {
577     KURLGooglePrivate::Replacements replacements;
578     replacements.SetHost(CharactersOrEmpty(host),
579                          url_parse::Component(0, host.length()));
580     m_url.replaceComponents(replacements);
581 }
582
583 void KURL::setHostAndPort(const String& s)
584 {
585     String host = s;
586     String port;
587     int hostEnd = s.find(":");
588     if (hostEnd != -1) {
589         host = s.left(hostEnd);
590         port = s.substring(hostEnd + 1);
591     }
592
593     KURLGooglePrivate::Replacements replacements;
594     // Host can't be removed, so we always set.
595     replacements.SetHost(CharactersOrEmpty(host),
596                          url_parse::Component(0, host.length()));
597
598     if (port.isEmpty())  // Port may be removed, so we support clearing.
599         replacements.ClearPort();
600     else
601         replacements.SetPort(CharactersOrEmpty(port), url_parse::Component(0, port.length()));
602     m_url.replaceComponents(replacements);
603 }
604
605 void KURL::removePort()
606 {
607     if (hasPort()) {
608         String urlWithoutPort = m_url.string().left(hostEnd()) + m_url.string().substring(pathStart());
609         m_url.setUtf8(urlWithoutPort.utf8());
610     }
611 }
612
613 void KURL::setPort(unsigned short i)
614 {
615     KURLGooglePrivate::Replacements replacements;
616     String portStr;
617     if (i) {
618         portStr = String::number(static_cast<int>(i));
619         replacements.SetPort(
620             reinterpret_cast<const url_parse::UTF16Char*>(portStr.characters()),
621             url_parse::Component(0, portStr.length()));
622
623     } else {
624         // Clear any existing port when it is set to 0.
625         replacements.ClearPort();
626     }
627     m_url.replaceComponents(replacements);
628 }
629
630 void KURL::setUser(const String& user)
631 {
632     // This function is commonly called to clear the username, which we
633     // normally don't have, so we optimize this case.
634     if (user.isEmpty() && !m_url.m_parsed.username.is_valid())
635         return;
636
637     // The canonicalizer will clear any usernames that are empty, so we
638     // don't have to explicitly call ClearUsername() here.
639     KURLGooglePrivate::Replacements replacements;
640     replacements.SetUsername(CharactersOrEmpty(user),
641                              url_parse::Component(0, user.length()));
642     m_url.replaceComponents(replacements);
643 }
644
645 void KURL::setPass(const String& pass)
646 {
647     // This function is commonly called to clear the password, which we
648     // normally don't have, so we optimize this case.
649     if (pass.isEmpty() && !m_url.m_parsed.password.is_valid())
650         return;
651
652     // The canonicalizer will clear any passwords that are empty, so we
653     // don't have to explicitly call ClearUsername() here.
654     KURLGooglePrivate::Replacements replacements;
655     replacements.SetPassword(CharactersOrEmpty(pass),
656                              url_parse::Component(0, pass.length()));
657     m_url.replaceComponents(replacements);
658 }
659
660 void KURL::setFragmentIdentifier(const String& s)
661 {
662     // This function is commonly called to clear the ref, which we
663     // normally don't have, so we optimize this case.
664     if (s.isNull() && !m_url.m_parsed.ref.is_valid())
665         return;
666
667     KURLGooglePrivate::Replacements replacements;
668     if (s.isNull())
669         replacements.ClearRef();
670     else
671         replacements.SetRef(CharactersOrEmpty(s), url_parse::Component(0, s.length()));
672     m_url.replaceComponents(replacements);
673 }
674
675 void KURL::removeFragmentIdentifier()
676 {
677     KURLGooglePrivate::Replacements replacements;
678     replacements.ClearRef();
679     m_url.replaceComponents(replacements);
680 }
681
682 void KURL::setQuery(const String& query)
683 {
684     KURLGooglePrivate::Replacements replacements;
685     if (query.isNull()) {
686         // KURL.cpp sets to NULL to clear any query.
687         replacements.ClearQuery();
688     } else if (query.length() > 0 && query[0] == '?') {
689         // WebCore expects the query string to begin with a question mark, but
690         // GoogleURL doesn't. So we trim off the question mark when setting.
691         replacements.SetQuery(CharactersOrEmpty(query),
692                               url_parse::Component(1, query.length() - 1));
693     } else {
694         // When set with the empty string or something that doesn't begin with
695         // a question mark, KURL.cpp will add a question mark for you. The only
696         // way this isn't compatible is if you call this function with an empty
697         // string. KURL.cpp will leave a '?' with nothing following it in the
698         // URL, whereas we'll clear it.
699         // FIXME We should eliminate this difference.
700         replacements.SetQuery(CharactersOrEmpty(query),
701                               url_parse::Component(0, query.length()));
702     }
703     m_url.replaceComponents(replacements);
704 }
705
706 void KURL::setPath(const String& path)
707 {
708     // Empty paths will be canonicalized to "/", so we don't have to worry
709     // about calling ClearPath().
710     KURLGooglePrivate::Replacements replacements;
711     replacements.SetPath(CharactersOrEmpty(path),
712                          url_parse::Component(0, path.length()));
713     m_url.replaceComponents(replacements);
714 }
715
716 // On Mac, this just seems to return the same URL, but with "/foo/bar" for
717 // file: URLs instead of file:///foo/bar. We don't bother with any of this,
718 // at least for now.
719 String KURL::prettyURL() const
720 {
721     if (!m_url.m_isValid)
722         return String();
723     return m_url.string();
724 }
725
726 bool protocolIsJavaScript(const String& url)
727 {
728     return protocolIs(url, "javascript");
729 }
730
731 bool isValidProtocol(const String& protocol)
732 {
733     if (!isSchemeFirstChar(protocol[0]))
734         return false;
735     unsigned protocolLength = protocol.length();
736     for (unsigned i = 1; i < protocolLength; i++) {
737         if (!isSchemeChar(protocol[i]))
738             return false;
739     }
740     return true;
741 }
742
743 // We copied the KURL version here on Sept 12, 2008 while doing a WebKit
744 // merge.
745 // 
746 // FIXME Somehow share this with KURL? Like we'd theoretically merge with
747 // decodeURLEscapeSequences below?
748 String mimeTypeFromDataURL(const String& url)
749 {
750     ASSERT(protocolIs(url, "data"));
751     int index = url.find(';');
752     if (index == -1)
753         index = url.find(',');
754     if (index != -1) {
755         int len = index - 5;
756         if (len > 0)
757             return url.substring(5, len);
758         return "text/plain"; // Data URLs with no MIME type are considered text/plain.
759     }
760     return "";
761 }
762
763 String decodeURLEscapeSequences(const String& str)
764 {
765     return decodeURLEscapeSequences(str, UTF8Encoding());
766 }
767
768 // In KURL.cpp's implementation, this is called by every component getter.
769 // It will unescape every character, including NULL. This is scary, and may
770 // cause security holes. We never call this function for components, and
771 // just return the ASCII versions instead.
772 //
773 // This function is also used to decode javascript: URLs and as a general
774 // purpose unescaping function.
775 //
776 // FIXME These should be merged to the KURL.cpp implementation.
777 String decodeURLEscapeSequences(const String& str, const TextEncoding& encoding)
778 {
779     // FIXME We can probably use KURL.cpp's version of this function
780     // without modification. However, I'm concerned about
781     // https://bugs.webkit.org/show_bug.cgi?id=20559 so am keeping this old
782     // custom code for now. Using their version will also fix the bug that
783     // we ignore the encoding.
784     //
785     // FIXME b/1350291: This does not get called very often. We just convert
786     // first to 8-bit UTF-8, then unescape, then back to 16-bit. This kind of
787     // sucks, and we don't use the encoding properly, which will make some
788     // obscure anchor navigations fail.
789     CString cstr = str.utf8();
790
791     const char* input = cstr.data();
792     int inputLength = cstr.length();
793     url_canon::RawCanonOutputT<char> unescaped;
794     for (int i = 0; i < inputLength; i++) {
795         if (input[i] == '%') {
796             unsigned char ch;
797             if (url_canon::DecodeEscaped(input, &i, inputLength, &ch))
798                 unescaped.push_back(ch);
799             else {
800                 // Invalid escape sequence, copy the percent literal.
801                 unescaped.push_back('%');
802             }
803         } else {
804             // Regular non-escaped 8-bit character.
805             unescaped.push_back(input[i]);
806         }
807     }
808
809     // Convert that 8-bit to UTF-16. It's not clear IE does this at all to
810     // JavaScript URLs, but Firefox and Safari do.
811     url_canon::RawCanonOutputT<url_parse::UTF16Char> utf16;
812     for (int i = 0; i < unescaped.length(); i++) {
813         unsigned char uch = static_cast<unsigned char>(unescaped.at(i));
814         if (uch < 0x80) {
815             // Non-UTF-8, just append directly
816             utf16.push_back(uch);
817         } else {
818             // next_ch will point to the last character of the decoded
819             // character.
820             int nextCharacter = i;
821             unsigned codePoint;
822             if (url_canon::ReadUTFChar(unescaped.data(), &nextCharacter,
823                                        unescaped.length(), &codePoint)) {
824                 // Valid UTF-8 character, convert to UTF-16.
825                 url_canon::AppendUTF16Value(codePoint, &utf16);
826                 i = nextCharacter;
827             } else {
828                 // KURL.cpp strips any sequences that are not valid UTF-8. This
829                 // sounds scary. Instead, we just keep those invalid code
830                 // points and promote to UTF-16. We copy all characters from
831                 // the current position to the end of the identified sqeuqnce.
832                 while (i < nextCharacter) {
833                     utf16.push_back(static_cast<unsigned char>(unescaped.at(i)));
834                     i++;
835                 }
836                 utf16.push_back(static_cast<unsigned char>(unescaped.at(i)));
837             }
838         }
839     }
840
841     return String(reinterpret_cast<UChar*>(utf16.data()), utf16.length());
842 }
843
844 bool KURL::protocolIs(const char* protocol) const
845 {
846     assertProtocolIsGood(protocol);
847
848     // JavaScript URLs are "valid" and should be executed even if KURL decides they are invalid.
849     // The free function protocolIsJavaScript() should be used instead.
850     // FIXME: Chromium code needs to be fixed for this assert to be enabled. ASSERT(strcmp(protocol, "javascript"));
851
852     if (m_url.m_parsed.scheme.len <= 0)
853         return !protocol;
854     return lowerCaseEqualsASCII(
855         m_url.utf8String().data() + m_url.m_parsed.scheme.begin,
856         m_url.utf8String().data() + m_url.m_parsed.scheme.end(),
857         protocol);
858 }
859
860 bool KURL::isLocalFile() const
861 {
862     return protocolIs("file");
863 }
864
865 // This is called to escape a URL string. It is only used externally when
866 // constructing mailto: links to set the query section. Since our query setter
867 // will automatically do the correct escaping, this function does not have to
868 // do any work.
869 //
870 // There is a possibility that a future called may use this function in other
871 // ways, and may expect to get a valid URL string. The dangerous thing we want
872 // to protect against here is accidentally getting NULLs in a string that is
873 // not supposed to have NULLs. Therefore, we escape NULLs here to prevent this.
874 String encodeWithURLEscapeSequences(const String& notEncodedString)
875 {
876     CString utf8 = UTF8Encoding().encode(
877         reinterpret_cast<const UChar*>(notEncodedString.characters()),
878         notEncodedString.length(),
879         URLEncodedEntitiesForUnencodables);
880     const char* input = utf8.data();
881     int inputLength = utf8.length();
882
883     Vector<char, 2048> buffer;
884     for (int i = 0; i < inputLength; i++) {
885         if (!input[i])
886             buffer.append("%00", 3);
887         else
888             buffer.append(input[i]);
889     }
890     return String(buffer.data(), buffer.size());
891 }
892
893 bool KURL::isHierarchical() const
894 {
895     if (!m_url.m_parsed.scheme.is_nonempty())
896         return false;
897     return url_util::IsStandard(
898         &m_url.utf8String().data()[m_url.m_parsed.scheme.begin],
899         m_url.utf8String().length(),
900         m_url.m_parsed.scheme);
901 }
902
903 #ifndef NDEBUG
904 void KURL::print() const
905 {
906     printf("%s\n", m_url.utf8String().data());
907 }
908 #endif
909
910 void KURL::invalidate()
911 {
912     // This is only called from the constructor so resetting the (automatically
913     // initialized) string and parsed structure would be a waste of time.
914     m_url.m_isValid = false;
915     m_url.m_protocolInHTTPFamily = false;
916 }
917
918 // Equal up to reference fragments, if any.
919 bool equalIgnoringFragmentIdentifier(const KURL& a, const KURL& b)
920 {
921     // Compute the length of each URL without its ref. Note that the reference
922     // begin (if it exists) points to the character *after* the '#', so we need
923     // to subtract one.
924     int aLength = a.m_url.utf8String().length();
925     if (a.m_url.m_parsed.ref.len >= 0)
926         aLength = a.m_url.m_parsed.ref.begin - 1;
927
928     int bLength = b.m_url.utf8String().length();
929     if (b.m_url.m_parsed.ref.len >= 0)
930         bLength = b.m_url.m_parsed.ref.begin - 1;
931
932     return aLength == bLength
933         && !strncmp(a.m_url.utf8String().data(), b.m_url.utf8String().data(), aLength);
934 }
935
936 unsigned KURL::hostStart() const
937 {
938     return m_url.m_parsed.CountCharactersBefore(url_parse::Parsed::HOST, false);
939 }
940
941 unsigned KURL::hostEnd() const
942 {
943     return m_url.m_parsed.CountCharactersBefore(url_parse::Parsed::PORT, true);
944 }
945
946 unsigned KURL::pathStart() const
947 {
948     return m_url.m_parsed.CountCharactersBefore(url_parse::Parsed::PATH, false);
949 }
950
951 unsigned KURL::pathEnd() const
952 {
953     return m_url.m_parsed.CountCharactersBefore(url_parse::Parsed::QUERY, true);
954 }
955
956 unsigned KURL::pathAfterLastSlash() const
957 {
958     // When there's no path, ask for what would be the beginning of it.
959     if (!m_url.m_parsed.path.is_valid())
960         return m_url.m_parsed.CountCharactersBefore(url_parse::Parsed::PATH, false);
961
962     url_parse::Component filename;
963     url_parse::ExtractFileName(m_url.utf8String().data(), m_url.m_parsed.path,
964                                &filename);
965     return filename.begin;
966 }
967
968 const KURL& blankURL()
969 {
970     static KURL staticBlankURL(ParsedURLString, "about:blank");
971     return staticBlankURL;
972 }
973
974 bool protocolIs(const String& url, const char* protocol)
975 {
976     // Do the comparison without making a new string object.
977     assertProtocolIsGood(protocol);
978     for (int i = 0; ; ++i) {
979         if (!protocol[i])
980             return url[i] == ':';
981         if (toASCIILower(url[i]) != protocol[i])
982             return false;
983     }
984 }
985
986 inline bool KURL::protocolIs(const String& string, const char* protocol)
987 {
988     return WebCore::protocolIs(string, protocol);
989 }
990
991 bool protocolHostAndPortAreEqual(const KURL& a, const KURL& b)
992 {
993     if (a.parsed().scheme.end() != b.parsed().scheme.end())
994         return false;
995
996     int hostStartA = a.hostStart();
997     int hostStartB = b.hostStart();
998     if (a.hostEnd() - hostStartA != b.hostEnd() - hostStartB)
999         return false;
1000
1001     // Check the scheme
1002     for (int i = 0; i < a.parsed().scheme.end(); ++i)
1003         if (a.string()[i] != b.string()[i])
1004             return false;
1005     
1006     // And the host
1007     for (int i = hostStartA; i < static_cast<int>(a.hostEnd()); ++i)
1008         if (a.string()[i] != b.string()[i])
1009             return false;
1010     
1011     if (a.port() != b.port())
1012         return false;
1013
1014     return true;
1015 }
1016
1017 } // namespace WebCore
1018
1019 #endif // USE(GOOGLEURL)