summaryrefslogtreecommitdiffstats
path: root/WebCore/platform/KURL.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'WebCore/platform/KURL.cpp')
-rw-r--r--WebCore/platform/KURL.cpp1395
1 files changed, 699 insertions, 696 deletions
diff --git a/WebCore/platform/KURL.cpp b/WebCore/platform/KURL.cpp
index 45922e7..1f33297 100644
--- a/WebCore/platform/KURL.cpp
+++ b/WebCore/platform/KURL.cpp
@@ -28,20 +28,28 @@
#include "CString.h"
#include "PlatformString.h"
-#include "RegularExpression.h"
#include "TextEncoding.h"
-#include <wtf/Vector.h>
+
#if USE(ICU_UNICODE)
#include <unicode/uidna.h>
#elif USE(QT4_UNICODE)
#include <QUrl>
#endif
+#include <stdio.h>
+
using namespace std;
using namespace WTF;
namespace WebCore {
+typedef Vector<char, 512> CharBuffer;
+typedef Vector<UChar, 512> UCharBuffer;
+
+// FIXME: This file makes too much use of the + operator on String.
+// We either have to optimize that operator so it doesn't involve
+// so many allocations, or change this to use Vector<UChar> instead.
+
enum URLCharacterClasses {
// alpha
SchemeFirstChar = 1 << 0,
@@ -66,56 +74,52 @@ enum URLCharacterClasses {
// "#" | "?" | "/" | nul
PathSegmentEndChar = 1 << 5,
- // digit | "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c" | "d" | "e" | "f"
- HexDigitChar = 1 << 6,
-
// not allowed in path
- BadChar = 1 << 7
-
+ BadChar = 1 << 6
};
static const char hexDigits[17] = "0123456789ABCDEF";
static const unsigned char characterClassTable[256] = {
/* 0 nul */ PathSegmentEndChar, /* 1 soh */ BadChar,
- /* 2 stx */ BadChar, /* 3 etx */ BadChar,
+ /* 2 stx */ BadChar, /* 3 etx */ BadChar,
/* 4 eot */ BadChar, /* 5 enq */ BadChar, /* 6 ack */ BadChar, /* 7 bel */ BadChar,
- /* 8 bs */ BadChar, /* 9 ht */ BadChar, /* 10 nl */ BadChar, /* 11 vt */ BadChar,
+ /* 8 bs */ BadChar, /* 9 ht */ BadChar, /* 10 nl */ BadChar, /* 11 vt */ BadChar,
/* 12 np */ BadChar, /* 13 cr */ BadChar, /* 14 so */ BadChar, /* 15 si */ BadChar,
/* 16 dle */ BadChar, /* 17 dc1 */ BadChar, /* 18 dc2 */ BadChar, /* 19 dc3 */ BadChar,
/* 20 dc4 */ BadChar, /* 21 nak */ BadChar, /* 22 syn */ BadChar, /* 23 etb */ BadChar,
/* 24 can */ BadChar, /* 25 em */ BadChar, /* 26 sub */ BadChar, /* 27 esc */ BadChar,
/* 28 fs */ BadChar, /* 29 gs */ BadChar, /* 30 rs */ BadChar, /* 31 us */ BadChar,
/* 32 sp */ BadChar, /* 33 ! */ UserInfoChar,
- /* 34 " */ BadChar, /* 35 # */ PathSegmentEndChar | BadChar,
+ /* 34 " */ BadChar, /* 35 # */ PathSegmentEndChar | BadChar,
/* 36 $ */ UserInfoChar, /* 37 % */ UserInfoChar | HostnameChar | IPv6Char | BadChar,
/* 38 & */ UserInfoChar, /* 39 ' */ UserInfoChar,
- /* 40 ( */ UserInfoChar, /* 41 ) */ UserInfoChar,
+ /* 40 ( */ UserInfoChar, /* 41 ) */ UserInfoChar,
/* 42 * */ UserInfoChar, /* 43 + */ SchemeChar | UserInfoChar,
- /* 44 , */ UserInfoChar,
- /* 45 - */ SchemeChar | UserInfoChar | HostnameChar,
- /* 46 . */ SchemeChar | UserInfoChar | HostnameChar,
+ /* 44 , */ UserInfoChar,
+ /* 45 - */ SchemeChar | UserInfoChar | HostnameChar,
+ /* 46 . */ SchemeChar | UserInfoChar | HostnameChar,
/* 47 / */ PathSegmentEndChar,
- /* 48 0 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 49 1 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 50 2 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 51 3 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 52 4 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 53 5 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 54 6 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 55 7 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 56 8 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 57 9 */ SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
+ /* 48 0 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 49 1 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 50 2 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 51 3 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 52 4 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 53 5 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 54 6 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 55 7 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 56 8 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 57 9 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
/* 58 : */ UserInfoChar | IPv6Char, /* 59 ; */ UserInfoChar,
/* 60 < */ BadChar, /* 61 = */ UserInfoChar,
/* 62 > */ BadChar, /* 63 ? */ PathSegmentEndChar | BadChar,
/* 64 @ */ 0,
- /* 65 A */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 66 B */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 67 C */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 68 D */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 69 E */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 70 F */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
+ /* 65 A */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 66 B */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 67 C */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 68 D */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 69 E */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 70 F */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
/* 71 G */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
/* 72 H */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
/* 73 I */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
@@ -141,12 +145,12 @@ static const unsigned char characterClassTable[256] = {
/* 94 ^ */ 0,
/* 95 _ */ UserInfoChar | HostnameChar,
/* 96 ` */ 0,
- /* 97 a */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 98 b */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 99 c */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 100 d */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 101 e */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
- /* 102 f */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | HexDigitChar | IPv6Char,
+ /* 97 a */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 98 b */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 99 c */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 100 d */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 101 e */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
+ /* 102 f */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
/* 103 g */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
/* 104 h */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
/* 105 i */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
@@ -204,137 +208,166 @@ static const unsigned char characterClassTable[256] = {
};
static int copyPathRemovingDots(char* dst, const char* src, int srcStart, int srcEnd);
-static char* encodeRelativeString(const KURL &base, const DeprecatedString& rel, const TextEncoding&);
-static DeprecatedString substituteBackslashes(const DeprecatedString &string);
+static void encodeRelativeString(const String& rel, const TextEncoding&, CharBuffer& ouput);
+static String substituteBackslashes(const String&);
-static inline bool isSchemeFirstChar(unsigned char c) { return characterClassTable[c] & SchemeFirstChar; }
-static inline bool isSchemeChar(unsigned char c) { return characterClassTable[c] & SchemeChar; }
+static inline bool isSchemeFirstChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & SchemeFirstChar; }
+static inline bool isSchemeFirstChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeFirstChar); }
+static inline bool isSchemeChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & SchemeChar; }
+static inline bool isSchemeChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeChar); }
static inline bool isUserInfoChar(unsigned char c) { return characterClassTable[c] & UserInfoChar; }
static inline bool isHostnameChar(unsigned char c) { return characterClassTable[c] & HostnameChar; }
static inline bool isIPv6Char(unsigned char c) { return characterClassTable[c] & IPv6Char; }
-static inline bool isPathSegmentEndChar(unsigned char c) { return characterClassTable[c] & PathSegmentEndChar; }
+static inline bool isPathSegmentEndChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & PathSegmentEndChar; }
+static inline bool isPathSegmentEndChar(UChar c) { return c <= 0xff && (characterClassTable[c] & PathSegmentEndChar); }
static inline bool isBadChar(unsigned char c) { return characterClassTable[c] & BadChar; }
-static inline bool isHexDigit(unsigned char c) { return characterClassTable[c] & HexDigitChar; }
-static inline int hexDigitValue(unsigned char c)
+static inline int hexDigitValue(UChar c)
{
- ASSERT(isHexDigit(c));
+ ASSERT(isASCIIHexDigit(c));
if (c < 'A')
return c - '0';
return (c - 'A' + 10) & 0xF; // handle both upper and lower case without a branch
}
-#ifdef ANDROID_JAVASCRIPT_SECURITY
+// Copies the source to the destination, assuming all the source characters are
+// ASCII. The destination buffer must be large enough. Null characters are allowed
+// in the source string, and no attempt is made to null-terminate the result.
+static void copyASCII(const UChar* src, int length, char* dest)
+{
+ for (int i = 0; i < length; i++)
+ dest[i] = static_cast<char>(src[i]);
+}
+
+// FIXME: Move to PlatformString.h eventually.
+// Returns the index of the first index in string |s| of any of the characters
+// in |toFind|. |toFind| should be a null-terminated string, all characters up
+// to the null will be searched. Returns int if not found.
+static int findFirstOf(const UChar* s, int sLen, int startPos, const char* toFind)
+{
+ for (int i = startPos; i < sLen; i++) {
+ const char* cur = toFind;
+ while (*cur) {
+ if (s[i] == *(cur++))
+ return i;
+ }
+ }
+ return -1;
+}
+
inline bool KURL::protocolIs(const String& string, const char* protocol)
{
return WebCore::protocolIs(string, protocol);
}
-#endif
-// KURL
-
-KURL::KURL() : m_isValid(false)
+void KURL::invalidate()
{
+ m_isValid = false;
+ m_schemeEnd = 0;
+ m_userStart = 0;
+ m_userEnd = 0;
+ m_passwordEnd = 0;
+ m_hostEnd = 0;
+ m_portEnd = 0;
+ m_pathEnd = 0;
+ m_pathAfterLastSlash = 0;
+ m_queryEnd = 0;
+ m_fragmentEnd = 0;
}
-KURL::KURL(const char *url)
+KURL::KURL(const char* url)
{
- if (url && url[0] == '/') {
- // 5 for "file:", 1 for terminator
- size_t urlLength = strlen(url) + 1;
- Vector<char, 2048> buffer(urlLength + 5);
- buffer[0] = 'f';
- buffer[1] = 'i';
- buffer[2] = 'l';
- buffer[3] = 'e';
- buffer[4] = ':';
- memcpy(&buffer[5], url, urlLength);
- parse(buffer.data(), 0);
- } else
+ if (!url || url[0] != '/') {
parse(url, 0);
+ return;
+ }
+
+ size_t urlLength = strlen(url) + 1;
+ CharBuffer buffer(urlLength + 5); // 5 for "file:".
+ buffer[0] = 'f';
+ buffer[1] = 'i';
+ buffer[2] = 'l';
+ buffer[3] = 'e';
+ buffer[4] = ':';
+ memcpy(&buffer[5], url, urlLength);
+ parse(buffer.data(), 0);
}
-KURL::KURL(const DeprecatedString &url)
+KURL::KURL(const String& url)
{
- if (!url.isEmpty() && url[0] == '/') {
- // 5 for "file:", 1 for terminator
- Vector<char, 2048> buffer(url.length() + 6);
- buffer[0] = 'f';
- buffer[1] = 'i';
- buffer[2] = 'l';
- buffer[3] = 'e';
- buffer[4] = ':';
- url.copyLatin1(&buffer[5]);
- parse(buffer.data(), 0);
- } else
- parse(url.ascii(), &url);
+ if (url[0] != '/') {
+ parse(url);
+ return;
+ }
+
+ CharBuffer buffer(url.length() + 6); // 5 for "file:", 1 for terminator.
+ buffer[0] = 'f';
+ buffer[1] = 'i';
+ buffer[2] = 'l';
+ buffer[3] = 'e';
+ buffer[4] = ':';
+ copyASCII(url.characters(), url.length(), &buffer[5]);
+ buffer[url.length() + 5] = '\0'; // Need null terminator.
+
+ parse(buffer.data(), 0);
}
-KURL::KURL(const KURL& base, const DeprecatedString& relative)
+KURL::KURL(const KURL& base, const String& relative)
{
init(base, relative, UTF8Encoding());
}
-KURL::KURL(const KURL& base, const DeprecatedString& relative, const TextEncoding& encoding)
+KURL::KURL(const KURL& base, const String& relative, const TextEncoding& encoding)
{
init(base, relative, encoding);
}
-void KURL::init(const KURL &base, const DeprecatedString &relative, const TextEncoding& encoding)
+void KURL::init(const KURL& base, const String& relative, const TextEncoding& encoding)
{
- // Allow at least absolute URLs to resolve against an empty URL.
+ // Allow resolutions with a null or empty base URL, but not with any other invalid one.
+ // FIXME: Is this a good rule?
if (!base.m_isValid && !base.isEmpty()) {
- m_isValid = false;
+ m_string = relative;
+ invalidate();
return;
}
-
- bool absolute = false;
- // for compatibility with Win IE, we must treat backslashes as if they were slashes, as long as we're not dealing with the javascript: schema
- DeprecatedString substitutedRelative;
-#ifdef ANDROID_JAVASCRIPT_SECURITY
- bool shouldSubstituteBackslashes = relative.contains('\\') && !(protocolIs(relative, "javascript") || protocolIs(relative, "data"));
-#else
- bool shouldSubstituteBackslashes = relative.contains('\\') && !(relative.startsWith("javascript:", false) || relative.startsWith("data:", false));
-#endif
- if (shouldSubstituteBackslashes)
- substitutedRelative = substituteBackslashes(relative);
+ // For compatibility with Win IE, treat backslashes as if they were slashes,
+ // as long as we're not dealing with javascript: or data: URLs.
+ String rel = relative;
+ if (rel.contains('\\') && !(protocolIs(rel, "javascript") || protocolIs(rel, "data")))
+ rel = substituteBackslashes(rel);
- const DeprecatedString &rel = shouldSubstituteBackslashes ? substitutedRelative : relative;
-
- bool allASCII = rel.isAllASCII();
- char *strBuffer;
- const char *str;
+ String* originalString = &rel;
+
+ bool allASCII = charactersAreAllASCII(rel.characters(), rel.length());
+ CharBuffer strBuffer;
+ char* str;
+ size_t len;
if (allASCII) {
- strBuffer = 0;
- str = rel.ascii();
+ len = rel.length();
+ strBuffer.resize(len + 1);
+ copyASCII(rel.characters(), len, strBuffer.data());
+ strBuffer[len] = 0;
+ str = strBuffer.data();
} else {
- strBuffer = encodeRelativeString(base, rel, encoding);
- str = strBuffer;
+ originalString = 0;
+ encodeRelativeString(rel, encoding, strBuffer);
+ str = strBuffer.data();
+ len = strlen(str);
}
-
- // workaround for sites that put leading whitespace whitespace on
- // URL references
- bool strippedStart = false;
+
+ // Get rid of leading whitespace.
while (*str == ' ') {
+ originalString = 0;
str++;
- strippedStart = true;
+ --len;
}
- // workaround for trailing whitespace - a bit more complicated cause we have to copy
- // it would be even better to replace null-termination with a length parameter
- int len = strlen(str);
- int charsToChopOffEnd = 0;
- for (int pos = len - 1; pos >= 0 && str[pos] == ' '; pos--) {
- charsToChopOffEnd++;
- }
- if (charsToChopOffEnd > 0) {
- char *newStrBuffer = (char *)fastMalloc((len + 1) - charsToChopOffEnd);
- strncpy(newStrBuffer, str, len - charsToChopOffEnd);
- newStrBuffer[len - charsToChopOffEnd] = '\0';
- fastFree(strBuffer);
- strBuffer = newStrBuffer;
- str = strBuffer;
+ // Get rid of trailing whitespace.
+ while (len && str[len - 1] == ' ') {
+ originalString = 0;
+ str[--len] = '\0';
}
// According to the RFC, the reference should be interpreted as an
@@ -342,119 +375,108 @@ void KURL::init(const KURL &base, const DeprecatedString &relative, const TextEn
// algorithm. If the URI reference is absolute it will have a
// scheme, meaning that it will have a colon before the first
// non-scheme element.
- const char *p = str;
+ bool absolute = false;
+ char* p = str;
if (isSchemeFirstChar(*p)) {
++p;
while (isSchemeChar(*p)) {
++p;
}
if (*p == ':') {
- if (p[1] != '/' && base.protocol().lower() == DeprecatedString(str, p - str).lower() && base.isHierarchical())
+ if (p[1] != '/' && equalIgnoringCase(base.protocol(), String(str, p - str)) && base.isHierarchical()) {
str = p + 1;
- else
+ originalString = 0;
+ } else
absolute = true;
}
}
if (absolute) {
- parse(str, (allASCII && !strippedStart && (charsToChopOffEnd == 0)) ? &rel : 0);
+ parse(str, originalString);
} else {
// If the base is empty or opaque (e.g. data: or javascript:), then the URL is invalid
// unless the relative URL is a single fragment.
if (!base.isHierarchical()) {
- if (str[0] == '#') {
- DeprecatedString newURL = base.urlString.left(base.queryEndPos) + str;
- parse(newURL.ascii(), &newURL);
- } else
- m_isValid = false;
-
- if (strBuffer)
- fastFree(strBuffer);
+ if (str[0] == '#')
+ parse(base.m_string.left(base.m_queryEnd) + (allASCII ? String(str) : String::fromUTF8(str)));
+ else {
+ m_string = relative;
+ invalidate();
+ }
return;
}
- switch(str[0]) {
+ switch (str[0]) {
case '\0':
// the reference must be empty - the RFC says this is a
// reference to the same document
- {
- *this = base;
- break;
- }
+ *this = base;
+ break;
case '#':
// must be fragment-only reference
- {
- DeprecatedString newURL = base.urlString.left(base.queryEndPos) + str;
- parse(newURL.ascii(), &newURL);
- break;
- }
+ parse(base.m_string.left(base.m_queryEnd) + (allASCII ? String(str) : String::fromUTF8(str)));
+ break;
case '?':
// query-only reference, special case needed for non-URL results
- {
- DeprecatedString newURL = base.urlString.left(base.pathEndPos) + str;
- parse(newURL.ascii(), &newURL);
- break;
- }
+ parse(base.m_string.left(base.m_pathEnd) + (allASCII ? String(str) : String::fromUTF8(str)));
+ break;
case '/':
// must be net-path or absolute-path reference
- {
- if (str[1] == '/') {
- // net-path
- DeprecatedString newURL = base.urlString.left(base.schemeEndPos + 1) + str;
- parse(newURL.ascii(), &newURL);
- } else {
- // abs-path
- DeprecatedString newURL = base.urlString.left(base.portEndPos) + str;
- parse(newURL.ascii(), &newURL);
- }
- break;
+ if (str[1] == '/') {
+ // net-path
+ parse(base.m_string.left(base.m_schemeEnd + 1) + (allASCII ? String(str) : String::fromUTF8(str)));
+ } else {
+ // abs-path
+ parse(base.m_string.left(base.m_portEnd) + (allASCII ? String(str) : String::fromUTF8(str)));
}
+ break;
default:
{
// must be relative-path reference
// Base part plus relative part plus one possible slash added in between plus terminating \0 byte.
- Vector<char, 2048> buffer(base.pathEndPos + 1 + strlen(str) + 1);
+ CharBuffer buffer(base.m_pathEnd + 1 + len + 1);
+
+ char* bufferPos = buffer.data();
- char *bufferPos = buffer.data();
-
// first copy everything before the path from the base
- const char *baseString = base.urlString.ascii();
- const char *baseStringStart = baseString;
- const char *pathStart = baseStringStart + base.portEndPos;
- while (baseStringStart < pathStart) {
+ unsigned baseLength = base.m_string.length();
+ const UChar* baseCharacters = base.m_string.characters();
+ CharBuffer baseStringBuffer(baseLength);
+ for (unsigned i = 0; i < baseLength; ++i)
+ baseStringBuffer[i] = static_cast<char>(baseCharacters[i]);
+ const char* baseString = baseStringBuffer.data();
+ const char* baseStringStart = baseString;
+ const char* pathStart = baseStringStart + base.m_portEnd;
+ while (baseStringStart < pathStart)
*bufferPos++ = *baseStringStart++;
- }
- char *bufferPathStart = bufferPos;
+ char* bufferPathStart = bufferPos;
+
+ // now copy the base path
+ const char* baseStringEnd = baseString + base.m_pathEnd;
- // now copy the base path
- const char *baseStringEnd = baseString + base.pathEndPos;
-
// go back to the last slash
- while (baseStringEnd > baseStringStart && baseStringEnd[-1] != '/') {
+ while (baseStringEnd > baseStringStart && baseStringEnd[-1] != '/')
baseStringEnd--;
- }
-
+
if (baseStringEnd == baseStringStart) {
// no path in base, add a path separator if necessary
- if (base.schemeEndPos + 1 != base.pathEndPos && *str != '\0' && *str != '?' && *str != '#') {
+ if (base.m_schemeEnd + 1 != base.m_pathEnd && *str && *str != '?' && *str != '#')
*bufferPos++ = '/';
- }
} else {
bufferPos += copyPathRemovingDots(bufferPos, baseStringStart, 0, baseStringEnd - baseStringStart);
}
- const char *relStringStart = str;
- const char *relStringPos = relStringStart;
-
- while (*relStringPos != '\0' && *relStringPos != '?' && *relStringPos != '#') {
+ const char* relStringStart = str;
+ const char* relStringPos = relStringStart;
+
+ while (*relStringPos && *relStringPos != '?' && *relStringPos != '#') {
if (relStringPos[0] == '.' && bufferPos[-1] == '/') {
if (isPathSegmentEndChar(relStringPos[1])) {
// skip over "." segment
relStringPos += 1;
- if (relStringPos[0] == '/') {
+ if (relStringPos[0] == '/')
relStringPos++;
- }
continue;
} else if (relStringPos[1] == '.' && isPathSegmentEndChar(relStringPos[2])) {
// skip over ".." segment and rewind the last segment
@@ -462,19 +484,16 @@ void KURL::init(const KURL &base, const DeprecatedString &relative, const TextEn
// ".." segments - we choose to drop them since some web content
// relies on this.
relStringPos += 2;
- if (relStringPos[0] == '/') {
+ if (relStringPos[0] == '/')
relStringPos++;
- }
- if (bufferPos > bufferPathStart + 1) {
+ if (bufferPos > bufferPathStart + 1)
bufferPos--;
- }
- while (bufferPos > bufferPathStart + 1 && bufferPos[-1] != '/') {
+ while (bufferPos > bufferPathStart + 1 && bufferPos[-1] != '/')
bufferPos--;
- }
continue;
}
}
-
+
*bufferPos = *relStringPos;
relStringPos++;
bufferPos++;
@@ -485,114 +504,84 @@ void KURL::init(const KURL &base, const DeprecatedString &relative, const TextEn
strcpy(bufferPos, relStringPos);
parse(buffer.data(), 0);
-
+
ASSERT(strlen(buffer.data()) + 1 <= buffer.size());
break;
}
}
}
-
- if (strBuffer) {
- fastFree(strBuffer);
- }
}
bool KURL::hasPath() const
{
- return m_isValid && pathEndPos != portEndPos;
+ return m_pathEnd != m_portEnd;
}
-DeprecatedString KURL::lastPathComponent() const
+String KURL::lastPathComponent() const
{
if (!hasPath())
- return DeprecatedString();
+ return String();
- int end = pathEndPos - 1;
- if (urlString[end] == '/')
+ int end = m_pathEnd - 1;
+ if (m_string[end] == '/')
--end;
- int start = urlString.findRev('/', end);
- if (start < portEndPos)
- return DeprecatedString();
+ int start = m_string.reverseFind('/', end);
+ if (start < m_portEnd)
+ return String();
++start;
- return urlString.mid(start, end - start + 1);
+ return m_string.substring(start, end - start + 1);
}
-DeprecatedString KURL::protocol() const
+String KURL::protocol() const
{
- if (!m_isValid) {
- return DeprecatedString();
- }
-
- return urlString.left(schemeEndPos);
+ return m_string.left(m_schemeEnd);
}
-DeprecatedString KURL::host() const
+String KURL::host() const
{
- if (!m_isValid) {
- return DeprecatedString();
- }
-
- int start = (passwordEndPos == userStartPos) ? passwordEndPos : passwordEndPos + 1;
- return decode_string(urlString.mid(start, hostEndPos - start));
+ int start = hostStart();
+ return decodeURLEscapeSequences(m_string.substring(start, m_hostEnd - start));
}
-unsigned short int KURL::port() const
+unsigned short KURL::port() const
{
- if (!m_isValid) {
+ if (m_hostEnd == m_portEnd)
return 0;
- }
-
- if (hostEndPos != portEndPos) {
- bool ok;
- unsigned short result = urlString.mid(hostEndPos + 1, portEndPos - hostEndPos - 1).toUShort(&ok);
- if (!ok) {
- result = 0;
- }
- return result;
- }
- return 0;
+ int number = m_string.substring(m_hostEnd + 1, m_portEnd - m_hostEnd - 1).toInt();
+ if (number < 0 || number > 0xFFFF)
+ return 0;
+ return number;
}
-DeprecatedString KURL::pass() const
+String KURL::pass() const
{
- if (!m_isValid) {
- return DeprecatedString();
- }
-
- if (passwordEndPos == userEndPos) {
- return DeprecatedString();
- }
+ if (m_passwordEnd == m_userEnd)
+ return String();
- return decode_string(urlString.mid(userEndPos + 1, passwordEndPos - userEndPos - 1));
+ return decodeURLEscapeSequences(m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1));
}
-DeprecatedString KURL::user() const
+String KURL::user() const
{
- if (!m_isValid) {
- return DeprecatedString();
- }
-
- return decode_string(urlString.mid(userStartPos, userEndPos - userStartPos));
+ return decodeURLEscapeSequences(m_string.substring(m_userStart, m_userEnd - m_userStart));
}
-DeprecatedString KURL::ref() const
+String KURL::ref() const
{
- if (!m_isValid || fragmentEndPos == queryEndPos) {
- return DeprecatedString();
- }
+ if (m_fragmentEnd == m_queryEnd)
+ return String();
- return urlString.mid(queryEndPos + 1, fragmentEndPos - (queryEndPos + 1));
+ return m_string.substring(m_queryEnd + 1, m_fragmentEnd - (m_queryEnd + 1));
}
bool KURL::hasRef() const
{
- return m_isValid && fragmentEndPos != queryEndPos;
+ return m_fragmentEnd != m_queryEnd;
}
-#ifdef ANDROID_JAVASCRIPT_SECURITY
static inline void assertProtocolIsGood(const char* protocol)
{
#ifndef NDEBUG
@@ -610,210 +599,208 @@ bool KURL::protocolIs(const char* protocol) const
assertProtocolIsGood(protocol);
if (!m_isValid)
return false;
- for (int i = 0; i < schemeEndPos; ++i) {
- if (!protocol[i] || toASCIILower(urlString[i].unicode()) != protocol[i])
+ for (int i = 0; i < m_schemeEnd; ++i) {
+ if (!protocol[i] || toASCIILower(m_string[i]) != protocol[i])
return false;
}
- return !protocol[schemeEndPos]; // We should have consumed all characters in the argument.
+ return !protocol[m_schemeEnd]; // We should have consumed all characters in the argument.
}
-#endif
-DeprecatedString KURL::query() const
+String KURL::query() const
{
- if (!m_isValid) {
- return DeprecatedString();
- }
-
- return urlString.mid(pathEndPos, queryEndPos - pathEndPos);
+ return m_string.substring(m_pathEnd, m_queryEnd - m_pathEnd);
}
-DeprecatedString KURL::path() const
+String KURL::path() const
{
- if (!m_isValid) {
- return DeprecatedString();
- }
-
- return decode_string(urlString.mid(portEndPos, pathEndPos - portEndPos));
+ return decodeURLEscapeSequences(m_string.substring(m_portEnd, m_pathEnd - m_portEnd));
}
-void KURL::setProtocol(const DeprecatedString &s)
+void KURL::setProtocol(const String& s)
{
if (!m_isValid) {
- DeprecatedString newURL = s + ":" + urlString;
- parse(newURL.ascii(), &newURL);
+ parse(s + ":" + m_string);
return;
}
- DeprecatedString newURL = s + urlString.mid(schemeEndPos);
- parse(newURL.ascii(), &newURL);
+ parse(s + m_string.substring(m_schemeEnd));
}
-void KURL::setHost(const DeprecatedString &s)
+void KURL::setHost(const String& s)
{
- if (m_isValid) {
- bool slashSlashNeeded = userStartPos == schemeEndPos + 1;
- int hostStart = (passwordEndPos == userStartPos) ? passwordEndPos : passwordEndPos + 1;
-
- DeprecatedString newURL = urlString.left(hostStart) + (slashSlashNeeded ? "//" : DeprecatedString()) + s + urlString.mid(hostEndPos);
- parse(newURL.ascii(), &newURL);
- }
+ if (!m_isValid)
+ return;
+
+ bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
+
+ parse(m_string.left(hostStart()) + (slashSlashNeeded ? "//" : "") + s + m_string.substring(m_hostEnd));
}
void KURL::setPort(unsigned short i)
{
- if (m_isValid) {
- bool colonNeeded = portEndPos == hostEndPos;
- int portStart = (colonNeeded ? hostEndPos : hostEndPos + 1);
- DeprecatedString newURL = urlString.left(portStart) + (colonNeeded ? ":" : DeprecatedString()) + DeprecatedString::number(i) + urlString.mid(portEndPos);
- parse(newURL.ascii(), &newURL);
- }
+ if (!m_isValid)
+ return;
+
+ bool colonNeeded = m_portEnd == m_hostEnd;
+ int portStart = (colonNeeded ? m_hostEnd : m_hostEnd + 1);
+
+ parse(m_string.left(portStart) + (colonNeeded ? ":" : "") + String::number(i) + m_string.substring(m_portEnd));
}
-void KURL::setHostAndPort(const DeprecatedString& hostAndPort)
+void KURL::setHostAndPort(const String& hostAndPort)
{
- if (m_isValid) {
- bool slashSlashNeeded = userStartPos == schemeEndPos + 1;
- int hostStart = (passwordEndPos == userStartPos) ? passwordEndPos : passwordEndPos + 1;
-
- DeprecatedString newURL = urlString.left(hostStart) + (slashSlashNeeded ? "//" : DeprecatedString()) + hostAndPort + urlString.mid(portEndPos);
- parse(newURL.ascii(), &newURL);
- }
+ if (!m_isValid)
+ return;
+
+ bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
+
+ parse(m_string.left(hostStart()) + (slashSlashNeeded ? "//" : "") + hostAndPort + m_string.substring(m_portEnd));
}
-void KURL::setUser(const DeprecatedString &user)
+void KURL::setUser(const String& user)
{
- if (m_isValid) {
- DeprecatedString u;
- int end = userEndPos;
- if (!user.isEmpty()) {
- u = user;
- if (userStartPos == schemeEndPos + 1)
- u = "//" + u;
- // Add '@' if we didn't have one before.
- if (end == hostEndPos || (end == passwordEndPos && urlString[end] != '@'))
- u += '@';
- } else {
- // Remove '@' if we now have neither user nor password.
- if (userEndPos == passwordEndPos && end != hostEndPos && urlString[end] == '@')
- end += 1;
- }
- const DeprecatedString newURL = urlString.left(userStartPos) + u + urlString.mid(end);
- parse(newURL.ascii(), &newURL);
+ if (!m_isValid)
+ return;
+
+ String u;
+ int end = m_userEnd;
+ if (!user.isEmpty()) {
+ u = user;
+ if (m_userStart == m_schemeEnd + 1)
+ u = "//" + u;
+ // Add '@' if we didn't have one before.
+ if (end == m_hostEnd || (end == m_passwordEnd && m_string[end] != '@'))
+ u.append('@');
+ } else {
+ // Remove '@' if we now have neither user nor password.
+ if (m_userEnd == m_passwordEnd && end != m_hostEnd && m_string[end] == '@')
+ end += 1;
}
+ parse(m_string.left(m_userStart) + u + m_string.substring(end));
}
-void KURL::setPass(const DeprecatedString &password)
+void KURL::setPass(const String& password)
{
- if (m_isValid) {
- DeprecatedString p;
- int end = passwordEndPos;
- if (!password.isEmpty()) {
- p = ':' + password + '@';
- if (userEndPos == schemeEndPos + 1)
- p = "//" + p;
- // Eat the existing '@' since we are going to add our own.
- if (end != hostEndPos && urlString[end] == '@')
- end += 1;
- } else {
- // Remove '@' if we now have neither user nor password.
- if (userStartPos == userEndPos && end != hostEndPos && urlString[end] == '@')
- end += 1;
- }
- const DeprecatedString newURL = urlString.left(userEndPos) + p + urlString.mid(end);
- parse(newURL.ascii(), &newURL);
+ if (!m_isValid)
+ return;
+
+ String p;
+ int end = m_passwordEnd;
+ if (!password.isEmpty()) {
+ p = ":" + password + "@";
+ if (m_userEnd == m_schemeEnd + 1)
+ p = "//" + p;
+ // Eat the existing '@' since we are going to add our own.
+ if (end != m_hostEnd && m_string[end] == '@')
+ end += 1;
+ } else {
+ // Remove '@' if we now have neither user nor password.
+ if (m_userStart == m_userEnd && end != m_hostEnd && m_string[end] == '@')
+ end += 1;
}
+ parse(m_string.left(m_userEnd) + p + m_string.substring(end));
}
-void KURL::setRef(const DeprecatedString &s)
+void KURL::setRef(const String& s)
{
- if (m_isValid) {
- DeprecatedString newURL = urlString.left(queryEndPos) + (s.isEmpty() ? DeprecatedString() : "#" + s);
- parse(newURL.ascii(), &newURL);
- }
+ if (!m_isValid)
+ return;
+ parse(m_string.left(m_queryEnd) + (s.isNull() ? "" : "#" + s));
}
-void KURL::setQuery(const DeprecatedString &query)
+void KURL::removeRef()
{
- if (m_isValid) {
- DeprecatedString q;
- if (!query.isNull() && (query.isEmpty() || query[0] != '?')) {
- q = "?" + query;
- } else {
- q = query;
- }
+ if (!m_isValid)
+ return;
+ parse(m_string.left(m_queryEnd));
+}
+
+void KURL::setQuery(const String& query)
+{
+ if (!m_isValid)
+ return;
+
+ if ((query.isEmpty() || query[0] != '?') && !query.isNull())
+ parse(m_string.left(m_pathEnd) + "?" + query + m_string.substring(m_queryEnd));
+ else
+ parse(m_string.left(m_pathEnd) + query + m_string.substring(m_queryEnd));
- DeprecatedString newURL = urlString.left(pathEndPos) + q + urlString.mid(queryEndPos);
- parse(newURL.ascii(), &newURL);
- }
}
-void KURL::setPath(const DeprecatedString &s)
+void KURL::setPath(const String& s)
{
- if (m_isValid) {
- DeprecatedString newURL = urlString.left(portEndPos) + encode_string(s) + urlString.mid(pathEndPos);
- parse(newURL.ascii(), &newURL);
- }
+ if (!m_isValid)
+ return;
+
+ parse(m_string.left(m_portEnd) + encodeWithURLEscapeSequences(s) + m_string.substring(m_pathEnd));
}
-DeprecatedString KURL::prettyURL() const
+String KURL::prettyURL() const
{
- if (!m_isValid) {
- return urlString;
- }
+ if (!m_isValid)
+ return m_string;
+
+ Vector<UChar> result;
- DeprecatedString result = protocol() + ":";
+ append(result, protocol());
+ result.append(':');
- DeprecatedString authority;
+ Vector<UChar> authority;
- if (hostEndPos != passwordEndPos) {
- if (userEndPos != userStartPos) {
- authority += user();
- authority += "@";
+ if (m_hostEnd != m_passwordEnd) {
+ if (m_userEnd != m_userStart) {
+ append(authority, user());
+ authority.append('@');
}
- authority += host();
+ append(authority, host());
if (port() != 0) {
- authority += ":";
- authority += DeprecatedString::number(port());
+ authority.append(':');
+ append(authority, String::number(port()));
}
}
- if (!authority.isEmpty())
- result += "//" + authority;
- else if (protocol() == "file")
- result += "//";
+ if (!authority.isEmpty()) {
+ result.append('/');
+ result.append('/');
+ result.append(authority);
+ } else if (protocolIs("file")) {
+ result.append('/');
+ result.append('/');
+ }
- result += path();
- result += query();
+ append(result, path());
+ append(result, query());
- if (fragmentEndPos != queryEndPos) {
- result += "#" + ref();
+ if (m_fragmentEnd != m_queryEnd) {
+ result.append('#');
+ append(result, ref());
}
- return result;
+ return String::adopt(result);
}
-DeprecatedString KURL::decode_string(const DeprecatedString& urlString)
+String decodeURLEscapeSequences(const String& str)
{
- return decode_string(urlString, UTF8Encoding());
+ return decodeURLEscapeSequences(str, UTF8Encoding());
}
-DeprecatedString KURL::decode_string(const DeprecatedString& urlString, const TextEncoding& encoding)
+String decodeURLEscapeSequences(const String& str, const TextEncoding& encoding)
{
- DeprecatedString result("");
+ Vector<UChar> result;
- Vector<char, 2048> buffer(0);
+ CharBuffer buffer;
- int length = urlString.length();
+ int length = str.length();
int decodedPosition = 0;
int searchPosition = 0;
int encodedRunPosition;
- while ((encodedRunPosition = urlString.find('%', searchPosition)) >= 0) {
+ while ((encodedRunPosition = str.find('%', searchPosition)) >= 0) {
// Find the sequence of %-escape codes.
int encodedRunEnd = encodedRunPosition;
while (length - encodedRunEnd >= 3
- && urlString[encodedRunEnd] == '%'
- && isHexDigit(urlString[encodedRunEnd + 1].latin1())
- && isHexDigit(urlString[encodedRunEnd + 2].latin1()))
+ && str[encodedRunEnd] == '%'
+ && isASCIIHexDigit(str[encodedRunEnd + 1])
+ && isASCIIHexDigit(str[encodedRunEnd + 2]))
encodedRunEnd += 3;
if (encodedRunEnd == encodedRunPosition) {
++searchPosition;
@@ -821,16 +808,12 @@ DeprecatedString KURL::decode_string(const DeprecatedString& urlString, const Te
}
searchPosition = encodedRunEnd;
- // Copy the entire %-escape sequence into an 8-bit buffer.
- int encodedRunLength = encodedRunEnd - encodedRunPosition;
- buffer.clear();
- buffer.grow(encodedRunLength + 1);
- urlString.copyLatin1(buffer.data(), encodedRunPosition, encodedRunLength);
-
// Decode the %-escapes into bytes.
- char *p = buffer.data();
- const char *q = buffer.data();
- while (*q) {
+ unsigned runLength = (encodedRunEnd - encodedRunPosition) / 3;
+ buffer.resize(runLength);
+ char* p = buffer.data();
+ const UChar* q = str.characters() + encodedRunPosition;
+ for (unsigned i = 0; i < runLength; ++i) {
*p++ = (hexDigitValue(q[1]) << 4) | hexDigitValue(q[2]);
q += 3;
}
@@ -841,13 +824,14 @@ DeprecatedString KURL::decode_string(const DeprecatedString& urlString, const Te
continue;
// Build up the string with what we just skipped and what we just decoded.
- result.append(urlString.mid(decodedPosition, encodedRunPosition - decodedPosition));
- result.append(reinterpret_cast<const DeprecatedChar*>(decoded.characters()), decoded.length());
+ result.append(str.characters() + decodedPosition, encodedRunPosition - decodedPosition);
+ result.append(decoded.characters(), decoded.length());
decodedPosition = encodedRunEnd;
}
- result.append(urlString.mid(decodedPosition, length - decodedPosition));
- return result;
+ result.append(str.characters() + decodedPosition, length - decodedPosition);
+
+ return String::adopt(result);
}
bool KURL::isLocalFile() const
@@ -856,15 +840,15 @@ bool KURL::isLocalFile() const
// and including feed would allow feeds to potentially let someone's blog
// read the contents of the clipboard on a drag, even without a drop.
// Likewise with using the FrameLoader::shouldTreatURLAsLocal() function.
- return equalIgnoringCase(protocol(), "file");
+ return protocolIs("file");
}
-static void appendEscapingBadChars(char*& buffer, const char *strStart, size_t length)
+static void appendEscapingBadChars(char*& buffer, const char* strStart, size_t length)
{
- char *p = buffer;
+ char* p = buffer;
- const char *str = strStart;
- const char *strEnd = strStart + length;
+ const char* str = strStart;
+ const char* strEnd = strStart + length;
while (str < strEnd) {
unsigned char c = *str++;
if (isBadChar(c)) {
@@ -879,20 +863,20 @@ static void appendEscapingBadChars(char*& buffer, const char *strStart, size_t l
*p++ = c;
}
}
-
+
buffer = p;
}
// copy a path, accounting for "." and ".." segments
-static int copyPathRemovingDots(char *dst, const char *src, int srcStart, int srcEnd)
+static int copyPathRemovingDots(char* dst, const char* src, int srcStart, int srcEnd)
{
- char *bufferPathStart = dst;
+ char* bufferPathStart = dst;
// empty path is a special case, and need not have a leading slash
if (srcStart != srcEnd) {
- const char *baseStringStart = src + srcStart;
- const char *baseStringEnd = src + srcEnd;
- const char *baseStringPos = baseStringStart;
+ const char* baseStringStart = src + srcStart;
+ const char* baseStringEnd = src + srcEnd;
+ const char* baseStringPos = baseStringStart;
// this code is unprepared for paths that do not begin with a
// slash and we should always have one in the source string
@@ -916,18 +900,15 @@ static int copyPathRemovingDots(char *dst, const char *src, int srcStart, int sr
// ".." segments - we choose to drop them since some web content
// relies on this.
baseStringPos += 3;
- if (dst > bufferPathStart + 1) {
+ if (dst > bufferPathStart + 1)
dst--;
- }
// Note that these two while blocks differ subtly.
// The first helps to remove multiple adjoining slashes as we rewind.
// The +1 to bufferPathStart in the first while block prevents eating a leading slash
- while (dst > bufferPathStart + 1 && dst[-1] == '/') {
+ while (dst > bufferPathStart + 1 && dst[-1] == '/')
dst--;
- }
- while (dst > bufferPathStart && dst[-1] != '/') {
+ while (dst > bufferPathStart && dst[-1] != '/')
dst--;
- }
continue;
}
}
@@ -941,9 +922,9 @@ static int copyPathRemovingDots(char *dst, const char *src, int srcStart, int sr
return dst - bufferPathStart;
}
-static inline bool hasSlashDotOrDotDot(const char *str)
+static inline bool hasSlashDotOrDotDot(const char* str)
{
- const unsigned char *p = reinterpret_cast<const unsigned char *>(str);
+ const unsigned char* p = reinterpret_cast<const unsigned char*>(str);
if (!*p)
return false;
unsigned char pc = *p;
@@ -960,33 +941,36 @@ static inline bool matchLetter(char c, char lowercaseLetter)
return (c | 0x20) == lowercaseLetter;
}
-void KURL::parse(const char *url, const DeprecatedString *originalString)
+void KURL::parse(const String& string)
{
- m_isValid = true;
+ CharBuffer buffer;
+ encodeRelativeString(string, UTF8Encoding(), buffer);
+ parse(buffer.data(), &string);
+}
+void KURL::parse(const char* url, const String* originalString)
+{
if (!url || url[0] == '\0') {
// valid URL must be non-empty
- m_isValid = false;
- urlString = url;
+ m_string = originalString ? *originalString : url;
+ invalidate();
return;
}
if (!isSchemeFirstChar(url[0])) {
// scheme must start with an alphabetic character
- m_isValid = false;
- urlString = url;
+ m_string = originalString ? *originalString : url;
+ invalidate();
return;
}
int schemeEnd = 0;
-
- while (isSchemeChar(url[schemeEnd])) {
+ while (isSchemeChar(url[schemeEnd]))
schemeEnd++;
- }
if (url[schemeEnd] != ':') {
- m_isValid = false;
- urlString = url;
+ m_string = originalString ? *originalString : url;
+ invalidate();
return;
}
@@ -1001,30 +985,42 @@ void KURL::parse(const char *url, const DeprecatedString *originalString)
bool hierarchical = url[schemeEnd + 1] == '/';
+ bool isFile = schemeEnd == 4
+ && matchLetter(url[0], 'f')
+ && matchLetter(url[1], 'i')
+ && matchLetter(url[2], 'l')
+ && matchLetter(url[3], 'e');
+
+ bool isHTTPorHTTPS = matchLetter(url[0], 'h')
+ && matchLetter(url[1], 't')
+ && matchLetter(url[2], 't')
+ && matchLetter(url[3], 'p')
+ && (url[4] == ':' || (matchLetter(url[4], 's') && url[5] == ':'));
+
if (hierarchical && url[schemeEnd + 2] == '/') {
- // part after the scheme must be a net_path, parse the authority section
+ // The part after the scheme is either a net_path or an abs_path whose first path segment is empty.
+ // Attempt to find an authority.
- // FIXME: authority characters may be scanned twice
+ // FIXME: Authority characters may be scanned twice, and it would be nice to be faster.
userStart += 2;
userEnd = userStart;
int colonPos = 0;
while (isUserInfoChar(url[userEnd])) {
- if (url[userEnd] == ':' && colonPos == 0) {
+ if (url[userEnd] == ':' && colonPos == 0)
colonPos = userEnd;
- }
userEnd++;
}
-
+
if (url[userEnd] == '@') {
// actual end of the userinfo, start on the host
if (colonPos != 0) {
passwordEnd = userEnd;
userEnd = colonPos;
passwordStart = colonPos + 1;
- } else {
+ } else
passwordStart = passwordEnd = userEnd;
- }
+
hostStart = passwordEnd + 1;
} else if (url[userEnd] == '[' || isPathSegmentEndChar(url[userEnd])) {
// hit the end of the authority, must have been no user
@@ -1035,8 +1031,8 @@ void KURL::parse(const char *url, const DeprecatedString *originalString)
hostStart = userStart;
} else {
// invalid character
- m_isValid = false;
- urlString = url;
+ m_string = originalString ? *originalString : url;
+ invalidate();
return;
}
@@ -1045,21 +1041,19 @@ void KURL::parse(const char *url, const DeprecatedString *originalString)
// IPV6 IP address
if (url[hostEnd] == '[') {
hostEnd++;
- while (isIPv6Char(url[hostEnd])) {
+ while (isIPv6Char(url[hostEnd]))
hostEnd++;
- }
- if (url[hostEnd] == ']') {
+ if (url[hostEnd] == ']')
hostEnd++;
- } else {
+ else {
// invalid character
- m_isValid = false;
- urlString = url;
+ m_string = originalString ? *originalString : url;
+ invalidate();
return;
}
} else {
- while (isHostnameChar(url[hostEnd])) {
+ while (isHostnameChar(url[hostEnd]))
hostEnd++;
- }
}
if (url[hostEnd] == ':') {
@@ -1067,19 +1061,30 @@ void KURL::parse(const char *url, const DeprecatedString *originalString)
// possible start of port
portEnd = portStart;
- while (isASCIIDigit(url[portEnd])) {
+ while (isASCIIDigit(url[portEnd]))
portEnd++;
- }
- } else {
+ } else
portStart = portEnd = hostEnd;
- }
if (!isPathSegmentEndChar(url[portEnd])) {
// invalid character
- m_isValid = false;
- urlString = url;
+ m_string = originalString ? *originalString : url;
+ invalidate();
return;
}
+
+ if (userStart == portEnd && !isHTTPorHTTPS && !isFile) {
+ // No authority found, which means that this is not a net_path, but rather an abs_path whose first two
+ // path segments are empty. For file, http and https only, an empty authority is allowed.
+ userStart -= 2;
+ userEnd = userStart;
+ passwordStart = userEnd;
+ passwordEnd = passwordStart;
+ hostStart = passwordEnd;
+ hostEnd = hostStart;
+ portStart = hostEnd;
+ portEnd = hostEnd;
+ }
} else {
// the part after the scheme must be an opaque_part or an abs_path
userEnd = userStart;
@@ -1087,56 +1092,26 @@ void KURL::parse(const char *url, const DeprecatedString *originalString)
hostStart = hostEnd = passwordEnd;
portStart = portEnd = hostEnd;
}
-
+
int pathStart = portEnd;
int pathEnd = pathStart;
- int queryStart;
- int queryEnd;
- int fragmentStart;
- int fragmentEnd;
-
- if (!hierarchical) {
- while (url[pathEnd] != '\0' && url[pathEnd] != '?' && url[pathEnd] != '#')
- pathEnd++;
-
- queryStart = pathEnd;
- queryEnd = queryStart;
- if (url[queryStart] == '?') {
- while (url[queryEnd] != '\0' && url[queryEnd] != '#')
- queryEnd++;
- }
-
- fragmentStart = queryEnd;
- fragmentEnd = fragmentStart;
- if (url[fragmentStart] == '#') {
- fragmentStart++;
- fragmentEnd = fragmentStart;
- while (url[fragmentEnd] != '\0')
- fragmentEnd++;
- }
+ while (url[pathEnd] && url[pathEnd] != '?' && url[pathEnd] != '#')
+ pathEnd++;
+
+ int queryStart = pathEnd;
+ int queryEnd = queryStart;
+ if (url[queryStart] == '?') {
+ while (url[queryEnd] && url[queryEnd] != '#')
+ queryEnd++;
}
- else {
- while (url[pathEnd] != '\0' && url[pathEnd] != '?' && url[pathEnd] != '#') {
- pathEnd++;
- }
-
- queryStart = pathEnd;
- queryEnd = queryStart;
- if (url[queryStart] == '?') {
- while (url[queryEnd] != '\0' && url[queryEnd] != '#') {
- queryEnd++;
- }
- }
-
- fragmentStart = queryEnd;
+
+ int fragmentStart = queryEnd;
+ int fragmentEnd = fragmentStart;
+ if (url[fragmentStart] == '#') {
+ fragmentStart++;
fragmentEnd = fragmentStart;
- if (url[fragmentStart] == '#') {
- fragmentStart++;
- fragmentEnd = fragmentStart;
- while (url[fragmentEnd] != '\0') {
- fragmentEnd++;
- }
- }
+ while (url[fragmentEnd])
+ fragmentEnd++;
}
// assemble it all, remembering the real ranges
@@ -1148,18 +1123,9 @@ void KURL::parse(const char *url, const DeprecatedString *originalString)
// copy in the scheme
const char *schemeEndPtr = url + schemeEnd;
- while (strPtr < schemeEndPtr) {
+ while (strPtr < schemeEndPtr)
*p++ = *strPtr++;
- }
- schemeEndPos = p - buffer.data();
-
- // Check if we're http or https.
- bool isHTTPorHTTPS = matchLetter(url[0], 'h')
- && matchLetter(url[1], 't')
- && matchLetter(url[2], 't')
- && matchLetter(url[3], 'p')
- && (url[4] == ':'
- || (matchLetter(url[4], 's') && url[5] == ':'));
+ m_schemeEnd = p - buffer.data();
bool hostIsLocalHost = portEnd - userStart == 9
&& matchLetter(url[userStart], 'l')
@@ -1172,144 +1138,157 @@ void KURL::parse(const char *url, const DeprecatedString *originalString)
&& matchLetter(url[userStart+7], 's')
&& matchLetter(url[userStart+8], 't');
- bool isFile = matchLetter(url[0], 'f')
- && matchLetter(url[1], 'i')
- && matchLetter(url[2], 'l')
- && matchLetter(url[3], 'e')
- && url[4] == ':';
-
// File URLs need a host part unless it is just file:// or file://localhost
- bool degenFilePath = pathStart == pathEnd
- && (hostStart == hostEnd
- || hostIsLocalHost);
-
+ bool degenFilePath = pathStart == pathEnd && (hostStart == hostEnd || hostIsLocalHost);
+
bool haveNonHostAuthorityPart = userStart != userEnd || passwordStart != passwordEnd || portStart != portEnd;
// add ":" after scheme
*p++ = ':';
// if we have at least one authority part or a file URL - add "//" and authority
- if (isFile ? !degenFilePath
- : (haveNonHostAuthorityPart || hostStart != hostEnd)) {
-
-//if ((isFile && !degenFilePath) || haveNonHostAuthorityPart || hostStart != hostEnd) {
-// still adds // for file://localhost, file://
-
-//if (!(isFile && degenFilePath) && (haveNonHostAuthorityPart || hostStart != hostEnd)) {
-//doesn't add // for things like file:///foo
-
+ if (isFile ? !degenFilePath : (haveNonHostAuthorityPart || hostStart != hostEnd)) {
*p++ = '/';
*p++ = '/';
- userStartPos = p - buffer.data();
+ m_userStart = p - buffer.data();
// copy in the user
strPtr = url + userStart;
- const char *userEndPtr = url + userEnd;
- while (strPtr < userEndPtr) {
+ const char* userEndPtr = url + userEnd;
+ while (strPtr < userEndPtr)
*p++ = *strPtr++;
- }
- userEndPos = p - buffer.data();
-
+ m_userEnd = p - buffer.data();
+
// copy in the password
if (passwordEnd != passwordStart) {
*p++ = ':';
strPtr = url + passwordStart;
- const char *passwordEndPtr = url + passwordEnd;
- while (strPtr < passwordEndPtr) {
+ const char* passwordEndPtr = url + passwordEnd;
+ while (strPtr < passwordEndPtr)
*p++ = *strPtr++;
- }
}
- passwordEndPos = p - buffer.data();
-
+ m_passwordEnd = p - buffer.data();
+
// If we had any user info, add "@"
- if (p - buffer.data() != userStartPos) {
+ if (p - buffer.data() != m_userStart)
*p++ = '@';
- }
-
+
// copy in the host, except in the case of a file URL with authority="localhost"
if (!(isFile && hostIsLocalHost && !haveNonHostAuthorityPart)) {
strPtr = url + hostStart;
- const char *hostEndPtr = url + hostEnd;
- while (strPtr < hostEndPtr) {
+ const char* hostEndPtr = url + hostEnd;
+ while (strPtr < hostEndPtr)
*p++ = *strPtr++;
- }
}
- hostEndPos = p - buffer.data();
-
+ m_hostEnd = p - buffer.data();
+
// copy in the port
if (hostEnd != portStart) {
*p++ = ':';
strPtr = url + portStart;
const char *portEndPtr = url + portEnd;
- while (strPtr < portEndPtr) {
+ while (strPtr < portEndPtr)
*p++ = *strPtr++;
- }
}
- portEndPos = p - buffer.data();
- } else {
- userStartPos = userEndPos = passwordEndPos = hostEndPos = portEndPos = p - buffer.data();
- }
+ m_portEnd = p - buffer.data();
+ } else
+ m_userStart = m_userEnd = m_passwordEnd = m_hostEnd = m_portEnd = p - buffer.data();
// For canonicalization, ensure we have a '/' for no path.
// Only do this for http and https.
- if (isHTTPorHTTPS && pathEnd - pathStart == 0) {
+ if (isHTTPorHTTPS && pathEnd - pathStart == 0)
*p++ = '/';
- }
-
+
// add path, escaping bad characters
-
- if (hierarchical && hasSlashDotOrDotDot(url)) {
- Vector<char, 4096> path_buffer(pathEnd - pathStart + 1);
- copyPathRemovingDots(path_buffer.data(), url, pathStart, pathEnd);
- appendEscapingBadChars(p, path_buffer.data(), strlen(path_buffer.data()));
- } else
+ if (!hierarchical || !hasSlashDotOrDotDot(url))
appendEscapingBadChars(p, url + pathStart, pathEnd - pathStart);
+ else {
+ CharBuffer pathBuffer(pathEnd - pathStart + 1);
+ size_t length = copyPathRemovingDots(pathBuffer.data(), url, pathStart, pathEnd);
+ appendEscapingBadChars(p, pathBuffer.data(), length);
+ }
+
+ m_pathEnd = p - buffer.data();
+
+ // Find the position after the last slash in the path, or
+ // the position before the path if there are no slashes in it.
+ int i;
+ for (i = m_pathEnd; i > m_portEnd; --i) {
+ if (buffer[i - 1] == '/')
+ break;
+ }
+ m_pathAfterLastSlash = i;
- pathEndPos = p - buffer.data();
-
-
// add query, escaping bad characters
appendEscapingBadChars(p, url + queryStart, queryEnd - queryStart);
- queryEndPos = p - buffer.data();
-
+ m_queryEnd = p - buffer.data();
+
// add fragment, escaping bad characters
if (fragmentEnd != queryEnd) {
*p++ = '#';
appendEscapingBadChars(p, url + fragmentStart, fragmentEnd - fragmentStart);
}
- fragmentEndPos = p - buffer.data();
+ m_fragmentEnd = p - buffer.data();
+
+ ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
// If we didn't end up actually changing the original string and
- // it started as a DeprecatedString, just reuse it, to avoid extra
- // allocation.
- if (originalString && strncmp(buffer.data(), url, fragmentEndPos) == 0) {
- urlString = *originalString;
- } else
- urlString = DeprecatedString(buffer.data(), fragmentEndPos);
+ // it was already in a String, reuse it to avoid extra allocation.
+ if (originalString && strncmp(buffer.data(), url, m_fragmentEnd) == 0)
+ m_string = *originalString;
+ else
+ m_string = String(buffer.data(), m_fragmentEnd);
- ASSERT(p - buffer.data() <= (int)buffer.size());
+ m_isValid = true;
}
-bool operator==(const KURL &a, const KURL &b)
+bool equalIgnoringRef(const KURL& a, const KURL& b)
{
- return a.urlString == b.urlString;
+ if (a.m_queryEnd != b.m_queryEnd)
+ return false;
+ unsigned queryLength = a.m_queryEnd;
+ for (unsigned i = 0; i < queryLength; ++i)
+ if (a.string()[i] != b.string()[i])
+ return false;
+ return true;
}
-bool equalIgnoringRef(const KURL& a, const KURL& b)
+bool protocolHostAndPortAreEqual(const KURL& a, const KURL& b)
{
- return a.urlString.left(a.queryEndPos) == b.urlString.left(b.queryEndPos);
+ if (a.m_schemeEnd != b.m_schemeEnd)
+ return false;
+ int hostStartA = a.hostStart();
+ int hostStartB = b.hostStart();
+ if (a.m_hostEnd - hostStartA != b.m_hostEnd - hostStartB)
+ return false;
+
+ // Check the scheme
+ for (int i = 0; i < a.m_schemeEnd; ++i)
+ if (a.string()[i] != b.string()[i])
+ return false;
+
+ // And the host
+ for (int i = hostStartA; i < a.m_hostEnd; ++i)
+ if (a.string()[i] != b.string()[i])
+ return false;
+
+ if (a.port() != b.port())
+ return false;
+
+ return true;
}
+
-DeprecatedString KURL::encode_string(const DeprecatedString& notEncodedString)
+String encodeWithURLEscapeSequences(const String& notEncodedString)
{
- DeprecatedCString asUTF8 = notEncodedString.utf8();
-
- Vector<char, 4096> buffer(asUTF8.length() * 3 + 1);
- char *p = buffer.data();
+ CString asUTF8 = notEncodedString.utf8();
+
+ CharBuffer buffer(asUTF8.length() * 3 + 1);
+ char* p = buffer.data();
- const char *str = asUTF8;
- const char *strEnd = str + asUTF8.length();
+ const char* str = asUTF8.data();
+ const char* strEnd = str + asUTF8.length();
while (str < strEnd) {
unsigned char c = *str++;
if (isBadChar(c)) {
@@ -1319,96 +1298,94 @@ DeprecatedString KURL::encode_string(const DeprecatedString& notEncodedString)
} else
*p++ = c;
}
-
- DeprecatedString result(buffer.data(), p - buffer.data());
-
- ASSERT(p - buffer.data() <= (int)buffer.size());
- return result;
+ ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
+
+ return String(buffer.data(), p - buffer.data());
}
-static DeprecatedString encodeHostname(const DeprecatedString &s)
+// Appends the punycoded hostname identified by the given string and length to
+// the output buffer. The result will not be null terminated.
+static void appendEncodedHostname(UCharBuffer& buffer, const UChar* str, unsigned strLen)
{
// Needs to be big enough to hold an IDN-encoded name.
// For host names bigger than this, we won't do IDN encoding, which is almost certainly OK.
const unsigned hostnameBufferLength = 2048;
- if (s.isAllASCII() || s.length() > hostnameBufferLength)
- return s;
+ if (strLen > hostnameBufferLength || charactersAreAllASCII(str, strLen)) {
+ buffer.append(str, strLen);
+ return;
+ }
#if USE(ICU_UNICODE)
- UChar buffer[hostnameBufferLength];
+ UChar hostnameBuffer[hostnameBufferLength];
UErrorCode error = U_ZERO_ERROR;
- int32_t numCharactersConverted = uidna_IDNToASCII
- (reinterpret_cast<const UChar *>(s.unicode()), s.length(), buffer, hostnameBufferLength, UIDNA_ALLOW_UNASSIGNED, 0, &error);
- if (error != U_ZERO_ERROR) {
- return s;
- }
- return DeprecatedString(reinterpret_cast<DeprecatedChar *>(buffer), numCharactersConverted);
+ int32_t numCharactersConverted = uidna_IDNToASCII(str, strLen, hostnameBuffer,
+ hostnameBufferLength, UIDNA_ALLOW_UNASSIGNED, 0, &error);
+ if (error == U_ZERO_ERROR)
+ buffer.append(hostnameBuffer, numCharactersConverted);
#elif USE(QT4_UNICODE)
- QByteArray result = QUrl::toAce(s);
- return DeprecatedString(result.constData(), result.length());
+ QByteArray result = QUrl::toAce(String(str, strLen));
+ buffer.append(result.constData(), result.length());
#endif
}
-static Vector<pair<int, int> > findHostnamesInMailToURL(const DeprecatedString &s)
+static void findHostnamesInMailToURL(const UChar* str, int strLen, Vector<pair<int, int> >& nameRanges)
{
// In a mailto: URL, host names come after a '@' character and end with a '>' or ',' or '?' or end of string character.
// Skip quoted strings so that characters in them don't confuse us.
// When we find a '?' character, we are past the part of the URL that contains host names.
- Vector<pair<int, int> > a;
+ nameRanges.clear();
int p = 0;
while (1) {
// Find start of host name or of quoted string.
- int hostnameOrStringStart = s.find(RegularExpression("[\"@?]"), p);
- if (hostnameOrStringStart == -1) {
- return a;
- }
- DeprecatedChar c = s[hostnameOrStringStart];
+ int hostnameOrStringStart = findFirstOf(str, strLen, p, "\"@?");
+ if (hostnameOrStringStart == -1)
+ return;
+ UChar c = str[hostnameOrStringStart];
p = hostnameOrStringStart + 1;
- if (c == '?') {
- return a;
- }
-
+ if (c == '?')
+ return;
+
if (c == '@') {
// Find end of host name.
int hostnameStart = p;
- int hostnameEnd = s.find(RegularExpression("[>,?]"), p);
+ int hostnameEnd = findFirstOf(str, strLen, p, ">,?");
bool done;
if (hostnameEnd == -1) {
- hostnameEnd = s.length();
+ hostnameEnd = strLen;
done = true;
} else {
p = hostnameEnd;
done = false;
}
- a.append(make_pair(hostnameStart, hostnameEnd));
+ nameRanges.append(make_pair(hostnameStart, hostnameEnd));
if (done)
- return a;
+ return;
} else {
// Skip quoted string.
ASSERT(c == '"');
while (1) {
- int escapedCharacterOrStringEnd = s.find(RegularExpression("[\"\\]"), p);
+ int escapedCharacterOrStringEnd = findFirstOf(str, strLen, p, "\"\\");
if (escapedCharacterOrStringEnd == -1)
- return a;
+ return;
- c = s[escapedCharacterOrStringEnd];
+ c = str[escapedCharacterOrStringEnd];
p = escapedCharacterOrStringEnd + 1;
-
+
// If we are the end of the string, then break from the string loop back to the host name loop.
if (c == '"')
break;
-
+
// Skip escaped character.
ASSERT(c == '\\');
- if (p == static_cast<int>(s.length()))
- return a;
+ if (p == strLen)
+ return;
++p;
}
@@ -1416,158 +1393,184 @@ static Vector<pair<int, int> > findHostnamesInMailToURL(const DeprecatedString &
}
}
-static bool findHostnameInHierarchicalURL(const DeprecatedString &s, int &startOffset, int &endOffset)
+static bool findHostnameInHierarchicalURL(const UChar* str, int strLen, int& startOffset, int& endOffset)
{
// Find the host name in a hierarchical URL.
- // It comes after a "://" sequence, with scheme characters preceding.
- // If ends with the end of the string or a ":" or a path segment ending character.
+ // It comes after a "://" sequence, with scheme characters preceding, and
+ // this should be the first colon in the string.
+ // It ends with the end of the string or a ":" or a path segment ending character.
// If there is a "@" character, the host part is just the part after the "@".
- int separator = s.find("://");
- if (separator <= 0) {
+ int separator = findFirstOf(str, strLen, 0, ":");
+ if (separator == -1 || separator + 2 >= strLen ||
+ str[separator + 1] != '/' || str[separator + 2] != '/')
return false;
- }
// Check that all characters before the :// are valid scheme characters.
- if (!isSchemeFirstChar(s[0].latin1())) {
+ if (!isSchemeFirstChar(str[0]))
return false;
- }
for (int i = 1; i < separator; ++i) {
- if (!isSchemeChar(s[i].latin1())) {
+ if (!isSchemeChar(str[i]))
return false;
- }
}
// Start after the separator.
int authorityStart = separator + 3;
// Find terminating character.
- int length = s.length();
- int hostnameEnd = length;
- for (int i = authorityStart; i < length; ++i) {
- char c = s[i].latin1();
- if (c == ':' || (isPathSegmentEndChar(c) && c != '\0')) {
+ int hostnameEnd = strLen;
+ for (int i = authorityStart; i < strLen; ++i) {
+ UChar c = str[i];
+ if (c == ':' || (isPathSegmentEndChar(c) && c != 0)) {
hostnameEnd = i;
break;
}
}
// Find "@" for the start of the host name.
- int userInfoTerminator = s.find('@', authorityStart);
+ int userInfoTerminator = findFirstOf(str, strLen, authorityStart, "@");
int hostnameStart;
- if (userInfoTerminator == -1 || userInfoTerminator > hostnameEnd) {
+ if (userInfoTerminator == -1 || userInfoTerminator > hostnameEnd)
hostnameStart = authorityStart;
- } else {
+ else
hostnameStart = userInfoTerminator + 1;
- }
startOffset = hostnameStart;
endOffset = hostnameEnd;
return true;
}
-static DeprecatedString encodeHostnames(const DeprecatedString &s)
+// Converts all hostnames found in the given input to punycode, preserving the
+// rest of the URL unchanged. The output will NOT be null-terminated.
+static void encodeHostnames(const String& str, UCharBuffer& output)
{
- if (s.startsWith("mailto:", false)) {
- const Vector<pair<int, int> > hostnameRanges = findHostnamesInMailToURL(s);
+ output.clear();
+
+ if (protocolIs(str, "mailto")) {
+ Vector<pair<int, int> > hostnameRanges;
+ findHostnamesInMailToURL(str.characters(), str.length(), hostnameRanges);
int n = hostnameRanges.size();
- if (n != 0) {
- DeprecatedString result;
- unsigned p = 0;
- for (int i = 0; i < n; ++i) {
- const pair<int, int> &r = hostnameRanges[i];
- result += s.mid(p, r.first);
- result += encodeHostname(s.mid(r.first, r.second - r.first));
- p = r.second;
- }
- result += s.mid(p);
- return result;
+ int p = 0;
+ for (int i = 0; i < n; ++i) {
+ const pair<int, int>& r = hostnameRanges[i];
+ output.append(&str.characters()[p], r.first - p);
+ appendEncodedHostname(output, &str.characters()[r.first], r.second - r.first);
+ p = r.second;
}
+ // This will copy either everything after the last hostname, or the
+ // whole thing if there is no hostname.
+ output.append(&str.characters()[p], str.length() - p);
} else {
int hostStart, hostEnd;
- if (findHostnameInHierarchicalURL(s, hostStart, hostEnd)) {
- return s.left(hostStart) + encodeHostname(s.mid(hostStart, hostEnd - hostStart)) + s.mid(hostEnd);
+ if (findHostnameInHierarchicalURL(str.characters(), str.length(), hostStart, hostEnd)) {
+ output.append(str.characters(), hostStart); // Before hostname.
+ appendEncodedHostname(output, &str.characters()[hostStart], hostEnd - hostStart);
+ output.append(&str.characters()[hostEnd], str.length() - hostEnd); // After hostname.
+ } else {
+ // No hostname to encode, return the input.
+ output.append(str.characters(), str.length());
}
}
- return s;
}
-static char *encodeRelativeString(const KURL &base, const DeprecatedString &rel, const TextEncoding& encoding)
+static void encodeRelativeString(const String& rel, const TextEncoding& encoding, CharBuffer& output)
{
- DeprecatedString s = encodeHostnames(rel);
+ UCharBuffer s;
+ encodeHostnames(rel, s);
- char *strBuffer;
+ TextEncoding pathEncoding(UTF8Encoding()); // Path is always encoded as UTF-8; other parts may depend on the scheme.
- TextEncoding pathEncoding(UTF8Encoding());
- TextEncoding otherEncoding = (encoding.isValid() && !rel.startsWith("mailto:", false)) ? encoding : UTF8Encoding();
-
int pathEnd = -1;
- if (pathEncoding != otherEncoding) {
- pathEnd = s.find(RegularExpression("[?#]"));
+ if (encoding != pathEncoding && encoding.isValid() && !protocolIs(rel, "mailto") && !protocolIs(rel, "data")) {
+ // Find the first instance of either # or ?, keep pathEnd at -1 otherwise.
+ pathEnd = findFirstOf(s.data(), s.size(), 0, "#?");
}
+
if (pathEnd == -1) {
- CString decoded = pathEncoding.encode(reinterpret_cast<const UChar*>(s.unicode()), s.length());
- int decodedLength = decoded.length();
- strBuffer = static_cast<char *>(fastMalloc(decodedLength + 1));
- memcpy(strBuffer, decoded.data(), decodedLength);
- strBuffer[decodedLength] = 0;
+ CString decoded = pathEncoding.encode(s.data(), s.size(), URLEncodedEntitiesForUnencodables);
+ output.resize(decoded.length());
+ memcpy(output.data(), decoded.data(), decoded.length());
} else {
- int length = s.length();
- CString pathDecoded = pathEncoding.encode(reinterpret_cast<const UChar*>(s.unicode()), pathEnd);
- CString otherDecoded = otherEncoding.encode(reinterpret_cast<const UChar*>(s.unicode()) + pathEnd, length - pathEnd);
- int pathDecodedLength = pathDecoded.length();
- int otherDecodedLength = otherDecoded.length();
- strBuffer = static_cast<char *>(fastMalloc(pathDecodedLength + otherDecodedLength + 1));
- memcpy(strBuffer, pathDecoded.data(), pathDecodedLength);
- memcpy(strBuffer + pathDecodedLength, otherDecoded.data(), otherDecodedLength);
- strBuffer[pathDecodedLength + otherDecodedLength] = 0;
+ CString pathDecoded = pathEncoding.encode(s.data(), pathEnd, URLEncodedEntitiesForUnencodables);
+ // Unencodable characters in URLs are represented by converting
+ // them to XML entities and escaping non-alphanumeric characters.
+ CString otherDecoded = encoding.encode(s.data() + pathEnd, s.size() - pathEnd, URLEncodedEntitiesForUnencodables);
+
+ output.resize(pathDecoded.length() + otherDecoded.length());
+ memcpy(output.data(), pathDecoded.data(), pathDecoded.length());
+ memcpy(output.data() + pathDecoded.length(), otherDecoded.data(), otherDecoded.length());
}
-
- return strBuffer;
+ output.append('\0'); // null-terminate the output.
}
-static DeprecatedString substituteBackslashes(const DeprecatedString &string)
+static String substituteBackslashes(const String& string)
{
int questionPos = string.find('?');
int hashPos = string.find('#');
- unsigned pathEnd;
-
- if (hashPos >= 0 && (questionPos < 0 || questionPos > hashPos)) {
+ int pathEnd;
+
+ if (hashPos >= 0 && (questionPos < 0 || questionPos > hashPos))
pathEnd = hashPos;
- } else if (questionPos >= 0) {
+ else if (questionPos >= 0)
pathEnd = questionPos;
- } else {
+ else
pathEnd = string.length();
- }
- return string.left(pathEnd).replace('\\','/') + string.mid(pathEnd);
+ return string.left(pathEnd).replace('\\','/') + string.substring(pathEnd);
}
bool KURL::isHierarchical() const
{
if (!m_isValid)
return false;
- ASSERT(urlString[schemeEndPos] == ':');
- return urlString[schemeEndPos + 1] == '/';
+ ASSERT(m_string[m_schemeEnd] == ':');
+ return m_string[m_schemeEnd + 1] == '/';
+}
+
+void KURL::copyToBuffer(CharBuffer& buffer) const
+{
+ // FIXME: This throws away the high bytes of all the characters in the string!
+ // That's fine for a valid URL, which is all ASCII, but not for invalid URLs.
+ buffer.resize(m_string.length());
+ copyASCII(m_string.characters(), m_string.length(), buffer.data());
}
-#ifdef ANDROID_JAVASCRIPT_SECURITY
bool protocolIs(const String& url, const char* protocol)
{
+ // Do the comparison without making a new string object.
assertProtocolIsGood(protocol);
- String stripped = url.stripWhiteSpace();
for (int i = 0; ; ++i) {
if (!protocol[i])
- return stripped[i] == ':';
- if (toASCIILower(stripped[i]) != protocol[i])
+ return url[i] == ':';
+ if (toASCIILower(url[i]) != protocol[i])
return false;
}
}
-#endif
+
+String mimeTypeFromDataURL(const String& url)
+{
+ ASSERT(protocolIs(url, "data"));
+ int index = url.find(';');
+ if (index == -1)
+ index = url.find(',');
+ if (index != -1) {
+ int len = index - 5;
+ if (len > 0)
+ return url.substring(5, len);
+ return "text/plain"; // Data URLs with no MIME type are considered text/plain.
+ }
+ return "";
+}
+
+const KURL& blankURL()
+{
+ static KURL staticBlankURL("about:blank");
+ return staticBlankURL;
+}
#ifndef NDEBUG
void KURL::print() const
{
- printf("%s\n", urlString.ascii());
+ printf("%s\n", m_string.utf8().data());
}
#endif
generated by cgit v1.1 at 2024-07-15 10:58:04 +0000