Add m-esr52 at 52.6.0

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