diff options
Diffstat (limited to 'dom/indexedDB/Key.cpp')
| -rw-r--r-- | dom/indexedDB/Key.cpp | 842 |
1 files changed, 842 insertions, 0 deletions
diff --git a/dom/indexedDB/Key.cpp b/dom/indexedDB/Key.cpp new file mode 100644 index 000000000..945320dd5 --- /dev/null +++ b/dom/indexedDB/Key.cpp @@ -0,0 +1,842 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + +#include "Key.h" + +#include <algorithm> +#include "IndexedDatabaseManager.h" +#include "js/Date.h" +#include "js/Value.h" +#include "jsfriendapi.h" +#include "mozilla/Casting.h" +#include "mozilla/EndianUtils.h" +#include "mozilla/FloatingPoint.h" +#include "mozIStorageStatement.h" +#include "mozIStorageValueArray.h" +#include "nsAlgorithm.h" +#include "nsJSUtils.h" +#include "ReportInternalError.h" +#include "xpcpublic.h" + +#ifdef ENABLE_INTL_API +#include "unicode/ucol.h" +#endif + +namespace mozilla { +namespace dom { +namespace indexedDB { + +/* + Here's how we encode keys: + + Basic strategy is the following + + Numbers: 0x10 n n n n n n n n ("n"s are encoded 64bit float) + Dates: 0x20 n n n n n n n n ("n"s are encoded 64bit float) + Strings: 0x30 s s s ... 0 ("s"s are encoded unicode bytes) + Binaries: 0x40 s s s ... 0 ("s"s are encoded unicode bytes) + Arrays: 0x50 i i i ... 0 ("i"s are encoded array items) + + + When encoding floats, 64bit IEEE 754 are almost sortable, except that + positive sort lower than negative, and negative sort descending. So we use + the following encoding: + + value < 0 ? + (-to64bitInt(value)) : + (to64bitInt(value) | 0x8000000000000000) + + + When encoding strings, we use variable-size encoding per the following table + + Chars 0 - 7E are encoded as 0xxxxxxx with 1 added + Chars 7F - (3FFF+7F) are encoded as 10xxxxxx xxxxxxxx with 7F subtracted + Chars (3FFF+80) - FFFF are encoded as 11xxxxxx xxxxxxxx xx000000 + + This ensures that the first byte is never encoded as 0, which means that the + string terminator (per basic-stategy table) sorts before any character. + The reason that (3FFF+80) - FFFF is encoded "shifted up" 6 bits is to maximize + the chance that the last character is 0. See below for why. + + When encoding binaries, the algorithm is the same to how strings are encoded. + Since each octet in binary is in the range of [0-255], it'll take 1 to 2 encoded + unicode bytes. + + When encoding Arrays, we use an additional trick. Rather than adding a byte + containing the value 0x50 to indicate type, we instead add 0x50 to the next byte. + This is usually the byte containing the type of the first item in the array. + So simple examples are + + ["foo"] 0x80 s s s 0 0 // 0x80 is 0x30 + 0x50 + [1, 2] 0x60 n n n n n n n n 1 n n n n n n n n 0 // 0x60 is 0x10 + 0x50 + + Whe do this iteratively if the first item in the array is also an array + + [["foo"]] 0xA0 s s s 0 0 0 + + However, to avoid overflow in the byte, we only do this 3 times. If the first + item in an array is an array, and that array also has an array as first item, + we simply write out the total value accumulated so far and then follow the + "normal" rules. + + [[["foo"]]] 0xF0 0x30 s s s 0 0 0 0 + + There is another edge case that can happen though, which is that the array + doesn't have a first item to which we can add 0x50 to the type. Instead the + next byte would normally be the array terminator (per basic-strategy table) + so we simply add the 0x50 there. + + [[]] 0xA0 0 // 0xA0 is 0x50 + 0x50 + 0 + [] 0x50 // 0x50 is 0x50 + 0 + [[], "foo"] 0xA0 0x30 s s s 0 0 // 0xA0 is 0x50 + 0x50 + 0 + + Note that the max-3-times rule kicks in before we get a chance to add to the + array terminator + + [[[]]] 0xF0 0 0 0 // 0xF0 is 0x50 + 0x50 + 0x50 + + As a final optimization we do a post-encoding step which drops all 0s at the + end of the encoded buffer. + + "foo" // 0x30 s s s + 1 // 0x10 bf f0 + ["a", "b"] // 0x80 s 0 0x30 s + [1, 2] // 0x60 bf f0 0 0 0 0 0 0 0x10 c0 + [[]] // 0x80 +*/ +#ifdef ENABLE_INTL_API +nsresult +Key::ToLocaleBasedKey(Key& aTarget, const nsCString& aLocale) const +{ + if (IsUnset()) { + aTarget.Unset(); + return NS_OK; + } + + if (IsFloat() || IsDate() || IsBinary()) { + aTarget.mBuffer = mBuffer; + return NS_OK; + } + + aTarget.mBuffer.Truncate(); + aTarget.mBuffer.SetCapacity(mBuffer.Length()); + + auto* it = reinterpret_cast<const unsigned char*>(mBuffer.BeginReading()); + auto* end = reinterpret_cast<const unsigned char*>(mBuffer.EndReading()); + + // First we do a pass and see if there are any strings in this key. We only + // want to copy/decode when necessary. + bool canShareBuffers = true; + while (it < end) { + auto type = *it % eMaxType; + if (type == eTerminator || type == eArray) { + it++; + } else if (type == eFloat || type == eDate) { + it++; + it += std::min(sizeof(uint64_t), size_t(end - it)); + } else { + // We have a string! + canShareBuffers = false; + break; + } + } + + if (canShareBuffers) { + MOZ_ASSERT(it == end); + aTarget.mBuffer = mBuffer; + return NS_OK; + } + + // A string was found, so we need to copy the data we've read so far + auto* start = reinterpret_cast<const unsigned char*>(mBuffer.BeginReading()); + if (it > start) { + char* buffer; + if (!aTarget.mBuffer.GetMutableData(&buffer, it-start)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + while (start < it) { + *(buffer++) = *(start++); + } + } + + // Now continue decoding + while (it < end) { + char* buffer; + uint32_t oldLen = aTarget.mBuffer.Length(); + auto type = *it % eMaxType; + + if (type == eTerminator || type == eArray) { + // Copy array TypeID and terminator from raw key + if (!aTarget.mBuffer.GetMutableData(&buffer, oldLen + 1)) { + return NS_ERROR_OUT_OF_MEMORY; + } + *(buffer + oldLen) = *(it++); + } else if (type == eFloat || type == eDate) { + // Copy number from raw key + if (!aTarget.mBuffer.GetMutableData(&buffer, + oldLen + 1 + sizeof(uint64_t))) { + return NS_ERROR_OUT_OF_MEMORY; + } + buffer += oldLen; + *(buffer++) = *(it++); + + const size_t byteCount = std::min(sizeof(uint64_t), size_t(end - it)); + for (size_t count = 0; count < byteCount; count++) { + *(buffer++) = (*it++); + } + } else { + // Decode string and reencode + uint8_t typeOffset = *it - eString; + MOZ_ASSERT((typeOffset % eArray == 0) && (typeOffset / eArray <= 2)); + + nsDependentString str; + DecodeString(it, end, str); + aTarget.EncodeLocaleString(str, typeOffset, aLocale); + } + } + aTarget.TrimBuffer(); + return NS_OK; +} +#endif + +nsresult +Key::EncodeJSValInternal(JSContext* aCx, JS::Handle<JS::Value> aVal, + uint8_t aTypeOffset, uint16_t aRecursionDepth) +{ + static_assert(eMaxType * kMaxArrayCollapse < 256, + "Unable to encode jsvals."); + + if (NS_WARN_IF(aRecursionDepth == kMaxRecursionDepth)) { + return NS_ERROR_DOM_INDEXEDDB_DATA_ERR; + } + + if (aVal.isString()) { + nsAutoJSString str; + if (!str.init(aCx, aVal)) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + EncodeString(str, aTypeOffset); + return NS_OK; + } + + if (aVal.isNumber()) { + double d = aVal.toNumber(); + if (mozilla::IsNaN(d)) { + return NS_ERROR_DOM_INDEXEDDB_DATA_ERR; + } + EncodeNumber(d, eFloat + aTypeOffset); + return NS_OK; + } + + if (aVal.isObject()) { + JS::Rooted<JSObject*> obj(aCx, &aVal.toObject()); + + js::ESClass cls; + if (!js::GetBuiltinClass(aCx, obj, &cls)) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + if (cls == js::ESClass::Array) { + aTypeOffset += eMaxType; + + if (aTypeOffset == eMaxType * kMaxArrayCollapse) { + mBuffer.Append(aTypeOffset); + aTypeOffset = 0; + } + NS_ASSERTION((aTypeOffset % eMaxType) == 0 && + aTypeOffset < (eMaxType * kMaxArrayCollapse), + "Wrong typeoffset"); + + uint32_t length; + if (!JS_GetArrayLength(aCx, obj, &length)) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + + for (uint32_t index = 0; index < length; index++) { + JS::Rooted<JS::Value> val(aCx); + if (!JS_GetElement(aCx, obj, index, &val)) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + + nsresult rv = EncodeJSValInternal(aCx, val, aTypeOffset, + aRecursionDepth + 1); + if (NS_FAILED(rv)) { + return rv; + } + + aTypeOffset = 0; + } + + mBuffer.Append(eTerminator + aTypeOffset); + + return NS_OK; + } + + if (cls == js::ESClass::Date) { + bool valid; + if (!js::DateIsValid(aCx, obj, &valid)) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + if (!valid) { + return NS_ERROR_DOM_INDEXEDDB_DATA_ERR; + } + double t; + if (!js::DateGetMsecSinceEpoch(aCx, obj, &t)) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + EncodeNumber(t, eDate + aTypeOffset); + return NS_OK; + } + + if (JS_IsArrayBufferObject(obj)) { + EncodeBinary(obj, /* aIsViewObject */ false, aTypeOffset); + return NS_OK; + } + + if (JS_IsArrayBufferViewObject(obj)) { + EncodeBinary(obj, /* aIsViewObject */ true, aTypeOffset); + return NS_OK; + } + } + + return NS_ERROR_DOM_INDEXEDDB_DATA_ERR; +} + +// static +nsresult +Key::DecodeJSValInternal(const unsigned char*& aPos, const unsigned char* aEnd, + JSContext* aCx, uint8_t aTypeOffset, JS::MutableHandle<JS::Value> aVal, + uint16_t aRecursionDepth) +{ + if (NS_WARN_IF(aRecursionDepth == kMaxRecursionDepth)) { + return NS_ERROR_DOM_INDEXEDDB_DATA_ERR; + } + + if (*aPos - aTypeOffset >= eArray) { + JS::Rooted<JSObject*> array(aCx, JS_NewArrayObject(aCx, 0)); + if (!array) { + NS_WARNING("Failed to make array!"); + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + + aTypeOffset += eMaxType; + + if (aTypeOffset == eMaxType * kMaxArrayCollapse) { + ++aPos; + aTypeOffset = 0; + } + + uint32_t index = 0; + JS::Rooted<JS::Value> val(aCx); + while (aPos < aEnd && *aPos - aTypeOffset != eTerminator) { + nsresult rv = DecodeJSValInternal(aPos, aEnd, aCx, aTypeOffset, + &val, aRecursionDepth + 1); + NS_ENSURE_SUCCESS(rv, rv); + + aTypeOffset = 0; + + if (!JS_DefineElement(aCx, array, index++, val, JSPROP_ENUMERATE)) { + NS_WARNING("Failed to set array element!"); + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + } + + NS_ASSERTION(aPos >= aEnd || (*aPos % eMaxType) == eTerminator, + "Should have found end-of-array marker"); + ++aPos; + + aVal.setObject(*array); + } + else if (*aPos - aTypeOffset == eString) { + nsString key; + DecodeString(aPos, aEnd, key); + if (!xpc::StringToJsval(aCx, key, aVal)) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + } + else if (*aPos - aTypeOffset == eDate) { + double msec = static_cast<double>(DecodeNumber(aPos, aEnd)); + JS::ClippedTime time = JS::TimeClip(msec); + MOZ_ASSERT(msec == time.toDouble(), + "encoding from a Date object not containing an invalid date " + "means we should always have clipped values"); + JSObject* date = JS::NewDateObject(aCx, time); + if (!date) { + IDB_WARNING("Failed to make date!"); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + + aVal.setObject(*date); + } + else if (*aPos - aTypeOffset == eFloat) { + aVal.setDouble(DecodeNumber(aPos, aEnd)); + } + else if (*aPos - aTypeOffset == eBinary) { + JSObject* binary = DecodeBinary(aPos, aEnd, aCx); + if (!binary) { + IDB_REPORT_INTERNAL_ERR(); + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + + aVal.setObject(*binary); + } + else { + NS_NOTREACHED("Unknown key type!"); + } + + return NS_OK; +} + +#define ONE_BYTE_LIMIT 0x7E +#define TWO_BYTE_LIMIT (0x3FFF+0x7F) + +#define ONE_BYTE_ADJUST 1 +#define TWO_BYTE_ADJUST (-0x7F) +#define THREE_BYTE_SHIFT 6 + +nsresult +Key::EncodeJSVal(JSContext* aCx, + JS::Handle<JS::Value> aVal, + uint8_t aTypeOffset) +{ + return EncodeJSValInternal(aCx, aVal, aTypeOffset, 0); +} + +void +Key::EncodeString(const nsAString& aString, uint8_t aTypeOffset) +{ + const char16_t* start = aString.BeginReading(); + const char16_t* end = aString.EndReading(); + EncodeString(start, end, aTypeOffset); +} + +template <typename T> +void +Key::EncodeString(const T* aStart, const T* aEnd, uint8_t aTypeOffset) +{ + EncodeAsString(aStart, aEnd, eString + aTypeOffset); +} + +template <typename T> +void +Key::EncodeAsString(const T* aStart, const T* aEnd, uint8_t aType) +{ + // First measure how long the encoded string will be. + + // The +2 is for initial 3 and trailing 0. We'll compensate for multi-byte + // chars below. + uint32_t size = (aEnd - aStart) + 2; + + const T* start = aStart; + const T* end = aEnd; + for (const T* iter = start; iter < end; ++iter) { + if (*iter > ONE_BYTE_LIMIT) { + size += char16_t(*iter) > TWO_BYTE_LIMIT ? 2 : 1; + } + } + + // Allocate memory for the new size + uint32_t oldLen = mBuffer.Length(); + char* buffer; + if (!mBuffer.GetMutableData(&buffer, oldLen + size)) { + return; + } + buffer += oldLen; + + // Write type marker + *(buffer++) = aType; + + // Encode string + for (const T* iter = start; iter < end; ++iter) { + if (*iter <= ONE_BYTE_LIMIT) { + *(buffer++) = *iter + ONE_BYTE_ADJUST; + } + else if (char16_t(*iter) <= TWO_BYTE_LIMIT) { + char16_t c = char16_t(*iter) + TWO_BYTE_ADJUST + 0x8000; + *(buffer++) = (char)(c >> 8); + *(buffer++) = (char)(c & 0xFF); + } + else { + uint32_t c = (uint32_t(*iter) << THREE_BYTE_SHIFT) | 0x00C00000; + *(buffer++) = (char)(c >> 16); + *(buffer++) = (char)(c >> 8); + *(buffer++) = (char)c; + } + } + + // Write end marker + *(buffer++) = eTerminator; + + NS_ASSERTION(buffer == mBuffer.EndReading(), "Wrote wrong number of bytes"); +} + +#ifdef ENABLE_INTL_API +nsresult +Key::EncodeLocaleString(const nsDependentString& aString, uint8_t aTypeOffset, + const nsCString& aLocale) +{ + const int length = aString.Length(); + if (length == 0) { + return NS_OK; + } + const UChar* ustr = reinterpret_cast<const UChar*>(aString.BeginReading()); + + UErrorCode uerror = U_ZERO_ERROR; + UCollator* collator = ucol_open(aLocale.get(), &uerror); + if (NS_WARN_IF(U_FAILURE(uerror))) { + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(collator); + + AutoTArray<uint8_t, 128> keyBuffer; + int32_t sortKeyLength = ucol_getSortKey(collator, ustr, length, + keyBuffer.Elements(), + keyBuffer.Length()); + if (sortKeyLength > (int32_t)keyBuffer.Length()) { + keyBuffer.SetLength(sortKeyLength); + sortKeyLength = ucol_getSortKey(collator, ustr, length, + keyBuffer.Elements(), + sortKeyLength); + } + + ucol_close(collator); + if (NS_WARN_IF(sortKeyLength == 0)) { + return NS_ERROR_FAILURE; + } + + EncodeString(keyBuffer.Elements(), + keyBuffer.Elements()+sortKeyLength, + aTypeOffset); + return NS_OK; +} +#endif + +// static +nsresult +Key::DecodeJSVal(const unsigned char*& aPos, + const unsigned char* aEnd, + JSContext* aCx, + JS::MutableHandle<JS::Value> aVal) +{ + return DecodeJSValInternal(aPos, aEnd, aCx, 0, aVal, 0); +} + +// static +void +Key::DecodeString(const unsigned char*& aPos, const unsigned char* aEnd, + nsString& aString) +{ + NS_ASSERTION(*aPos % eMaxType == eString, "Don't call me!"); + + const unsigned char* buffer = aPos + 1; + + // First measure how big the decoded string will be. + uint32_t size = 0; + const unsigned char* iter; + for (iter = buffer; iter < aEnd && *iter != eTerminator; ++iter) { + if (*iter & 0x80) { + iter += (*iter & 0x40) ? 2 : 1; + } + ++size; + } + + // Set end so that we don't have to check for null termination in the loop + // below + if (iter < aEnd) { + aEnd = iter; + } + + char16_t* out; + if (size && !aString.GetMutableData(&out, size)) { + return; + } + + for (iter = buffer; iter < aEnd;) { + if (!(*iter & 0x80)) { + *out = *(iter++) - ONE_BYTE_ADJUST; + } + else if (!(*iter & 0x40)) { + char16_t c = (char16_t(*(iter++)) << 8); + if (iter < aEnd) { + c |= *(iter++); + } + *out = c - TWO_BYTE_ADJUST - 0x8000; + } + else { + uint32_t c = uint32_t(*(iter++)) << (16 - THREE_BYTE_SHIFT); + if (iter < aEnd) { + c |= uint32_t(*(iter++)) << (8 - THREE_BYTE_SHIFT); + } + if (iter < aEnd) { + c |= *(iter++) >> THREE_BYTE_SHIFT; + } + *out = (char16_t)c; + } + + ++out; + } + + NS_ASSERTION(!size || out == aString.EndReading(), + "Should have written the whole string"); + + aPos = iter + 1; +} + +void +Key::EncodeNumber(double aFloat, uint8_t aType) +{ + // Allocate memory for the new size + uint32_t oldLen = mBuffer.Length(); + char* buffer; + if (!mBuffer.GetMutableData(&buffer, oldLen + 1 + sizeof(double))) { + return; + } + buffer += oldLen; + + *(buffer++) = aType; + + uint64_t bits = BitwiseCast<uint64_t>(aFloat); + // Note: The subtraction from 0 below is necessary to fix + // MSVC build warning C4146 (negating an unsigned value). + const uint64_t signbit = FloatingPoint<double>::kSignBit; + uint64_t number = bits & signbit ? (0 - bits) : (bits | signbit); + + mozilla::BigEndian::writeUint64(buffer, number); +} + +// static +double +Key::DecodeNumber(const unsigned char*& aPos, const unsigned char* aEnd) +{ + NS_ASSERTION(*aPos % eMaxType == eFloat || + *aPos % eMaxType == eDate, "Don't call me!"); + + ++aPos; + + uint64_t number = 0; + memcpy(&number, aPos, std::min<size_t>(sizeof(number), aEnd - aPos)); + number = mozilla::NativeEndian::swapFromBigEndian(number); + + aPos += sizeof(number); + + // Note: The subtraction from 0 below is necessary to fix + // MSVC build warning C4146 (negating an unsigned value). + const uint64_t signbit = FloatingPoint<double>::kSignBit; + uint64_t bits = number & signbit ? (number & ~signbit) : (0 - number); + + return BitwiseCast<double>(bits); +} + +void +Key::EncodeBinary(JSObject* aObject, bool aIsViewObject, uint8_t aTypeOffset) +{ + uint8_t* bufferData; + uint32_t bufferLength; + bool unused; + + if (aIsViewObject) { + js::GetArrayBufferViewLengthAndData(aObject, &bufferLength, &unused, &bufferData); + } else { + js::GetArrayBufferLengthAndData(aObject, &bufferLength, &unused, &bufferData); + } + + EncodeAsString(bufferData, bufferData + bufferLength, eBinary + aTypeOffset); +} + +// static +JSObject* +Key::DecodeBinary(const unsigned char*& aPos, + const unsigned char* aEnd, + JSContext* aCx) +{ + MOZ_ASSERT(*aPos % eMaxType == eBinary, "Don't call me!"); + + const unsigned char* buffer = ++aPos; + + // First measure how big the decoded array buffer will be. + size_t size = 0; + const unsigned char* iter; + for (iter = buffer; iter < aEnd && *iter != eTerminator; ++iter) { + if (*iter & 0x80) { + iter++; + } + ++size; + } + + if (!size) { + return JS_NewArrayBuffer(aCx, 0); + } + + uint8_t* out = static_cast<uint8_t*>(JS_malloc(aCx, size)); + if (NS_WARN_IF(!out)) { + return nullptr; + } + + uint8_t* pos = out; + + // Set end so that we don't have to check for null termination in the loop + // below + if (iter < aEnd) { + aEnd = iter; + } + + for (iter = buffer; iter < aEnd;) { + if (!(*iter & 0x80)) { + *pos = *(iter++) - ONE_BYTE_ADJUST; + } + else { + uint16_t c = (uint16_t(*(iter++)) << 8); + if (iter < aEnd) { + c |= *(iter++); + } + *pos = static_cast<uint8_t>(c - TWO_BYTE_ADJUST - 0x8000); + } + + ++pos; + } + + aPos = iter + 1; + + MOZ_ASSERT(static_cast<size_t>(pos - out) == size, + "Should have written the whole buffer"); + + return JS_NewArrayBufferWithContents(aCx, size, out); +} + +nsresult +Key::BindToStatement(mozIStorageStatement* aStatement, + const nsACString& aParamName) const +{ + nsresult rv; + if (IsUnset()) { + rv = aStatement->BindNullByName(aParamName); + } else { + rv = aStatement->BindBlobByName(aParamName, + reinterpret_cast<const uint8_t*>(mBuffer.get()), mBuffer.Length()); + } + + return NS_SUCCEEDED(rv) ? NS_OK : NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; +} + +nsresult +Key::SetFromStatement(mozIStorageStatement* aStatement, + uint32_t aIndex) +{ + return SetFromSource(aStatement, aIndex); +} + +nsresult +Key::SetFromValueArray(mozIStorageValueArray* aValues, + uint32_t aIndex) +{ + return SetFromSource(aValues, aIndex); +} + +nsresult +Key::SetFromJSVal(JSContext* aCx, + JS::Handle<JS::Value> aVal) +{ + mBuffer.Truncate(); + + if (aVal.isNull() || aVal.isUndefined()) { + Unset(); + return NS_OK; + } + + nsresult rv = EncodeJSVal(aCx, aVal, 0); + if (NS_FAILED(rv)) { + Unset(); + return rv; + } + TrimBuffer(); + + return NS_OK; +} + +nsresult +Key::ToJSVal(JSContext* aCx, + JS::MutableHandle<JS::Value> aVal) const +{ + if (IsUnset()) { + aVal.setUndefined(); + return NS_OK; + } + + const unsigned char* pos = BufferStart(); + nsresult rv = DecodeJSVal(pos, BufferEnd(), aCx, aVal); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + MOZ_ASSERT(pos >= BufferEnd()); + + return NS_OK; +} + +nsresult +Key::ToJSVal(JSContext* aCx, + JS::Heap<JS::Value>& aVal) const +{ + JS::Rooted<JS::Value> value(aCx); + nsresult rv = ToJSVal(aCx, &value); + if (NS_SUCCEEDED(rv)) { + aVal = value; + } + return rv; +} + +nsresult +Key::AppendItem(JSContext* aCx, bool aFirstOfArray, JS::Handle<JS::Value> aVal) +{ + nsresult rv = EncodeJSVal(aCx, aVal, aFirstOfArray ? eMaxType : 0); + if (NS_FAILED(rv)) { + Unset(); + return rv; + } + + return NS_OK; +} + +template <typename T> +nsresult +Key::SetFromSource(T* aSource, uint32_t aIndex) +{ + const uint8_t* data; + uint32_t dataLength = 0; + + nsresult rv = aSource->GetSharedBlob(aIndex, &dataLength, &data); + if (NS_WARN_IF(NS_FAILED(rv))) { + return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR; + } + + mBuffer.Assign(reinterpret_cast<const char*>(data), dataLength); + + return NS_OK; +} + +#ifdef DEBUG + +void +Key::Assert(bool aCondition) const +{ + MOZ_ASSERT(aCondition); +} + +#endif // DEBUG + +} // namespace indexedDB +} // namespace dom +} // namespace mozilla |