зеркало из https://github.com/mozilla/gecko-dev.git
745 строки
20 KiB
C++
745 строки
20 KiB
C++
/* -*- 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/Endian.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)
|
|
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 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()) {
|
|
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::ESClassValue 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;
|
|
}
|
|
}
|
|
|
|
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 {
|
|
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)
|
|
{
|
|
// 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++) = eString + aTypeOffset;
|
|
|
|
// 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;
|
|
}
|
|
|
|
union Float64Union {
|
|
double d;
|
|
uint64_t u;
|
|
};
|
|
|
|
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;
|
|
|
|
Float64Union pun;
|
|
pun.d = aFloat;
|
|
// Note: The subtraction from 0 below is necessary to fix
|
|
// MSVC build warning C4146 (negating an unsigned value).
|
|
uint64_t number = pun.u & PR_UINT64(0x8000000000000000) ?
|
|
(0 - pun.u) :
|
|
(pun.u | PR_UINT64(0x8000000000000000));
|
|
|
|
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);
|
|
|
|
Float64Union pun;
|
|
// Note: The subtraction from 0 below is necessary to fix
|
|
// MSVC build warning C4146 (negating an unsigned value).
|
|
pun.u = number & PR_UINT64(0x8000000000000000) ?
|
|
(number & ~PR_UINT64(0x8000000000000000)) :
|
|
(0 - number);
|
|
|
|
return pun.d;
|
|
}
|
|
|
|
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
|