Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 448 insertions, 0 deletions

diff --git a/dom/base/DOMException.cpp b/dom/base/DOMException.cpp
new file mode 100644
index 0000000000..d3e2fc42d3
--- /dev/null
+++ b/dom/base/DOMException.cpp
@@ -0,0 +1,448 @@
+/* -*- 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 "mozilla/dom/DOMException.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/HoldDropJSObjects.h"
+#include "mozilla/dom/Exceptions.h"
+#include "nsContentUtils.h"
+#include "nsCOMPtr.h"
+#include "mozilla/dom/Document.h"
+#include "nsIException.h"
+#include "xpcprivate.h"
+
+#include "mozilla/dom/DOMExceptionBinding.h"
+#include "mozilla/ErrorResult.h"
+
+#include "js/TypeDecls.h"
+#include "js/StructuredClone.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+enum DOM4ErrorTypeCodeMap {
+  /* DOM4 errors from
+     http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#domexception */
+  IndexSizeError = DOMException_Binding::INDEX_SIZE_ERR,
+  HierarchyRequestError = DOMException_Binding::HIERARCHY_REQUEST_ERR,
+  WrongDocumentError = DOMException_Binding::WRONG_DOCUMENT_ERR,
+  InvalidCharacterError = DOMException_Binding::INVALID_CHARACTER_ERR,
+  NoModificationAllowedError =
+      DOMException_Binding::NO_MODIFICATION_ALLOWED_ERR,
+  NotFoundError = DOMException_Binding::NOT_FOUND_ERR,
+  NotSupportedError = DOMException_Binding::NOT_SUPPORTED_ERR,
+  // Can't remove until setNamedItem is removed
+  InUseAttributeError = DOMException_Binding::INUSE_ATTRIBUTE_ERR,
+  InvalidStateError = DOMException_Binding::INVALID_STATE_ERR,
+  SyntaxError = DOMException_Binding::SYNTAX_ERR,
+  InvalidModificationError = DOMException_Binding::INVALID_MODIFICATION_ERR,
+  NamespaceError = DOMException_Binding::NAMESPACE_ERR,
+  InvalidAccessError = DOMException_Binding::INVALID_ACCESS_ERR,
+  TypeMismatchError = DOMException_Binding::TYPE_MISMATCH_ERR,
+  SecurityError = DOMException_Binding::SECURITY_ERR,
+  NetworkError = DOMException_Binding::NETWORK_ERR,
+  AbortError = DOMException_Binding::ABORT_ERR,
+  URLMismatchError = DOMException_Binding::URL_MISMATCH_ERR,
+  QuotaExceededError = DOMException_Binding::QUOTA_EXCEEDED_ERR,
+  TimeoutError = DOMException_Binding::TIMEOUT_ERR,
+  InvalidNodeTypeError = DOMException_Binding::INVALID_NODE_TYPE_ERR,
+  DataCloneError = DOMException_Binding::DATA_CLONE_ERR,
+  EncodingError = 0,
+
+  /* IndexedDB errors
+     http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#exceptions */
+  UnknownError = 0,
+  ConstraintError = 0,
+  DataError = 0,
+  TransactionInactiveError = 0,
+  ReadOnlyError = 0,
+  VersionError = 0,
+
+  /* File API errors http://dev.w3.org/2006/webapi/FileAPI/#ErrorAndException */
+  NotReadableError = 0,
+
+  /* FileHandle API errors */
+  FileHandleInactiveError = 0,
+
+  /* WebCrypto errors
+     https://dvcs.w3.org/hg/webcrypto-api/raw-file/tip/spec/Overview.html#dfn-DataError
+   */
+  OperationError = 0,
+
+  /* Push API errors */
+  NotAllowedError = 0,
+};
+
+#define DOM4_MSG_DEF(name, message, nsresult) \
+  {(nsresult), name, #name, message},
+#define DOM_MSG_DEF(val, message) \
+  {(val), NS_ERROR_GET_CODE(val), #val, message},
+
+static constexpr struct ResultStruct {
+  nsresult mNSResult;
+  uint16_t mCode;
+  const char* mName;
+  const char* mMessage;
+} sDOMErrorMsgMap[] = {
+#include "domerr.msg"
+};
+
+#undef DOM4_MSG_DEF
+#undef DOM_MSG_DEF
+
+static void NSResultToNameAndMessage(nsresult aNSResult, nsCString& aName,
+                                     nsCString& aMessage, uint16_t* aCode) {
+  aName.Truncate();
+  aMessage.Truncate();
+  *aCode = 0;
+  for (uint32_t idx = 0; idx < ArrayLength(sDOMErrorMsgMap); idx++) {
+    if (aNSResult == sDOMErrorMsgMap[idx].mNSResult) {
+      aName.Rebind(sDOMErrorMsgMap[idx].mName,
+                   strlen(sDOMErrorMsgMap[idx].mName));
+      aMessage.Rebind(sDOMErrorMsgMap[idx].mMessage,
+                      strlen(sDOMErrorMsgMap[idx].mMessage));
+      *aCode = sDOMErrorMsgMap[idx].mCode;
+      return;
+    }
+  }
+
+  NS_WARNING("Huh, someone is throwing non-DOM errors using the DOM module!");
+}
+
+nsresult NS_GetNameAndMessageForDOMNSResult(nsresult aNSResult,
+                                            nsACString& aName,
+                                            nsACString& aMessage,
+                                            uint16_t* aCode) {
+  nsCString name;
+  nsCString message;
+  uint16_t code = 0;
+  NSResultToNameAndMessage(aNSResult, name, message, &code);
+
+  if (!name.IsEmpty() && !message.IsEmpty()) {
+    aName = name;
+    aMessage = message;
+    if (aCode) {
+      *aCode = code;
+    }
+    return NS_OK;
+  }
+
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+namespace mozilla::dom {
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Exception)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(Exception)
+  NS_INTERFACE_MAP_ENTRY(nsIException)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(Exception)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(Exception)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WITH_JS_MEMBERS(Exception,
+                                                      (mLocation, mData),
+                                                      (mThrownJSVal))
+
+Exception::Exception(const nsACString& aMessage, nsresult aResult,
+                     const nsACString& aName, nsIStackFrame* aLocation,
+                     nsISupports* aData)
+    : mMessage(aMessage),
+      mResult(aResult),
+      mName(aName),
+      mData(aData),
+      mHoldingJSVal(false) {
+  if (aLocation) {
+    mLocation = aLocation;
+  } else {
+    mLocation = GetCurrentJSStack();
+    // it is legal for there to be no active JS stack, if C++ code
+    // is operating on a JS-implemented interface pointer without
+    // having been called in turn by JS.  This happens in the JS
+    // component loader.
+  }
+}
+
+Exception::Exception(nsCString&& aMessage, nsresult aResult, nsCString&& aName)
+    : mMessage(std::move(aMessage)),
+      mResult(aResult),
+      mName(std::move(aName)),
+      mHoldingJSVal(false) {}
+
+Exception::~Exception() {
+  if (mHoldingJSVal) {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    mozilla::DropJSObjects(this);
+  }
+}
+
+bool Exception::StealJSVal(JS::Value* aVp) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mHoldingJSVal) {
+    *aVp = mThrownJSVal;
+
+    mozilla::DropJSObjects(this);
+    mHoldingJSVal = false;
+    return true;
+  }
+
+  return false;
+}
+
+void Exception::StowJSVal(JS::Value& aVp) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mThrownJSVal = aVp;
+  if (!mHoldingJSVal) {
+    mozilla::HoldJSObjects(this);
+    mHoldingJSVal = true;
+  }
+}
+
+void Exception::GetName(nsAString& aName) {
+  if (!mName.IsEmpty()) {
+    CopyUTF8toUTF16(mName, aName);
+  } else {
+    aName.Truncate();
+
+    const char* name = nullptr;
+    nsXPCException::NameAndFormatForNSResult(mResult, &name, nullptr);
+
+    if (name) {
+      CopyUTF8toUTF16(mozilla::MakeStringSpan(name), aName);
+    }
+  }
+}
+
+void Exception::GetFilename(JSContext* aCx, nsAString& aFilename) {
+  if (mLocation) {
+    mLocation->GetFilename(aCx, aFilename);
+    return;
+  }
+
+  aFilename.Truncate();
+}
+
+void Exception::ToString(JSContext* aCx, nsACString& _retval) {
+  static const char defaultMsg[] = "<no message>";
+  static const char defaultLocation[] = "<unknown>";
+  static const char format[] = "[Exception... \"%s\"  nsresult: \"0x%" PRIx32
+                               " (%s)\"  location: \"%s\"  data: %s]";
+
+  nsCString location;
+
+  if (mLocation) {
+    // we need to free this if it does not fail
+    mLocation->ToString(aCx, location);
+  }
+
+  if (location.IsEmpty()) {
+    location.Assign(defaultLocation);
+  }
+
+  const char* msg = mMessage.IsEmpty() ? nullptr : mMessage.get();
+
+  const char* resultName = mName.IsEmpty() ? nullptr : mName.get();
+  if (!resultName && !nsXPCException::NameAndFormatForNSResult(
+                         mResult, &resultName, (!msg) ? &msg : nullptr)) {
+    if (!msg) {
+      msg = defaultMsg;
+    }
+    resultName = "<unknown>";
+  }
+  const char* data = mData ? "yes" : "no";
+
+  _retval.Truncate();
+  _retval.AppendPrintf(format, msg, static_cast<uint32_t>(mResult), resultName,
+                       location.get(), data);
+}
+
+JSObject* Exception::WrapObject(JSContext* cx,
+                                JS::Handle<JSObject*> aGivenProto) {
+  return Exception_Binding::Wrap(cx, this, aGivenProto);
+}
+
+void Exception::GetMessageMoz(nsString& retval) {
+  CopyUTF8toUTF16(mMessage, retval);
+}
+
+uint32_t Exception::Result() const { return (uint32_t)mResult; }
+
+uint32_t Exception::SourceId(JSContext* aCx) const {
+  if (mLocation) {
+    return mLocation->GetSourceId(aCx);
+  }
+
+  return 0;
+}
+
+uint32_t Exception::LineNumber(JSContext* aCx) const {
+  if (mLocation) {
+    return mLocation->GetLineNumber(aCx);
+  }
+
+  return 0;
+}
+
+uint32_t Exception::ColumnNumber() const { return 0; }
+
+already_AddRefed<nsIStackFrame> Exception::GetLocation() const {
+  nsCOMPtr<nsIStackFrame> location = mLocation;
+  return location.forget();
+}
+
+nsISupports* Exception::GetData() const { return mData; }
+
+void Exception::GetStack(JSContext* aCx, nsAString& aStack) const {
+  if (mLocation) {
+    mLocation->GetFormattedStack(aCx, aStack);
+  }
+}
+
+void Exception::Stringify(JSContext* aCx, nsString& retval) {
+  nsCString str;
+  ToString(aCx, str);
+  CopyUTF8toUTF16(str, retval);
+}
+
+DOMException::DOMException(nsresult aRv, const nsACString& aMessage,
+                           const nsACString& aName, uint16_t aCode,
+                           nsIStackFrame* aLocation)
+    : Exception(aMessage, aRv, aName, aLocation, nullptr), mCode(aCode) {}
+DOMException::DOMException(nsresult aRv, nsCString&& aMessage,
+                           nsCString&& aName, uint16_t aCode)
+    : Exception(std::move(aMessage), aRv, std::move(aName)), mCode(aCode) {}
+
+void DOMException::ToString(JSContext* aCx, nsACString& aReturn) {
+  aReturn.Truncate();
+
+  static const char defaultMsg[] = "<no message>";
+  static const char defaultLocation[] = "<unknown>";
+  static const char defaultName[] = "<unknown>";
+  static const char format[] =
+      "[Exception... \"%s\"  code: \"%d\" nsresult: \"0x%" PRIx32
+      " (%s)\"  location: \"%s\"]";
+
+  nsAutoCString location;
+
+  if (location.IsEmpty()) {
+    location = defaultLocation;
+  }
+
+  const char* msg = !mMessage.IsEmpty() ? mMessage.get() : defaultMsg;
+  const char* resultName = !mName.IsEmpty() ? mName.get() : defaultName;
+
+  aReturn.AppendPrintf(format, msg, mCode, static_cast<uint32_t>(mResult),
+                       resultName, location.get());
+}
+
+void DOMException::GetName(nsString& retval) { CopyUTF8toUTF16(mName, retval); }
+
+already_AddRefed<DOMException> DOMException::Constructor(
+    GlobalObject& /* unused */, const nsAString& aMessage,
+    const Optional<nsAString>& aName) {
+  nsresult exceptionResult = NS_OK;
+  uint16_t exceptionCode = 0;
+  nsCString name("Error"_ns);
+
+  if (aName.WasPassed()) {
+    CopyUTF16toUTF8(aName.Value(), name);
+    for (uint32_t idx = 0; idx < ArrayLength(sDOMErrorMsgMap); idx++) {
+      if (name.EqualsASCII(sDOMErrorMsgMap[idx].mName)) {
+        exceptionResult = sDOMErrorMsgMap[idx].mNSResult;
+        exceptionCode = sDOMErrorMsgMap[idx].mCode;
+        break;
+      }
+    }
+  }
+
+  RefPtr<DOMException> retval = new DOMException(
+      exceptionResult, NS_ConvertUTF16toUTF8(aMessage), name, exceptionCode);
+  return retval.forget();
+}
+
+JSObject* DOMException::WrapObject(JSContext* aCx,
+                                   JS::Handle<JSObject*> aGivenProto) {
+  return DOMException_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+/* static */
+already_AddRefed<DOMException> DOMException::Create(nsresult aRv) {
+  nsCString name;
+  nsCString message;
+  uint16_t code;
+  NSResultToNameAndMessage(aRv, name, message, &code);
+  RefPtr<DOMException> inst = new DOMException(aRv, message, name, code);
+  return inst.forget();
+}
+
+/* static */
+already_AddRefed<DOMException> DOMException::Create(
+    nsresult aRv, const nsACString& aMessage) {
+  nsCString name;
+  nsCString message;
+  uint16_t code;
+  NSResultToNameAndMessage(aRv, name, message, &code);
+  RefPtr<DOMException> inst = new DOMException(aRv, aMessage, name, code);
+  return inst.forget();
+}
+
+static bool ReadAsCString(JSContext* aCx, JSStructuredCloneReader* aReader,
+                          nsCString& aString) {
+  JS::Rooted<JSString*> jsMessage(aCx);
+  if (!JS_ReadString(aReader, &jsMessage)) {
+    return false;
+  }
+  return AssignJSString(aCx, aString, jsMessage);
+}
+
+already_AddRefed<DOMException> DOMException::ReadStructuredClone(
+    JSContext* aCx, nsIGlobalObject* aGlobal,
+    JSStructuredCloneReader* aReader) {
+  uint32_t reserved;
+  nsresult rv;
+  nsCString message;
+  nsCString name;
+  uint16_t code;
+
+  if (!JS_ReadBytes(aReader, &reserved, 4) || !JS_ReadBytes(aReader, &rv, 4) ||
+      !ReadAsCString(aCx, aReader, message) ||
+      !ReadAsCString(aCx, aReader, name) || !JS_ReadBytes(aReader, &code, 2)) {
+    return nullptr;
+  };
+
+  return do_AddRef(
+      new DOMException(rv, std::move(message), std::move(name), code));
+}
+
+bool DOMException::WriteStructuredClone(
+    JSContext* aCx, JSStructuredCloneWriter* aWriter) const {
+  JS::Rooted<JS::Value> messageValue(aCx);
+  JS::Rooted<JS::Value> nameValue(aCx);
+  if (!NonVoidByteStringToJsval(aCx, mMessage, &messageValue) ||
+      !NonVoidByteStringToJsval(aCx, mName, &nameValue)) {
+    return false;
+  }
+
+  JS::Rooted<JSString*> message(aCx, messageValue.toString());
+  JS::Rooted<JSString*> name(aCx, nameValue.toString());
+
+  static_assert(sizeof(nsresult) == 4);
+
+  // A reserved field. Use this to indicate stack serialization support etc.
+  uint32_t reserved = 0;
+  return JS_WriteBytes(aWriter, &reserved, 4) &&
+         JS_WriteBytes(aWriter, &mResult, 4) &&
+         JS_WriteString(aWriter, message) && JS_WriteString(aWriter, name) &&
+         JS_WriteBytes(aWriter, &mCode, 2);
+};
+
+}  // namespace mozilla::dom