Merge V8 5.3.332.45. DO NOT MERGE
Test: Manual
FPIIM-449
Change-Id: Id3254828b068abdea3cb10442e0172a8c9a98e03
(cherry picked from commit 13e2dadd00298019ed862f2b2fc5068bba730bcf)
diff --git a/src/uri.cc b/src/uri.cc
index c459be5..0107721 100644
--- a/src/uri.cc
+++ b/src/uri.cc
@@ -8,10 +8,197 @@
#include "src/handles.h"
#include "src/isolate-inl.h"
#include "src/list.h"
+#include "src/string-search.h"
namespace v8 {
namespace internal {
+namespace { // anonymous namespace for DecodeURI helper functions
+bool IsReservedPredicate(uc16 c) {
+ switch (c) {
+ case '#':
+ case '$':
+ case '&':
+ case '+':
+ case ',':
+ case '/':
+ case ':':
+ case ';':
+ case '=':
+ case '?':
+ case '@':
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool IsReplacementCharacter(const uint8_t* octets, int length) {
+ // The replacement character is at codepoint U+FFFD in the Unicode Specials
+ // table. Its UTF-8 encoding is 0xEF 0xBF 0xBD.
+ if (length != 3 || octets[0] != 0xef || octets[1] != 0xbf ||
+ octets[2] != 0xbd) {
+ return false;
+ }
+ return true;
+}
+
+bool DecodeOctets(const uint8_t* octets, int length, List<uc16>* buffer) {
+ size_t cursor = 0;
+ uc32 value = unibrow::Utf8::ValueOf(octets, length, &cursor);
+ if (value == unibrow::Utf8::kBadChar &&
+ !IsReplacementCharacter(octets, length)) {
+ return false;
+ }
+
+ if (value <= unibrow::Utf16::kMaxNonSurrogateCharCode) {
+ buffer->Add(value);
+ } else {
+ buffer->Add(unibrow::Utf16::LeadSurrogate(value));
+ buffer->Add(unibrow::Utf16::TrailSurrogate(value));
+ }
+ return true;
+}
+
+int TwoDigitHex(uc16 character1, uc16 character2) {
+ if (character1 > 'f') return -1;
+ int high = HexValue(character1);
+ if (high == -1) return -1;
+ if (character2 > 'f') return -1;
+ int low = HexValue(character2);
+ if (low == -1) return -1;
+ return (high << 4) + low;
+}
+
+template <typename T>
+void AddToBuffer(uc16 decoded, String::FlatContent* uri_content, int index,
+ bool is_uri, List<T>* buffer) {
+ if (is_uri && IsReservedPredicate(decoded)) {
+ buffer->Add('%');
+ uc16 first = uri_content->Get(index + 1);
+ uc16 second = uri_content->Get(index + 2);
+ DCHECK_GT(std::numeric_limits<T>::max(), first);
+ DCHECK_GT(std::numeric_limits<T>::max(), second);
+
+ buffer->Add(first);
+ buffer->Add(second);
+ } else {
+ buffer->Add(decoded);
+ }
+}
+
+bool IntoTwoByte(int index, bool is_uri, int uri_length,
+ String::FlatContent* uri_content, List<uc16>* buffer) {
+ for (int k = index; k < uri_length; k++) {
+ uc16 code = uri_content->Get(k);
+ if (code == '%') {
+ uc16 decoded;
+ if (k + 2 >= uri_length ||
+ (decoded = TwoDigitHex(uri_content->Get(k + 1),
+ uri_content->Get(k + 2))) < 0) {
+ return false;
+ }
+ k += 2;
+ if (decoded > unibrow::Utf8::kMaxOneByteChar) {
+ uint8_t octets[unibrow::Utf8::kMaxEncodedSize];
+ octets[0] = decoded;
+
+ int number_of_continuation_bytes = 0;
+ while ((decoded << ++number_of_continuation_bytes) & 0x80) {
+ if (number_of_continuation_bytes > 3 || k + 3 >= uri_length) {
+ return false;
+ }
+
+ uc16 continuation_byte;
+
+ if (uri_content->Get(++k) != '%' ||
+ (continuation_byte = TwoDigitHex(uri_content->Get(k + 1),
+ uri_content->Get(k + 2))) < 0) {
+ return false;
+ }
+ k += 2;
+ octets[number_of_continuation_bytes] = continuation_byte;
+ }
+
+ if (!DecodeOctets(octets, number_of_continuation_bytes, buffer)) {
+ return false;
+ }
+ } else {
+ AddToBuffer(decoded, uri_content, k - 2, is_uri, buffer);
+ }
+ } else {
+ buffer->Add(code);
+ }
+ }
+ return true;
+}
+
+bool IntoOneAndTwoByte(Handle<String> uri, bool is_uri,
+ List<uint8_t>* one_byte_buffer,
+ List<uc16>* two_byte_buffer) {
+ DisallowHeapAllocation no_gc;
+ String::FlatContent uri_content = uri->GetFlatContent();
+
+ int uri_length = uri->length();
+ for (int k = 0; k < uri_length; k++) {
+ uc16 code = uri_content.Get(k);
+ if (code == '%') {
+ uc16 decoded;
+ if (k + 2 >= uri_length ||
+ (decoded = TwoDigitHex(uri_content.Get(k + 1),
+ uri_content.Get(k + 2))) < 0) {
+ return false;
+ }
+
+ if (decoded > unibrow::Utf8::kMaxOneByteChar) {
+ return IntoTwoByte(k, is_uri, uri_length, &uri_content,
+ two_byte_buffer);
+ }
+
+ AddToBuffer(decoded, &uri_content, k, is_uri, one_byte_buffer);
+ k += 2;
+ } else {
+ if (code > unibrow::Utf8::kMaxOneByteChar) {
+ return IntoTwoByte(k, is_uri, uri_length, &uri_content,
+ two_byte_buffer);
+ }
+ one_byte_buffer->Add(code);
+ }
+ }
+ return true;
+}
+
+} // anonymous namespace
+
+MaybeHandle<String> Uri::Decode(Isolate* isolate, Handle<String> uri,
+ bool is_uri) {
+ uri = String::Flatten(uri);
+ List<uint8_t> one_byte_buffer;
+ List<uc16> two_byte_buffer;
+
+ if (!IntoOneAndTwoByte(uri, is_uri, &one_byte_buffer, &two_byte_buffer)) {
+ THROW_NEW_ERROR(isolate, NewURIError(), String);
+ }
+
+ if (two_byte_buffer.is_empty()) {
+ return isolate->factory()->NewStringFromOneByte(
+ one_byte_buffer.ToConstVector());
+ }
+
+ Handle<SeqTwoByteString> result;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, result, isolate->factory()->NewRawTwoByteString(
+ one_byte_buffer.length() + two_byte_buffer.length()),
+ String);
+
+ CopyChars(result->GetChars(), one_byte_buffer.ToConstVector().start(),
+ one_byte_buffer.length());
+ CopyChars(result->GetChars() + one_byte_buffer.length(),
+ two_byte_buffer.ToConstVector().start(), two_byte_buffer.length());
+
+ return result;
+}
+
namespace { // anonymous namespace for EncodeURI helper functions
bool IsUnescapePredicateInUriComponent(uc16 c) {
if (IsAlphaNumeric(c)) {
@@ -53,43 +240,36 @@
}
}
-void AddHexEncodedToBuffer(uint8_t octet, List<uint8_t>* buffer) {
+void AddEncodedOctetToBuffer(uint8_t octet, List<uint8_t>* buffer) {
buffer->Add('%');
buffer->Add(HexCharOfValue(octet >> 4));
buffer->Add(HexCharOfValue(octet & 0x0F));
}
void EncodeSingle(uc16 c, List<uint8_t>* buffer) {
- uint8_t x = (c >> 12) & 0xF;
- uint8_t y = (c >> 6) & 63;
- uint8_t z = c & 63;
- if (c <= 0x007F) {
- AddHexEncodedToBuffer(c, buffer);
- } else if (c <= 0x07FF) {
- AddHexEncodedToBuffer(y + 192, buffer);
- AddHexEncodedToBuffer(z + 128, buffer);
- } else {
- AddHexEncodedToBuffer(x + 224, buffer);
- AddHexEncodedToBuffer(y + 128, buffer);
- AddHexEncodedToBuffer(z + 128, buffer);
+ char s[4] = {};
+ int number_of_bytes;
+ number_of_bytes =
+ unibrow::Utf8::Encode(s, c, unibrow::Utf16::kNoPreviousCharacter, false);
+ for (int k = 0; k < number_of_bytes; k++) {
+ AddEncodedOctetToBuffer(s[k], buffer);
}
}
void EncodePair(uc16 cc1, uc16 cc2, List<uint8_t>* buffer) {
- uint8_t u = ((cc1 >> 6) & 0xF) + 1;
- uint8_t w = (cc1 >> 2) & 0xF;
- uint8_t x = cc1 & 3;
- uint8_t y = (cc2 >> 6) & 0xF;
- uint8_t z = cc2 & 63;
- AddHexEncodedToBuffer((u >> 2) + 240, buffer);
- AddHexEncodedToBuffer((((u & 3) << 4) | w) + 128, buffer);
- AddHexEncodedToBuffer(((x << 4) | y) + 128, buffer);
- AddHexEncodedToBuffer(z + 128, buffer);
+ char s[4] = {};
+ int number_of_bytes =
+ unibrow::Utf8::Encode(s, unibrow::Utf16::CombineSurrogatePair(cc1, cc2),
+ unibrow::Utf16::kNoPreviousCharacter, false);
+ for (int k = 0; k < number_of_bytes; k++) {
+ AddEncodedOctetToBuffer(s[k], buffer);
+ }
}
} // anonymous namespace
-Object* Uri::Encode(Isolate* isolate, Handle<String> uri, bool is_uri) {
+MaybeHandle<String> Uri::Encode(Isolate* isolate, Handle<String> uri,
+ bool is_uri) {
uri = String::Flatten(uri);
int uri_length = uri->length();
List<uint8_t> buffer(uri_length);
@@ -120,15 +300,205 @@
}
AllowHeapAllocation allocate_error_and_return;
- THROW_NEW_ERROR_RETURN_FAILURE(isolate, NewURIError());
+ THROW_NEW_ERROR(isolate, NewURIError(), String);
}
}
+ return isolate->factory()->NewStringFromOneByte(buffer.ToConstVector());
+}
+
+namespace { // Anonymous namespace for Escape and Unescape
+
+template <typename Char>
+int UnescapeChar(Vector<const Char> vector, int i, int length, int* step) {
+ uint16_t character = vector[i];
+ int32_t hi = 0;
+ int32_t lo = 0;
+ if (character == '%' && i <= length - 6 && vector[i + 1] == 'u' &&
+ (hi = TwoDigitHex(vector[i + 2], vector[i + 3])) > -1 &&
+ (lo = TwoDigitHex(vector[i + 4], vector[i + 5])) > -1) {
+ *step = 6;
+ return (hi << 8) + lo;
+ } else if (character == '%' && i <= length - 3 &&
+ (lo = TwoDigitHex(vector[i + 1], vector[i + 2])) > -1) {
+ *step = 3;
+ return lo;
+ } else {
+ *step = 1;
+ return character;
+ }
+}
+
+template <typename Char>
+MaybeHandle<String> UnescapeSlow(Isolate* isolate, Handle<String> string,
+ int start_index) {
+ bool one_byte = true;
+ int length = string->length();
+
+ int unescaped_length = 0;
+ {
+ DisallowHeapAllocation no_allocation;
+ Vector<const Char> vector = string->GetCharVector<Char>();
+ for (int i = start_index; i < length; unescaped_length++) {
+ int step;
+ if (UnescapeChar(vector, i, length, &step) >
+ String::kMaxOneByteCharCode) {
+ one_byte = false;
+ }
+ i += step;
+ }
+ }
+
+ DCHECK(start_index < length);
+ Handle<String> first_part =
+ isolate->factory()->NewProperSubString(string, 0, start_index);
+
+ int dest_position = 0;
+ Handle<String> second_part;
+ DCHECK(unescaped_length <= String::kMaxLength);
+ if (one_byte) {
+ Handle<SeqOneByteString> dest = isolate->factory()
+ ->NewRawOneByteString(unescaped_length)
+ .ToHandleChecked();
+ DisallowHeapAllocation no_allocation;
+ Vector<const Char> vector = string->GetCharVector<Char>();
+ for (int i = start_index; i < length; dest_position++) {
+ int step;
+ dest->SeqOneByteStringSet(dest_position,
+ UnescapeChar(vector, i, length, &step));
+ i += step;
+ }
+ second_part = dest;
+ } else {
+ Handle<SeqTwoByteString> dest = isolate->factory()
+ ->NewRawTwoByteString(unescaped_length)
+ .ToHandleChecked();
+ DisallowHeapAllocation no_allocation;
+ Vector<const Char> vector = string->GetCharVector<Char>();
+ for (int i = start_index; i < length; dest_position++) {
+ int step;
+ dest->SeqTwoByteStringSet(dest_position,
+ UnescapeChar(vector, i, length, &step));
+ i += step;
+ }
+ second_part = dest;
+ }
+ return isolate->factory()->NewConsString(first_part, second_part);
+}
+
+bool IsNotEscaped(uint16_t c) {
+ if (IsAlphaNumeric(c)) {
+ return true;
+ }
+ // @*_+-./
+ switch (c) {
+ case '@':
+ case '*':
+ case '_':
+ case '+':
+ case '-':
+ case '.':
+ case '/':
+ return true;
+ default:
+ return false;
+ }
+}
+
+template <typename Char>
+static MaybeHandle<String> UnescapePrivate(Isolate* isolate,
+ Handle<String> source) {
+ int index;
+ {
+ DisallowHeapAllocation no_allocation;
+ StringSearch<uint8_t, Char> search(isolate, STATIC_CHAR_VECTOR("%"));
+ index = search.Search(source->GetCharVector<Char>(), 0);
+ if (index < 0) return source;
+ }
+ return UnescapeSlow<Char>(isolate, source, index);
+}
+
+template <typename Char>
+static MaybeHandle<String> EscapePrivate(Isolate* isolate,
+ Handle<String> string) {
+ DCHECK(string->IsFlat());
+ int escaped_length = 0;
+ int length = string->length();
+
+ {
+ DisallowHeapAllocation no_allocation;
+ Vector<const Char> vector = string->GetCharVector<Char>();
+ for (int i = 0; i < length; i++) {
+ uint16_t c = vector[i];
+ if (c >= 256) {
+ escaped_length += 6;
+ } else if (IsNotEscaped(c)) {
+ escaped_length++;
+ } else {
+ escaped_length += 3;
+ }
+
+ // We don't allow strings that are longer than a maximal length.
+ DCHECK(String::kMaxLength < 0x7fffffff - 6); // Cannot overflow.
+ if (escaped_length > String::kMaxLength) break; // Provoke exception.
+ }
+ }
+
+ // No length change implies no change. Return original string if no change.
+ if (escaped_length == length) return string;
+
+ Handle<SeqOneByteString> dest;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, dest, isolate->factory()->NewRawOneByteString(escaped_length),
+ String);
+ int dest_position = 0;
+
+ {
+ DisallowHeapAllocation no_allocation;
+ Vector<const Char> vector = string->GetCharVector<Char>();
+ for (int i = 0; i < length; i++) {
+ uint16_t c = vector[i];
+ if (c >= 256) {
+ dest->SeqOneByteStringSet(dest_position, '%');
+ dest->SeqOneByteStringSet(dest_position + 1, 'u');
+ dest->SeqOneByteStringSet(dest_position + 2, HexCharOfValue(c >> 12));
+ dest->SeqOneByteStringSet(dest_position + 3,
+ HexCharOfValue((c >> 8) & 0xf));
+ dest->SeqOneByteStringSet(dest_position + 4,
+ HexCharOfValue((c >> 4) & 0xf));
+ dest->SeqOneByteStringSet(dest_position + 5, HexCharOfValue(c & 0xf));
+ dest_position += 6;
+ } else if (IsNotEscaped(c)) {
+ dest->SeqOneByteStringSet(dest_position, c);
+ dest_position++;
+ } else {
+ dest->SeqOneByteStringSet(dest_position, '%');
+ dest->SeqOneByteStringSet(dest_position + 1, HexCharOfValue(c >> 4));
+ dest->SeqOneByteStringSet(dest_position + 2, HexCharOfValue(c & 0xf));
+ dest_position += 3;
+ }
+ }
+ }
+
+ return dest;
+}
+
+} // Anonymous namespace
+
+MaybeHandle<String> Uri::Escape(Isolate* isolate, Handle<String> string) {
Handle<String> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- isolate->factory()->NewStringFromOneByte(buffer.ToConstVector()));
- return *result;
+ string = String::Flatten(string);
+ return string->IsOneByteRepresentationUnderneath()
+ ? EscapePrivate<uint8_t>(isolate, string)
+ : EscapePrivate<uc16>(isolate, string);
+}
+
+MaybeHandle<String> Uri::Unescape(Isolate* isolate, Handle<String> string) {
+ Handle<String> result;
+ string = String::Flatten(string);
+ return string->IsOneByteRepresentationUnderneath()
+ ? UnescapePrivate<uint8_t>(isolate, string)
+ : UnescapePrivate<uc16>(isolate, string);
}
} // namespace internal