Add m-esr52 at 52.6.0

1 files changed, 709 insertions, 0 deletions

diff --git a/dom/bindings/Exceptions.cpp b/dom/bindings/Exceptions.cpp
new file mode 100644
index 000000000..a3f807688
--- /dev/null
+++ b/dom/bindings/Exceptions.cpp
@@ -0,0 +1,709 @@
+/* -*- 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/Exceptions.h"
+
+#include "js/GCAPI.h"
+#include "js/TypeDecls.h"
+#include "jsapi.h"
+#include "jsprf.h"
+#include "mozilla/CycleCollectedJSContext.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "nsIProgrammingLanguage.h"
+#include "nsPIDOMWindow.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "XPCWrapper.h"
+#include "WorkerPrivate.h"
+#include "nsContentUtils.h"
+
+namespace mozilla {
+namespace dom {
+
+// Throw the given exception value if it's safe.  If it's not safe, then
+// synthesize and throw a new exception value for NS_ERROR_UNEXPECTED.  The
+// incoming value must be in the compartment of aCx.  This function guarantees
+// that an exception is pending on aCx when it returns.
+static void
+ThrowExceptionValueIfSafe(JSContext* aCx, JS::Handle<JS::Value> exnVal,
+                          nsIException* aOriginalException)
+{
+  MOZ_ASSERT(aOriginalException);
+
+  if (!exnVal.isObject()) {
+    JS_SetPendingException(aCx, exnVal);
+    return;
+  }
+
+  JS::Rooted<JSObject*> exnObj(aCx, &exnVal.toObject());
+  MOZ_ASSERT(js::IsObjectInContextCompartment(exnObj, aCx),
+             "exnObj needs to be in the right compartment for the "
+             "CheckedUnwrap thing to make sense");
+
+  if (js::CheckedUnwrap(exnObj)) {
+    // This is an object we're allowed to work with, so just go ahead and throw
+    // it.
+    JS_SetPendingException(aCx, exnVal);
+    return;
+  }
+
+  // We could probably Throw(aCx, NS_ERROR_UNEXPECTED) here, and it would do the
+  // right thing due to there not being an existing exception on the runtime at
+  // this point, but it's clearer to explicitly do the thing we want done.  This
+  // is also why we don't just call ThrowExceptionObject on the Exception we
+  // create: it would do the right thing, but that fact is not obvious.
+  RefPtr<Exception> syntheticException =
+    CreateException(aCx, NS_ERROR_UNEXPECTED);
+  JS::Rooted<JS::Value> syntheticVal(aCx);
+  if (!GetOrCreateDOMReflector(aCx, syntheticException, &syntheticVal)) {
+    return;
+  }
+  MOZ_ASSERT(syntheticVal.isObject() &&
+             !js::IsWrapper(&syntheticVal.toObject()),
+             "Must have a reflector here, not a wrapper");
+  JS_SetPendingException(aCx, syntheticVal);
+}
+
+void
+ThrowExceptionObject(JSContext* aCx, nsIException* aException)
+{
+  // See if we really have an Exception.
+  nsCOMPtr<Exception> exception = do_QueryInterface(aException);
+  if (exception) {
+    ThrowExceptionObject(aCx, exception);
+    return;
+  }
+
+  // We only have an nsIException (probably an XPCWrappedJS).  Fall back on old
+  // wrapping.
+  MOZ_ASSERT(NS_IsMainThread());
+
+  JS::Rooted<JS::Value> val(aCx);
+  if (!WrapObject(aCx, aException, &NS_GET_IID(nsIException), &val)) {
+    return;
+  }
+
+  ThrowExceptionValueIfSafe(aCx, val, aException);
+}
+
+void
+ThrowExceptionObject(JSContext* aCx, Exception* aException)
+{
+  JS::Rooted<JS::Value> thrown(aCx);
+
+  // If we stored the original thrown JS value in the exception
+  // (see XPCConvert::ConstructException) and we are in a web context
+  // (i.e., not chrome), rethrow the original value. This only applies to JS
+  // implemented components so we only need to check for this on the main
+  // thread.
+  if (NS_IsMainThread() && !nsContentUtils::IsCallerChrome() &&
+      aException->StealJSVal(thrown.address())) {
+    // Now check for the case when thrown is a number which matches
+    // aException->GetResult().  This would indicate that what actually got
+    // thrown was an nsresult value.  In that situation, we should go back
+    // through dom::Throw with that nsresult value, because it will make sure to
+    // create the right sort of Exception or DOMException, with the right
+    // global.
+    if (thrown.isNumber()) {
+      nsresult exceptionResult;
+      if (NS_SUCCEEDED(aException->GetResult(&exceptionResult)) &&
+          double(exceptionResult) == thrown.toNumber()) {
+        Throw(aCx, exceptionResult);
+        return;
+      }
+    }
+    if (!JS_WrapValue(aCx, &thrown)) {
+      return;
+    }
+    ThrowExceptionValueIfSafe(aCx, thrown, aException);
+    return;
+  }
+
+  if (!GetOrCreateDOMReflector(aCx, aException, &thrown)) {
+    return;
+  }
+
+  ThrowExceptionValueIfSafe(aCx, thrown, aException);
+}
+
+bool
+Throw(JSContext* aCx, nsresult aRv, const nsACString& aMessage)
+{
+  if (aRv == NS_ERROR_UNCATCHABLE_EXCEPTION) {
+    // Nuke any existing exception on aCx, to make sure we're uncatchable.
+    JS_ClearPendingException(aCx);
+    return false;
+  }
+
+  if (JS_IsExceptionPending(aCx)) {
+    // Don't clobber the existing exception.
+    return false;
+  }
+
+  CycleCollectedJSContext* context = CycleCollectedJSContext::Get();
+  nsCOMPtr<nsIException> existingException = context->GetPendingException();
+  // Make sure to clear the pending exception now.  Either we're going to reuse
+  // it (and we already grabbed it), or we plan to throw something else and this
+  // pending exception is no longer relevant.
+  context->SetPendingException(nullptr);
+
+  // Ignore the pending exception if we have a non-default message passed in.
+  if (aMessage.IsEmpty() && existingException) {
+    nsresult nr;
+    if (NS_SUCCEEDED(existingException->GetResult(&nr)) &&
+        aRv == nr) {
+      // Reuse the existing exception.
+      ThrowExceptionObject(aCx, existingException);
+      return false;
+    }
+  }
+
+  RefPtr<Exception> finalException = CreateException(aCx, aRv, aMessage);
+  MOZ_ASSERT(finalException);
+
+  ThrowExceptionObject(aCx, finalException);
+  return false;
+}
+
+void
+ThrowAndReport(nsPIDOMWindowInner* aWindow, nsresult aRv)
+{
+  MOZ_ASSERT(aRv != NS_ERROR_UNCATCHABLE_EXCEPTION,
+             "Doesn't make sense to report uncatchable exceptions!");
+  AutoJSAPI jsapi;
+  if (NS_WARN_IF(!jsapi.Init(aWindow))) {
+    return;
+  }
+
+  Throw(jsapi.cx(), aRv);
+}
+
+already_AddRefed<Exception>
+CreateException(JSContext* aCx, nsresult aRv, const nsACString& aMessage)
+{
+  // Do we use DOM exceptions for this error code?
+  switch (NS_ERROR_GET_MODULE(aRv)) {
+  case NS_ERROR_MODULE_DOM:
+  case NS_ERROR_MODULE_SVG:
+  case NS_ERROR_MODULE_DOM_XPATH:
+  case NS_ERROR_MODULE_DOM_INDEXEDDB:
+  case NS_ERROR_MODULE_DOM_FILEHANDLE:
+  case NS_ERROR_MODULE_DOM_ANIM:
+  case NS_ERROR_MODULE_DOM_PUSH:
+  case NS_ERROR_MODULE_DOM_MEDIA:
+    if (aMessage.IsEmpty()) {
+      return DOMException::Create(aRv);
+    }
+    return DOMException::Create(aRv, aMessage);
+  default:
+    break;
+  }
+
+  // If not, use the default.
+  RefPtr<Exception> exception =
+    new Exception(aMessage, aRv, EmptyCString(), nullptr, nullptr);
+  return exception.forget();
+}
+
+already_AddRefed<nsIStackFrame>
+GetCurrentJSStack(int32_t aMaxDepth)
+{
+  // is there a current context available?
+  JSContext* cx = nsContentUtils::GetCurrentJSContextForThread();
+
+  if (!cx || !js::GetContextCompartment(cx)) {
+    return nullptr;
+  }
+
+  static const unsigned MAX_FRAMES = 100;
+  if (aMaxDepth < 0) {
+    aMaxDepth = MAX_FRAMES;
+  }
+
+  JS::StackCapture captureMode = aMaxDepth == 0
+    ? JS::StackCapture(JS::AllFrames())
+    : JS::StackCapture(JS::MaxFrames(aMaxDepth));
+
+  return dom::exceptions::CreateStack(cx, mozilla::Move(captureMode));
+}
+
+namespace exceptions {
+
+class JSStackFrame : public nsIStackFrame
+{
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(JSStackFrame)
+  NS_DECL_NSISTACKFRAME
+
+  // aStack must not be null.
+  explicit JSStackFrame(JS::Handle<JSObject*> aStack);
+
+protected:
+  int32_t GetLineno(JSContext* aCx);
+
+  int32_t GetColNo(JSContext* aCx);
+
+private:
+  virtual ~JSStackFrame();
+
+  JS::Heap<JSObject*> mStack;
+  nsString mFormattedStack;
+
+  nsCOMPtr<nsIStackFrame> mCaller;
+  nsCOMPtr<nsIStackFrame> mAsyncCaller;
+  nsString mFilename;
+  nsString mFunname;
+  nsString mAsyncCause;
+  int32_t mLineno;
+  int32_t mColNo;
+
+  bool mFilenameInitialized;
+  bool mFunnameInitialized;
+  bool mLinenoInitialized;
+  bool mColNoInitialized;
+  bool mAsyncCauseInitialized;
+  bool mAsyncCallerInitialized;
+  bool mCallerInitialized;
+  bool mFormattedStackInitialized;
+};
+
+JSStackFrame::JSStackFrame(JS::Handle<JSObject*> aStack)
+  : mStack(aStack)
+  , mLineno(0)
+  , mColNo(0)
+  , mFilenameInitialized(false)
+  , mFunnameInitialized(false)
+  , mLinenoInitialized(false)
+  , mColNoInitialized(false)
+  , mAsyncCauseInitialized(false)
+  , mAsyncCallerInitialized(false)
+  , mCallerInitialized(false)
+  , mFormattedStackInitialized(false)
+{
+  MOZ_ASSERT(mStack);
+
+  mozilla::HoldJSObjects(this);
+}
+
+JSStackFrame::~JSStackFrame()
+{
+  mozilla::DropJSObjects(this);
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(JSStackFrame)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(JSStackFrame)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mCaller)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mAsyncCaller)
+  tmp->mStack = nullptr;
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(JSStackFrame)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCaller)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAsyncCaller)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(JSStackFrame)
+  NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mStack)
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(JSStackFrame)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(JSStackFrame)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSStackFrame)
+  NS_INTERFACE_MAP_ENTRY(nsIStackFrame)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMETHODIMP JSStackFrame::GetLanguage(uint32_t* aLanguage)
+{
+  *aLanguage = nsIProgrammingLanguage::JAVASCRIPT;
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::GetLanguageName(nsACString& aLanguageName)
+{
+  aLanguageName.AssignLiteral("JavaScript");
+  return NS_OK;
+}
+
+// Helper method to get the value of a stack property, if it's not already
+// cached.  This will make sure we skip the cache if the access is happening
+// over Xrays.
+//
+// @argument aStack the stack we're working with; must be non-null.
+// @argument aPropGetter the getter function to call.
+// @argument aIsCached whether we've cached this property's value before.
+//
+// @argument [out] aCanCache whether the value can get cached.
+// @argument [out] aUseCachedValue if true, just use the cached value.
+// @argument [out] aValue the value we got from the stack.
+template<typename ReturnType, typename GetterOutParamType>
+static void
+GetValueIfNotCached(JSContext* aCx, const JS::Heap<JSObject*>& aStack,
+                    JS::SavedFrameResult (*aPropGetter)(JSContext*,
+                                                        JS::Handle<JSObject*>,
+                                                        GetterOutParamType,
+                                                        JS::SavedFrameSelfHosted),
+                    bool aIsCached, bool* aCanCache, bool* aUseCachedValue,
+                    ReturnType aValue)
+{
+  MOZ_ASSERT(aStack);
+
+  JS::Rooted<JSObject*> stack(aCx, aStack);
+  // Allow caching if aCx and stack are same-compartment.  Otherwise take the
+  // slow path.
+  *aCanCache = js::GetContextCompartment(aCx) == js::GetObjectCompartment(stack);
+  if (*aCanCache && aIsCached) {
+    *aUseCachedValue = true;
+    return;
+  }
+
+  *aUseCachedValue = false;
+
+  aPropGetter(aCx, stack, aValue, JS::SavedFrameSelfHosted::Exclude);
+}
+
+NS_IMETHODIMP JSStackFrame::GetFilename(JSContext* aCx, nsAString& aFilename)
+{
+  if (!mStack) {
+    aFilename.Truncate();
+    return NS_OK;
+  }
+
+  JS::Rooted<JSString*> filename(aCx);
+  bool canCache = false, useCachedValue = false;
+  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameSource,
+                      mFilenameInitialized,
+                      &canCache, &useCachedValue, &filename);
+  if (useCachedValue) {
+    aFilename = mFilename;
+    return NS_OK;
+  }
+
+  nsAutoJSString str;
+  if (!str.init(aCx, filename)) {
+    JS_ClearPendingException(aCx);
+    aFilename.Truncate();
+    return NS_OK;
+  }
+  aFilename = str;
+
+  if (canCache) {
+    mFilename = str;
+    mFilenameInitialized = true;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::GetName(JSContext* aCx, nsAString& aFunction)
+{
+  if (!mStack) {
+    aFunction.Truncate();
+    return NS_OK;
+  }
+
+  JS::Rooted<JSString*> name(aCx);
+  bool canCache = false, useCachedValue = false;
+  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameFunctionDisplayName,
+                      mFunnameInitialized, &canCache, &useCachedValue,
+                      &name);
+
+  if (useCachedValue) {
+    aFunction = mFunname;
+    return NS_OK;
+  }
+
+  if (name) {
+    nsAutoJSString str;
+    if (!str.init(aCx, name)) {
+      JS_ClearPendingException(aCx);
+      aFunction.Truncate();
+      return NS_OK;
+    }
+    aFunction = str;
+  } else {
+    aFunction.SetIsVoid(true);
+  }
+
+  if (canCache) {
+    mFunname = aFunction;
+    mFunnameInitialized = true;
+  }
+
+  return NS_OK;
+}
+
+int32_t
+JSStackFrame::GetLineno(JSContext* aCx)
+{
+  if (!mStack) {
+    return 0;
+  }
+
+  uint32_t line;
+  bool canCache = false, useCachedValue = false;
+  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameLine, mLinenoInitialized,
+                      &canCache, &useCachedValue, &line);
+
+  if (useCachedValue) {
+    return mLineno;
+  }
+
+  if (canCache) {
+    mLineno = line;
+    mLinenoInitialized = true;
+  }
+
+  return line;
+}
+
+NS_IMETHODIMP JSStackFrame::GetLineNumber(JSContext* aCx, int32_t* aLineNumber)
+{
+  *aLineNumber = GetLineno(aCx);
+  return NS_OK;
+}
+
+int32_t
+JSStackFrame::GetColNo(JSContext* aCx)
+{
+  if (!mStack) {
+    return 0;
+  }
+
+  uint32_t col;
+  bool canCache = false, useCachedValue = false;
+  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameColumn, mColNoInitialized,
+                      &canCache, &useCachedValue, &col);
+
+  if (useCachedValue) {
+    return mColNo;
+  }
+
+  if (canCache) {
+    mColNo = col;
+    mColNoInitialized = true;
+  }
+
+  return col;
+}
+
+NS_IMETHODIMP JSStackFrame::GetColumnNumber(JSContext* aCx,
+                                            int32_t* aColumnNumber)
+{
+  *aColumnNumber = GetColNo(aCx);
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::GetSourceLine(nsACString& aSourceLine)
+{
+  aSourceLine.Truncate();
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::GetAsyncCause(JSContext* aCx,
+                                          nsAString& aAsyncCause)
+{
+  if (!mStack) {
+    aAsyncCause.Truncate();
+    return NS_OK;
+  }
+
+  JS::Rooted<JSString*> asyncCause(aCx);
+  bool canCache = false, useCachedValue = false;
+  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameAsyncCause,
+                      mAsyncCauseInitialized, &canCache, &useCachedValue,
+                      &asyncCause);
+
+  if (useCachedValue) {
+    aAsyncCause = mAsyncCause;
+    return NS_OK;
+  }
+
+  if (asyncCause) {
+    nsAutoJSString str;
+    if (!str.init(aCx, asyncCause)) {
+      JS_ClearPendingException(aCx);
+      aAsyncCause.Truncate();
+      return NS_OK;
+    }
+    aAsyncCause = str;
+  } else {
+    aAsyncCause.SetIsVoid(true);
+  }
+
+  if (canCache) {
+    mAsyncCause = aAsyncCause;
+    mAsyncCauseInitialized = true;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::GetAsyncCaller(JSContext* aCx,
+                                           nsIStackFrame** aAsyncCaller)
+{
+  if (!mStack) {
+    *aAsyncCaller = nullptr;
+    return NS_OK;
+  }
+
+  JS::Rooted<JSObject*> asyncCallerObj(aCx);
+  bool canCache = false, useCachedValue = false;
+  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameAsyncParent,
+                      mAsyncCallerInitialized, &canCache, &useCachedValue,
+                      &asyncCallerObj);
+
+  if (useCachedValue) {
+    NS_IF_ADDREF(*aAsyncCaller = mAsyncCaller);
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIStackFrame> asyncCaller =
+    asyncCallerObj ? new JSStackFrame(asyncCallerObj) : nullptr;
+  asyncCaller.forget(aAsyncCaller);
+
+  if (canCache) {
+    mAsyncCaller = *aAsyncCaller;
+    mAsyncCallerInitialized = true;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::GetCaller(JSContext* aCx, nsIStackFrame** aCaller)
+{
+  if (!mStack) {
+    *aCaller = nullptr;
+    return NS_OK;
+  }
+
+  JS::Rooted<JSObject*> callerObj(aCx);
+  bool canCache = false, useCachedValue = false;
+  GetValueIfNotCached(aCx, mStack, JS::GetSavedFrameParent, mCallerInitialized,
+                      &canCache, &useCachedValue, &callerObj);
+
+  if (useCachedValue) {
+    NS_IF_ADDREF(*aCaller = mCaller);
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIStackFrame> caller =
+    callerObj ? new JSStackFrame(callerObj) : nullptr;
+  caller.forget(aCaller);
+
+  if (canCache) {
+    mCaller = *aCaller;
+    mCallerInitialized = true;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::GetFormattedStack(JSContext* aCx, nsAString& aStack)
+{
+  if (!mStack) {
+    aStack.Truncate();
+    return NS_OK;
+  }
+
+  // Sadly we can't use GetValueIfNotCached here, because our getter
+  // returns bool, not JS::SavedFrameResult.  Maybe it's possible to
+  // make the templates more complicated to deal, but in the meantime
+  // let's just inline GetValueIfNotCached here.
+
+  // Allow caching if aCx and stack are same-compartment.  Otherwise take the
+  // slow path.
+  bool canCache =
+    js::GetContextCompartment(aCx) == js::GetObjectCompartment(mStack);
+  if (canCache && mFormattedStackInitialized) {
+    aStack = mFormattedStack;
+    return NS_OK;
+  }
+
+  JS::Rooted<JSObject*> stack(aCx, mStack);
+
+  JS::Rooted<JSString*> formattedStack(aCx);
+  if (!JS::BuildStackString(aCx, stack, &formattedStack)) {
+    JS_ClearPendingException(aCx);
+    aStack.Truncate();
+    return NS_OK;
+  }
+
+  nsAutoJSString str;
+  if (!str.init(aCx, formattedStack)) {
+    JS_ClearPendingException(aCx);
+    aStack.Truncate();
+    return NS_OK;
+  }
+
+  aStack = str;
+
+  if (canCache) {
+    mFormattedStack = str;
+    mFormattedStackInitialized = true;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::GetNativeSavedFrame(JS::MutableHandle<JS::Value> aSavedFrame)
+{
+  aSavedFrame.setObjectOrNull(mStack);
+  return NS_OK;
+}
+
+NS_IMETHODIMP JSStackFrame::ToString(JSContext* aCx, nsACString& _retval)
+{
+  _retval.Truncate();
+
+  nsString filename;
+  nsresult rv = GetFilename(aCx, filename);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (filename.IsEmpty()) {
+    filename.AssignLiteral("<unknown filename>");
+  }
+
+  nsString funname;
+  rv = GetName(aCx, funname);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (funname.IsEmpty()) {
+    funname.AssignLiteral("<TOP_LEVEL>");
+  }
+
+  int32_t lineno = GetLineno(aCx);
+
+  static const char format[] = "JS frame :: %s :: %s :: line %d";
+  _retval.AppendPrintf(format,
+                       NS_ConvertUTF16toUTF8(filename).get(),
+                       NS_ConvertUTF16toUTF8(funname).get(),
+                       lineno);
+  return NS_OK;
+}
+
+already_AddRefed<nsIStackFrame>
+CreateStack(JSContext* aCx, JS::StackCapture&& aCaptureMode)
+{
+  JS::Rooted<JSObject*> stack(aCx);
+  if (!JS::CaptureCurrentStack(aCx, &stack, mozilla::Move(aCaptureMode))) {
+    return nullptr;
+  }
+
+  if (!stack) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIStackFrame> frame = new JSStackFrame(stack);
+  return frame.forget();
+}
+
+} // namespace exceptions
+} // namespace dom
+} // namespace mozilla