mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-21 17:25:36 +00:00
ac69d4bf7b
When we call GetRemoteOuterWindowProxy in the middle of a transplant, the remote proxy that the function returns will be almost immediately swapped with some other object. Rather than trying to fix up the remote proxy map when that happens, this patch adds a new argument that is a pointer to the object, if any, that the remote proxy is going to be swapped to. This will be used in the remote proxy map. Having a value in the remote proxy map that is not a remote proxy could cause issues if somebody ends up calling GetRemoteOuterWindowProxy() a second time before the transplant has finished. To avoid that, my patch asserts that we are returning an object with the appropriate class. Differential Revision: https://phabricator.services.mozilla.com/D37598 --HG-- extra : moz-landing-system : lando
99 lines
3.0 KiB
C++
99 lines
3.0 KiB
C++
/* -*- 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/ToJSValue.h"
|
|
#include "mozilla/dom/DOMException.h"
|
|
#include "mozilla/dom/Exceptions.h"
|
|
#include "mozilla/dom/Promise.h"
|
|
#include "mozilla/dom/WindowProxyHolder.h"
|
|
#include "nsAString.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsStringBuffer.h"
|
|
#include "xpcpublic.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
bool ToJSValue(JSContext* aCx, const nsAString& aArgument,
|
|
JS::MutableHandle<JS::Value> aValue) {
|
|
// Make sure we're called in a compartment
|
|
MOZ_ASSERT(JS::CurrentGlobalOrNull(aCx));
|
|
|
|
// XXXkhuey I'd love to use xpc::NonVoidStringToJsval here, but it requires
|
|
// a non-const nsAString for silly reasons.
|
|
nsStringBuffer* sharedBuffer;
|
|
if (!XPCStringConvert::ReadableToJSVal(aCx, aArgument, &sharedBuffer,
|
|
aValue)) {
|
|
return false;
|
|
}
|
|
|
|
if (sharedBuffer) {
|
|
NS_ADDREF(sharedBuffer);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ToJSValue(JSContext* aCx, nsresult aArgument,
|
|
JS::MutableHandle<JS::Value> aValue) {
|
|
RefPtr<Exception> exception = CreateException(aArgument);
|
|
return ToJSValue(aCx, exception, aValue);
|
|
}
|
|
|
|
bool ToJSValue(JSContext* aCx, ErrorResult& aArgument,
|
|
JS::MutableHandle<JS::Value> aValue) {
|
|
MOZ_ASSERT(aArgument.Failed());
|
|
MOZ_ASSERT(
|
|
!aArgument.IsUncatchableException(),
|
|
"Doesn't make sense to convert uncatchable exception to a JS value!");
|
|
MOZ_ALWAYS_TRUE(aArgument.MaybeSetPendingException(aCx));
|
|
MOZ_ALWAYS_TRUE(JS_GetPendingException(aCx, aValue));
|
|
JS_ClearPendingException(aCx);
|
|
return true;
|
|
}
|
|
|
|
bool ToJSValue(JSContext* aCx, Promise& aArgument,
|
|
JS::MutableHandle<JS::Value> aValue) {
|
|
aValue.setObject(*aArgument.PromiseObj());
|
|
return MaybeWrapObjectValue(aCx, aValue);
|
|
}
|
|
|
|
bool ToJSValue(JSContext* aCx, const WindowProxyHolder& aArgument,
|
|
JS::MutableHandle<JS::Value> aValue) {
|
|
BrowsingContext* bc = aArgument.get();
|
|
if (!bc) {
|
|
aValue.setNull();
|
|
return true;
|
|
}
|
|
JS::Rooted<JSObject*> windowProxy(aCx);
|
|
if (bc->IsInProcess()) {
|
|
windowProxy = bc->GetWindowProxy();
|
|
if (!windowProxy) {
|
|
nsPIDOMWindowOuter* window = bc->GetDOMWindow();
|
|
if (!window) {
|
|
// Torn down enough that we should just return null.
|
|
aValue.setNull();
|
|
return true;
|
|
}
|
|
if (!window->EnsureInnerWindow()) {
|
|
return Throw(aCx, NS_ERROR_UNEXPECTED);
|
|
}
|
|
windowProxy = bc->GetWindowProxy();
|
|
}
|
|
return ToJSValue(aCx, windowProxy, aValue);
|
|
}
|
|
|
|
if (!GetRemoteOuterWindowProxy(aCx, bc, /* aTransplantTo = */ nullptr,
|
|
&windowProxy)) {
|
|
return false;
|
|
}
|
|
aValue.setObjectOrNull(windowProxy);
|
|
return true;
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|