Add m-esr52 at 52.6.0

1 files changed, 365 insertions, 0 deletions

diff --git a/dom/indexedDB/Key.h b/dom/indexedDB/Key.h
new file mode 100644
index 000000000..856089c97
--- /dev/null
+++ b/dom/indexedDB/Key.h
@@ -0,0 +1,365 @@
+/* -*- 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/. */
+
+#ifndef mozilla_dom_indexeddb_key_h__
+#define mozilla_dom_indexeddb_key_h__
+
+#include "js/RootingAPI.h"
+#include "nsString.h"
+
+class mozIStorageStatement;
+class mozIStorageValueArray;
+
+namespace IPC {
+
+template <typename> struct ParamTraits;
+
+} // namespace IPC
+
+namespace mozilla {
+namespace dom {
+namespace indexedDB {
+
+class Key
+{
+  friend struct IPC::ParamTraits<Key>;
+
+  nsCString mBuffer;
+
+public:
+  enum {
+    eTerminator = 0,
+    eFloat = 0x10,
+    eDate = 0x20,
+    eString = 0x30,
+    eBinary = 0x40,
+    eArray = 0x50,
+    eMaxType = eArray
+  };
+
+  static const uint8_t kMaxArrayCollapse = uint8_t(3);
+  static const uint8_t kMaxRecursionDepth = uint8_t(64);
+
+  Key()
+  {
+    Unset();
+  }
+
+  explicit
+  Key(const nsACString& aBuffer)
+    : mBuffer(aBuffer)
+  { }
+
+  Key&
+  operator=(const nsAString& aString)
+  {
+    SetFromString(aString);
+    return *this;
+  }
+
+  Key&
+  operator=(int64_t aInt)
+  {
+    SetFromInteger(aInt);
+    return *this;
+  }
+
+  bool
+  operator==(const Key& aOther) const
+  {
+    Assert(!mBuffer.IsVoid() && !aOther.mBuffer.IsVoid());
+
+    return mBuffer.Equals(aOther.mBuffer);
+  }
+
+  bool
+  operator!=(const Key& aOther) const
+  {
+    Assert(!mBuffer.IsVoid() && !aOther.mBuffer.IsVoid());
+
+    return !mBuffer.Equals(aOther.mBuffer);
+  }
+
+  bool
+  operator<(const Key& aOther) const
+  {
+    Assert(!mBuffer.IsVoid() && !aOther.mBuffer.IsVoid());
+
+    return Compare(mBuffer, aOther.mBuffer) < 0;
+  }
+
+  bool
+  operator>(const Key& aOther) const
+  {
+    Assert(!mBuffer.IsVoid() && !aOther.mBuffer.IsVoid());
+
+    return Compare(mBuffer, aOther.mBuffer) > 0;
+  }
+
+  bool
+  operator<=(const Key& aOther) const
+  {
+    Assert(!mBuffer.IsVoid() && !aOther.mBuffer.IsVoid());
+
+    return Compare(mBuffer, aOther.mBuffer) <= 0;
+  }
+
+  bool
+  operator>=(const Key& aOther) const
+  {
+    Assert(!mBuffer.IsVoid() && !aOther.mBuffer.IsVoid());
+
+    return Compare(mBuffer, aOther.mBuffer) >= 0;
+  }
+
+  void
+  Unset()
+  {
+    mBuffer.SetIsVoid(true);
+  }
+
+  bool
+  IsUnset() const
+  {
+    return mBuffer.IsVoid();
+  }
+
+  bool
+  IsFloat() const
+  {
+    return !IsUnset() && *BufferStart() == eFloat;
+  }
+
+  bool
+  IsDate() const
+  {
+    return !IsUnset() && *BufferStart() == eDate;
+  }
+
+  bool
+  IsString() const
+  {
+    return !IsUnset() && *BufferStart() == eString;
+  }
+
+  bool
+  IsBinary() const
+  {
+    return !IsUnset() && *BufferStart() == eBinary;
+  }
+
+  bool
+  IsArray() const
+  {
+    return !IsUnset() && *BufferStart() >= eArray;
+  }
+
+  double
+  ToFloat() const
+  {
+    Assert(IsFloat());
+    const unsigned char* pos = BufferStart();
+    double res = DecodeNumber(pos, BufferEnd());
+    Assert(pos >= BufferEnd());
+    return res;
+  }
+
+  double
+  ToDateMsec() const
+  {
+    Assert(IsDate());
+    const unsigned char* pos = BufferStart();
+    double res = DecodeNumber(pos, BufferEnd());
+    Assert(pos >= BufferEnd());
+    return res;
+  }
+
+  void
+  ToString(nsString& aString) const
+  {
+    Assert(IsString());
+    const unsigned char* pos = BufferStart();
+    DecodeString(pos, BufferEnd(), aString);
+    Assert(pos >= BufferEnd());
+  }
+
+  void
+  SetFromString(const nsAString& aString)
+  {
+    mBuffer.Truncate();
+    EncodeString(aString, 0);
+    TrimBuffer();
+  }
+
+  void
+  SetFromInteger(int64_t aInt)
+  {
+    mBuffer.Truncate();
+    EncodeNumber(double(aInt), eFloat);
+    TrimBuffer();
+  }
+
+  nsresult
+  SetFromJSVal(JSContext* aCx, JS::Handle<JS::Value> aVal);
+
+  nsresult
+  ToJSVal(JSContext* aCx, JS::MutableHandle<JS::Value> aVal) const;
+
+  nsresult
+  ToJSVal(JSContext* aCx, JS::Heap<JS::Value>& aVal) const;
+
+  nsresult
+  AppendItem(JSContext* aCx, bool aFirstOfArray, JS::Handle<JS::Value> aVal);
+
+#ifdef ENABLE_INTL_API
+  nsresult
+  ToLocaleBasedKey(Key& aTarget, const nsCString& aLocale) const;
+#endif
+
+  void
+  FinishArray()
+  {
+    TrimBuffer();
+  }
+
+  const nsCString&
+  GetBuffer() const
+  {
+    return mBuffer;
+  }
+
+  nsresult
+  BindToStatement(mozIStorageStatement* aStatement,
+                  const nsACString& aParamName) const;
+
+  nsresult
+  SetFromStatement(mozIStorageStatement* aStatement, uint32_t aIndex);
+
+  nsresult
+  SetFromValueArray(mozIStorageValueArray* aValues, uint32_t aIndex);
+
+  static int16_t
+  CompareKeys(const Key& aFirst, const Key& aSecond)
+  {
+    int32_t result = Compare(aFirst.mBuffer, aSecond.mBuffer);
+
+    if (result < 0) {
+      return -1;
+    }
+
+    if (result > 0) {
+      return 1;
+    }
+
+    return 0;
+  }
+
+private:
+  const unsigned char*
+  BufferStart() const
+  {
+    return reinterpret_cast<const unsigned char*>(mBuffer.BeginReading());
+  }
+
+  const unsigned char*
+  BufferEnd() const
+  {
+    return reinterpret_cast<const unsigned char*>(mBuffer.EndReading());
+  }
+
+  // Encoding helper. Trims trailing zeros off of mBuffer as a post-processing
+  // step.
+  void
+  TrimBuffer()
+  {
+    const char* end = mBuffer.EndReading() - 1;
+    while (!*end) {
+      --end;
+    }
+
+    mBuffer.Truncate(end + 1 - mBuffer.BeginReading());
+  }
+
+  // Encoding functions. These append the encoded value to the end of mBuffer
+  nsresult
+  EncodeJSVal(JSContext* aCx, JS::Handle<JS::Value> aVal, uint8_t aTypeOffset);
+
+  void
+  EncodeString(const nsAString& aString, uint8_t aTypeOffset);
+
+  template <typename T>
+  void
+  EncodeString(const T* aStart, const T* aEnd, uint8_t aTypeOffset);
+
+  template <typename T>
+  void
+  EncodeAsString(const T* aStart, const T* aEnd, uint8_t aType);
+
+#ifdef ENABLE_INTL_API
+  nsresult
+  EncodeLocaleString(const nsDependentString& aString, uint8_t aTypeOffset,
+                     const nsCString& aLocale);
+#endif
+
+  void
+  EncodeNumber(double aFloat, uint8_t aType);
+
+  void
+  EncodeBinary(JSObject* aObject, bool aIsViewObject, uint8_t aTypeOffset);
+
+  // Decoding functions. aPos points into mBuffer and is adjusted to point
+  // past the consumed value.
+  static nsresult
+  DecodeJSVal(const unsigned char*& aPos,
+              const unsigned char* aEnd,
+              JSContext* aCx,
+              JS::MutableHandle<JS::Value> aVal);
+
+  static void
+  DecodeString(const unsigned char*& aPos,
+               const unsigned char* aEnd,
+               nsString& aString);
+
+  static double
+  DecodeNumber(const unsigned char*& aPos, const unsigned char* aEnd);
+
+  static JSObject*
+  DecodeBinary(const unsigned char*& aPos,
+               const unsigned char* aEnd,
+               JSContext* aCx);
+
+  nsresult
+  EncodeJSValInternal(JSContext* aCx,
+                      JS::Handle<JS::Value> aVal,
+                      uint8_t aTypeOffset,
+                      uint16_t aRecursionDepth);
+
+  static nsresult
+  DecodeJSValInternal(const unsigned char*& aPos,
+                      const unsigned char* aEnd,
+                      JSContext* aCx,
+                      uint8_t aTypeOffset,
+                      JS::MutableHandle<JS::Value> aVal,
+                      uint16_t aRecursionDepth);
+
+  template <typename T>
+  nsresult
+  SetFromSource(T* aSource, uint32_t aIndex);
+
+  void
+  Assert(bool aCondition) const
+#ifdef DEBUG
+  ;
+#else
+  { }
+#endif
+};
+
+} // namespace indexedDB
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_indexeddb_key_h__