dom/base/DOMException.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/DOMException.h"
   8
   9 #include "mozilla/ArrayUtils.h"
  10 #include "mozilla/HoldDropJSObjects.h"
  11 #include "mozilla/dom/Exceptions.h"
  12 #include "nsContentUtils.h"
  13 #include "nsCOMPtr.h"
  14 #include "mozilla/dom/Document.h"
  15 #include "nsIException.h"
  16 #include "nsMemory.h"
  17 #include "xpcprivate.h"
  18
  19 #include "mozilla/dom/DOMExceptionBinding.h"
  20 #include "mozilla/ErrorResult.h"
  21
  22 using namespace mozilla;
  23 using namespace mozilla::dom;
  24
  25 enum DOM4ErrorTypeCodeMap {
  26   /* DOM4 errors from
  27      http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#domexception */
  28   IndexSizeError = DOMException_Binding::INDEX_SIZE_ERR,
  29   HierarchyRequestError = DOMException_Binding::HIERARCHY_REQUEST_ERR,
  30   WrongDocumentError = DOMException_Binding::WRONG_DOCUMENT_ERR,
  31   InvalidCharacterError = DOMException_Binding::INVALID_CHARACTER_ERR,
  32   NoModificationAllowedError =
  33       DOMException_Binding::NO_MODIFICATION_ALLOWED_ERR,
  34   NotFoundError = DOMException_Binding::NOT_FOUND_ERR,
  35   NotSupportedError = DOMException_Binding::NOT_SUPPORTED_ERR,
  36   // Can't remove until setNamedItem is removed
  37   InUseAttributeError = DOMException_Binding::INUSE_ATTRIBUTE_ERR,
  38   InvalidStateError = DOMException_Binding::INVALID_STATE_ERR,
  39   SyntaxError = DOMException_Binding::SYNTAX_ERR,
  40   InvalidModificationError = DOMException_Binding::INVALID_MODIFICATION_ERR,
  41   NamespaceError = DOMException_Binding::NAMESPACE_ERR,
  42   InvalidAccessError = DOMException_Binding::INVALID_ACCESS_ERR,
  43   TypeMismatchError = DOMException_Binding::TYPE_MISMATCH_ERR,
  44   SecurityError = DOMException_Binding::SECURITY_ERR,
  45   NetworkError = DOMException_Binding::NETWORK_ERR,
  46   AbortError = DOMException_Binding::ABORT_ERR,
  47   URLMismatchError = DOMException_Binding::URL_MISMATCH_ERR,
  48   QuotaExceededError = DOMException_Binding::QUOTA_EXCEEDED_ERR,
  49   TimeoutError = DOMException_Binding::TIMEOUT_ERR,
  50   InvalidNodeTypeError = DOMException_Binding::INVALID_NODE_TYPE_ERR,
  51   DataCloneError = DOMException_Binding::DATA_CLONE_ERR,
  52   InvalidPointerId = 0,
  53   EncodingError = 0,
  54
  55   /* XXX Should be JavaScript native errors */
  56   TypeError = 0,
  57   RangeError = 0,
  58
  59   /* IndexedDB errors
  60      http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#exceptions */
  61   UnknownError = 0,
  62   ConstraintError = 0,
  63   DataError = 0,
  64   TransactionInactiveError = 0,
  65   ReadOnlyError = 0,
  66   VersionError = 0,
  67
  68   /* File API errors http://dev.w3.org/2006/webapi/FileAPI/#ErrorAndException */
  69   NotReadableError = 0,
  70
  71   /* FileHandle API errors */
  72   FileHandleInactiveError = 0,
  73
  74   /* WebCrypto errors
  75      https://dvcs.w3.org/hg/webcrypto-api/raw-file/tip/spec/Overview.html#dfn-DataError
  76    */
  77   OperationError = 0,
  78
  79   /* Push API errors */
  80   NotAllowedError = 0,
  81 };
  82
  83 #define DOM4_MSG_DEF(name, message, nsresult) \
  84   {(nsresult), name, #name, message},
  85 #define DOM_MSG_DEF(val, message) \
  86   {(val), NS_ERROR_GET_CODE(val), #val, message},
  87
  88 static constexpr struct ResultStruct {
  89   nsresult mNSResult;
  90   uint16_t mCode;
  91   const char* mName;
  92   const char* mMessage;
  93 } sDOMErrorMsgMap[] = {
  94 #include "domerr.msg"
  95 };
  96
  97 #undef DOM4_MSG_DEF
  98 #undef DOM_MSG_DEF
  99
 100 static void NSResultToNameAndMessage(nsresult aNSResult, nsCString& aName,
 101                                      nsCString& aMessage, uint16_t* aCode) {
 102   aName.Truncate();
 103   aMessage.Truncate();
 104   *aCode = 0;
 105   for (uint32_t idx = 0; idx < ArrayLength(sDOMErrorMsgMap); idx++) {
 106     if (aNSResult == sDOMErrorMsgMap[idx].mNSResult) {
 107       aName.Rebind(sDOMErrorMsgMap[idx].mName,
 108                    strlen(sDOMErrorMsgMap[idx].mName));
 109       aMessage.Rebind(sDOMErrorMsgMap[idx].mMessage,
 110                       strlen(sDOMErrorMsgMap[idx].mMessage));
 111       *aCode = sDOMErrorMsgMap[idx].mCode;
 112       return;
 113     }
 114   }
 115
 116   NS_WARNING("Huh, someone is throwing non-DOM errors using the DOM module!");
 117 }
 118
 119 nsresult NS_GetNameAndMessageForDOMNSResult(nsresult aNSResult,
 120                                             nsACString& aName,
 121                                             nsACString& aMessage,
 122                                             uint16_t* aCode) {
 123   nsCString name;
 124   nsCString message;
 125   uint16_t code = 0;
 126   NSResultToNameAndMessage(aNSResult, name, message, &code);
 127
 128   if (!name.IsEmpty() && !message.IsEmpty()) {
 129     aName = name;
 130     aMessage = message;
 131     if (aCode) {
 132       *aCode = code;
 133     }
 134     return NS_OK;
 135   }
 136
 137   return NS_ERROR_NOT_AVAILABLE;
 138 }
 139
 140 namespace mozilla::dom {
 141
 142 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Exception)
 143   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
 144   NS_INTERFACE_MAP_ENTRY(Exception)
 145   NS_INTERFACE_MAP_ENTRY(nsIException)
 146   NS_INTERFACE_MAP_ENTRY(nsISupports)
 147 NS_INTERFACE_MAP_END
 148
 149 NS_IMPL_CYCLE_COLLECTING_ADDREF(Exception)
 150 NS_IMPL_CYCLE_COLLECTING_RELEASE(Exception)
 151
 152 NS_IMPL_CYCLE_COLLECTION_CLASS(Exception)
 153
 154 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Exception)
 155   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLocation)
 156   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mData)
 157 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 158
 159 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Exception)
 160   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
 161   NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mThrownJSVal)
 162 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 163
 164 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Exception)
 165   NS_IMPL_CYCLE_COLLECTION_UNLINK(mLocation)
 166   NS_IMPL_CYCLE_COLLECTION_UNLINK(mData)
 167   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
 168   tmp->mThrownJSVal.setNull();
 169 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 170
 171 Exception::Exception(const nsACString& aMessage, nsresult aResult,
 172                      const nsACString& aName, nsIStackFrame* aLocation,
 173                      nsISupports* aData)
 174     : mMessage(aMessage),
 175       mResult(aResult),
 176       mName(aName),
 177       mData(aData),
 178       mHoldingJSVal(false) {
 179   if (aLocation) {
 180     mLocation = aLocation;
 181   } else {
 182     mLocation = GetCurrentJSStack();
 183     // it is legal for there to be no active JS stack, if C++ code
 184     // is operating on a JS-implemented interface pointer without
 185     // having been called in turn by JS.  This happens in the JS
 186     // component loader.
 187   }
 188 }
 189
 190 Exception::~Exception() {
 191   if (mHoldingJSVal) {
 192     MOZ_ASSERT(NS_IsMainThread());
 193
 194     mozilla::DropJSObjects(this);
 195   }
 196 }
 197
 198 bool Exception::StealJSVal(JS::Value* aVp) {
 199   MOZ_ASSERT(NS_IsMainThread());
 200
 201   if (mHoldingJSVal) {
 202     *aVp = mThrownJSVal;
 203
 204     mozilla::DropJSObjects(this);
 205     mHoldingJSVal = false;
 206     return true;
 207   }
 208
 209   return false;
 210 }
 211
 212 void Exception::StowJSVal(JS::Value& aVp) {
 213   MOZ_ASSERT(NS_IsMainThread());
 214
 215   mThrownJSVal = aVp;
 216   if (!mHoldingJSVal) {
 217     mozilla::HoldJSObjects(this);
 218     mHoldingJSVal = true;
 219   }
 220 }
 221
 222 void Exception::GetName(nsAString& aName) {
 223   if (!mName.IsEmpty()) {
 224     CopyUTF8toUTF16(mName, aName);
 225   } else {
 226     aName.Truncate();
 227
 228     const char* name = nullptr;
 229     nsXPCException::NameAndFormatForNSResult(mResult, &name, nullptr);
 230
 231     if (name) {
 232       CopyUTF8toUTF16(mozilla::MakeStringSpan(name), aName);
 233     }
 234   }
 235 }
 236
 237 void Exception::GetFilename(JSContext* aCx, nsAString& aFilename) {
 238   if (mLocation) {
 239     mLocation->GetFilename(aCx, aFilename);
 240     return;
 241   }
 242
 243   aFilename.Truncate();
 244 }
 245
 246 void Exception::ToString(JSContext* aCx, nsACString& _retval) {
 247   static const char defaultMsg[] = "<no message>";
 248   static const char defaultLocation[] = "<unknown>";
 249   static const char format[] = "[Exception... \"%s\"  nsresult: \"0x%" PRIx32
 250                                " (%s)\"  location: \"%s\"  data: %s]";
 251
 252   nsCString location;
 253
 254   if (mLocation) {
 255     // we need to free this if it does not fail
 256     mLocation->ToString(aCx, location);
 257   }
 258
 259   if (location.IsEmpty()) {
 260     location.Assign(defaultLocation);
 261   }
 262
 263   const char* msg = mMessage.IsEmpty() ? nullptr : mMessage.get();
 264
 265   const char* resultName = mName.IsEmpty() ? nullptr : mName.get();
 266   if (!resultName && !nsXPCException::NameAndFormatForNSResult(
 267                          mResult, &resultName, (!msg) ? &msg : nullptr)) {
 268     if (!msg) {
 269       msg = defaultMsg;
 270     }
 271     resultName = "<unknown>";
 272   }
 273   const char* data = mData ? "yes" : "no";
 274
 275   _retval.Truncate();
 276   _retval.AppendPrintf(format, msg, static_cast<uint32_t>(mResult), resultName,
 277                        location.get(), data);
 278 }
 279
 280 JSObject* Exception::WrapObject(JSContext* cx,
 281                                 JS::Handle<JSObject*> aGivenProto) {
 282   return Exception_Binding::Wrap(cx, this, aGivenProto);
 283 }
 284
 285 void Exception::GetMessageMoz(nsString& retval) {
 286   CopyUTF8toUTF16(mMessage, retval);
 287 }
 288
 289 uint32_t Exception::Result() const { return (uint32_t)mResult; }
 290
 291 uint32_t Exception::SourceId(JSContext* aCx) const {
 292   if (mLocation) {
 293     return mLocation->GetSourceId(aCx);
 294   }
 295
 296   return 0;
 297 }
 298
 299 uint32_t Exception::LineNumber(JSContext* aCx) const {
 300   if (mLocation) {
 301     return mLocation->GetLineNumber(aCx);
 302   }
 303
 304   return 0;
 305 }
 306
 307 uint32_t Exception::ColumnNumber() const { return 0; }
 308
 309 already_AddRefed<nsIStackFrame> Exception::GetLocation() const {
 310   nsCOMPtr<nsIStackFrame> location = mLocation;
 311   return location.forget();
 312 }
 313
 314 nsISupports* Exception::GetData() const { return mData; }
 315
 316 void Exception::GetStack(JSContext* aCx, nsAString& aStack) const {
 317   if (mLocation) {
 318     mLocation->GetFormattedStack(aCx, aStack);
 319   }
 320 }
 321
 322 void Exception::Stringify(JSContext* aCx, nsString& retval) {
 323   nsCString str;
 324   ToString(aCx, str);
 325   CopyUTF8toUTF16(str, retval);
 326 }
 327
 328 DOMException::DOMException(nsresult aRv, const nsACString& aMessage,
 329                            const nsACString& aName, uint16_t aCode,
 330                            nsIStackFrame* aLocation)
 331     : Exception(aMessage, aRv, aName, aLocation, nullptr), mCode(aCode) {}
 332
 333 void DOMException::ToString(JSContext* aCx, nsACString& aReturn) {
 334   aReturn.Truncate();
 335
 336   static const char defaultMsg[] = "<no message>";
 337   static const char defaultLocation[] = "<unknown>";
 338   static const char defaultName[] = "<unknown>";
 339   static const char format[] =
 340       "[Exception... \"%s\"  code: \"%d\" nsresult: \"0x%" PRIx32
 341       " (%s)\"  location: \"%s\"]";
 342
 343   nsAutoCString location;
 344
 345   if (location.IsEmpty()) {
 346     location = defaultLocation;
 347   }
 348
 349   const char* msg = !mMessage.IsEmpty() ? mMessage.get() : defaultMsg;
 350   const char* resultName = !mName.IsEmpty() ? mName.get() : defaultName;
 351
 352   aReturn.AppendPrintf(format, msg, mCode, static_cast<uint32_t>(mResult),
 353                        resultName, location.get());
 354 }
 355
 356 void DOMException::GetName(nsString& retval) { CopyUTF8toUTF16(mName, retval); }
 357
 358 already_AddRefed<DOMException> DOMException::Constructor(
 359     GlobalObject& /* unused */, const nsAString& aMessage,
 360     const Optional<nsAString>& aName) {
 361   nsresult exceptionResult = NS_OK;
 362   uint16_t exceptionCode = 0;
 363   nsCString name("Error"_ns);
 364
 365   if (aName.WasPassed()) {
 366     CopyUTF16toUTF8(aName.Value(), name);
 367     for (uint32_t idx = 0; idx < ArrayLength(sDOMErrorMsgMap); idx++) {
 368       if (name.EqualsASCII(sDOMErrorMsgMap[idx].mName)) {
 369         exceptionResult = sDOMErrorMsgMap[idx].mNSResult;
 370         exceptionCode = sDOMErrorMsgMap[idx].mCode;
 371         break;
 372       }
 373     }
 374   }
 375
 376   RefPtr<DOMException> retval = new DOMException(
 377       exceptionResult, NS_ConvertUTF16toUTF8(aMessage), name, exceptionCode);
 378   return retval.forget();
 379 }
 380
 381 JSObject* DOMException::WrapObject(JSContext* aCx,
 382                                    JS::Handle<JSObject*> aGivenProto) {
 383   return DOMException_Binding::Wrap(aCx, this, aGivenProto);
 384 }
 385
 386 /* static */
 387 already_AddRefed<DOMException> DOMException::Create(nsresult aRv) {
 388   nsCString name;
 389   nsCString message;
 390   uint16_t code;
 391   NSResultToNameAndMessage(aRv, name, message, &code);
 392   RefPtr<DOMException> inst = new DOMException(aRv, message, name, code);
 393   return inst.forget();
 394 }
 395
 396 /* static */
 397 already_AddRefed<DOMException> DOMException::Create(
 398     nsresult aRv, const nsACString& aMessage) {
 399   nsCString name;
 400   nsCString message;
 401   uint16_t code;
 402   NSResultToNameAndMessage(aRv, name, message, &code);
 403   RefPtr<DOMException> inst = new DOMException(aRv, aMessage, name, code);
 404   return inst.forget();
 405 }
 406
 407 }  // namespace mozilla::dom