mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/dom/base/nsDOMClassInfo.cpp

1982 строки
62 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/ArrayUtils.h"
#ifdef XP_WIN
#undef GetClassName
#endif
// JavaScript includes
#include "jsapi.h"
#include "jsfriendapi.h"
#include "WrapperFactory.h"
#include "AccessCheck.h"
#include "XrayWrapper.h"
#include "xpcpublic.h"
#include "xpcprivate.h"
#include "xpc_make_class.h"
#include "XPCWrapper.h"
#include "mozilla/DOMEventTargetHelper.h"
#include "mozilla/dom/RegisterBindings.h"
#include "nscore.h"
#include "nsDOMClassInfo.h"
#include "nsIDOMClassInfo.h"
#include "nsCRT.h"
#include "nsCRTGlue.h"
#include "nsICategoryManager.h"
#include "nsIComponentRegistrar.h"
#include "nsXPCOM.h"
#include "nsISimpleEnumerator.h"
#include "nsISupportsPrimitives.h"
#include "nsIXPConnect.h"
#include "xptcall.h"
#include "nsTArray.h"
// General helper includes
#include "nsGlobalWindow.h"
#include "nsIContent.h"
#include "nsIDocument.h"
#include "nsIDOMDocument.h"
#include "nsIDOMEvent.h"
#include "nsIDOMEventListener.h"
#include "nsContentUtils.h"
#include "nsIDOMGlobalPropertyInitializer.h"
#include "mozilla/Attributes.h"
#include "mozilla/Telemetry.h"
// Window scriptable helper includes
#include "nsScriptNameSpaceManager.h"
// DOM base includes
#include "nsIDOMWindow.h"
#include "nsPIDOMWindow.h"
#include "nsIDOMConstructor.h"
// DOM core includes
#include "nsError.h"
#include "nsIDOMXULButtonElement.h"
#include "nsIDOMXULCheckboxElement.h"
#include "nsIDOMXULPopupElement.h"
// Event related includes
#include "nsIDOMEventTarget.h"
// CSS related includes
#include "nsIDOMCSSRule.h"
#include "nsMemory.h"
// includes needed for the prototype chain interfaces
#include "nsIEventListenerService.h"
#include "nsIMessageManager.h"
#include "mozilla/dom/TouchEvent.h"
#include "nsWrapperCacheInlines.h"
#include "mozilla/dom/HTMLCollectionBinding.h"
#include "nsDebug.h"
#include "mozilla/dom/BindingUtils.h"
#include "mozilla/Likely.h"
#include "nsIInterfaceInfoManager.h"
#ifdef MOZ_TIME_MANAGER
#include "TimeManager.h"
#endif
using namespace mozilla;
using namespace mozilla::dom;
// NOTE: DEFAULT_SCRIPTABLE_FLAGS and DOM_DEFAULT_SCRIPTABLE_FLAGS
// are defined in nsIDOMClassInfo.h.
#define DOMCLASSINFO_STANDARD_FLAGS \
(nsIClassInfo::MAIN_THREAD_ONLY | \
nsIClassInfo::DOM_OBJECT | \
nsIClassInfo::SINGLETON_CLASSINFO)
#ifdef DEBUG
#define NS_DEFINE_CLASSINFO_DATA_DEBUG(_class) \
eDOMClassInfo_##_class##_id,
#else
#define NS_DEFINE_CLASSINFO_DATA_DEBUG(_class) \
// nothing
#endif
#define NS_DEFINE_CLASSINFO_DATA_HELPER(_class, _helper, _flags, \
_chromeOnly, _allowXBL) \
{ nullptr, \
XPC_MAKE_CLASS_OPS(_flags), \
XPC_MAKE_CLASS(#_class, _flags, \
&sClassInfoData[eDOMClassInfo_##_class##_id].mClassOps), \
_helper::doCreate, \
nullptr, \
nullptr, \
nullptr, \
_flags, \
true, \
_chromeOnly, \
_allowXBL, \
false, \
NS_DEFINE_CLASSINFO_DATA_DEBUG(_class) \
},
#define NS_DEFINE_CLASSINFO_DATA(_class, _helper, _flags) \
NS_DEFINE_CLASSINFO_DATA_HELPER(_class, _helper, _flags, false, false)
#define NS_DEFINE_CHROME_ONLY_CLASSINFO_DATA(_class, _helper, _flags) \
NS_DEFINE_CLASSINFO_DATA_HELPER(_class, _helper, _flags, true, false)
#define NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(_class, _helper, _flags) \
NS_DEFINE_CLASSINFO_DATA_HELPER(_class, _helper, _flags, true, true)
// This list of NS_DEFINE_CLASSINFO_DATA macros is what gives the DOM
// classes their correct behavior when used through XPConnect. The
// arguments that are passed to NS_DEFINE_CLASSINFO_DATA are
//
// 1. Class name as it should appear in JavaScript, this name is also
// used to find the id of the class in nsDOMClassInfo
// (i.e. e<classname>_id)
// 2. Scriptable helper class
// 3. nsIClassInfo/nsIXPCScriptable flags (i.e. for GetScriptableFlags)
static nsDOMClassInfoData sClassInfoData[] = {
// Base classes
NS_DEFINE_CLASSINFO_DATA(DOMPrototype, nsDOMConstructorSH,
DOM_BASE_SCRIPTABLE_FLAGS |
XPC_SCRIPTABLE_WANT_PRECREATE |
XPC_SCRIPTABLE_WANT_RESOLVE |
XPC_SCRIPTABLE_WANT_HASINSTANCE |
XPC_SCRIPTABLE_DONT_ENUM_QUERY_INTERFACE)
NS_DEFINE_CLASSINFO_DATA(DOMConstructor, nsDOMConstructorSH,
DOM_BASE_SCRIPTABLE_FLAGS |
XPC_SCRIPTABLE_WANT_PRECREATE |
XPC_SCRIPTABLE_WANT_RESOLVE |
XPC_SCRIPTABLE_WANT_HASINSTANCE |
XPC_SCRIPTABLE_WANT_CALL |
XPC_SCRIPTABLE_WANT_CONSTRUCT |
XPC_SCRIPTABLE_DONT_ENUM_QUERY_INTERFACE)
// Misc Core related classes
NS_DEFINE_CHROME_ONLY_CLASSINFO_DATA(ContentFrameMessageManager,
nsMessageManagerSH<nsEventTargetSH>,
DOM_DEFAULT_SCRIPTABLE_FLAGS |
XPC_SCRIPTABLE_WANT_ENUMERATE |
XPC_SCRIPTABLE_IS_GLOBAL_OBJECT)
NS_DEFINE_CHROME_ONLY_CLASSINFO_DATA(ContentProcessMessageManager,
nsMessageManagerSH<nsDOMGenericSH>,
DOM_DEFAULT_SCRIPTABLE_FLAGS |
XPC_SCRIPTABLE_WANT_ENUMERATE |
XPC_SCRIPTABLE_IS_GLOBAL_OBJECT)
NS_DEFINE_CHROME_ONLY_CLASSINFO_DATA(ChromeMessageBroadcaster, nsDOMGenericSH,
DOM_DEFAULT_SCRIPTABLE_FLAGS)
NS_DEFINE_CHROME_ONLY_CLASSINFO_DATA(ChromeMessageSender, nsDOMGenericSH,
DOM_DEFAULT_SCRIPTABLE_FLAGS)
NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(XULControlElement, nsDOMGenericSH,
DOM_DEFAULT_SCRIPTABLE_FLAGS)
NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(XULLabeledControlElement, nsDOMGenericSH,
DOM_DEFAULT_SCRIPTABLE_FLAGS)
NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(XULButtonElement, nsDOMGenericSH,
DOM_DEFAULT_SCRIPTABLE_FLAGS)
NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(XULCheckboxElement, nsDOMGenericSH,
DOM_DEFAULT_SCRIPTABLE_FLAGS)
NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(XULPopupElement, nsDOMGenericSH,
DOM_DEFAULT_SCRIPTABLE_FLAGS)
};
nsIXPConnect *nsDOMClassInfo::sXPConnect = nullptr;
bool nsDOMClassInfo::sIsInitialized = false;
jsid nsDOMClassInfo::sConstructor_id = JSID_VOID;
jsid nsDOMClassInfo::sWrappedJSObject_id = JSID_VOID;
static const JSClass *sObjectClass = nullptr;
/**
* Set our JSClass pointer for the Object class
*/
static void
FindObjectClass(JSContext* cx, JSObject* aGlobalObject)
{
NS_ASSERTION(!sObjectClass,
"Double set of sObjectClass");
JS::Rooted<JSObject*> obj(cx), proto(cx, aGlobalObject);
do {
obj = proto;
js::GetObjectProto(cx, obj, &proto);
} while (proto);
sObjectClass = js::GetObjectJSClass(obj);
}
// Helper to handle torn-down inner windows.
static inline nsresult
SetParentToWindow(nsGlobalWindow *win, JSObject **parent)
{
MOZ_ASSERT(win);
MOZ_ASSERT(win->IsInnerWindow());
*parent = win->FastGetGlobalJSObject();
if (MOZ_UNLIKELY(!*parent)) {
// The inner window has been torn down. The scope is dying, so don't create
// any new wrappers.
return NS_ERROR_FAILURE;
}
return NS_OK;
}
nsresult
nsDOMClassInfo::DefineStaticJSVals()
{
AutoJSAPI jsapi;
if (!jsapi.Init(xpc::UnprivilegedJunkScope())) {
return NS_ERROR_UNEXPECTED;
}
JSContext* cx = jsapi.cx();
#define SET_JSID_TO_STRING(_id, _cx, _str) \
if (JSString *str = ::JS_AtomizeAndPinString(_cx, _str)) \
_id = INTERNED_STRING_TO_JSID(_cx, str); \
else \
return NS_ERROR_OUT_OF_MEMORY;
SET_JSID_TO_STRING(sConstructor_id, cx, "constructor");
SET_JSID_TO_STRING(sWrappedJSObject_id, cx, "wrappedJSObject");
return NS_OK;
}
// static
bool
nsDOMClassInfo::ObjectIsNativeWrapper(JSContext* cx, JSObject* obj)
{
return xpc::WrapperFactory::IsXrayWrapper(obj) &&
xpc::AccessCheck::wrapperSubsumes(obj);
}
nsDOMClassInfo::nsDOMClassInfo(nsDOMClassInfoData* aData) : mData(aData)
{
}
NS_IMPL_ADDREF(nsDOMClassInfo)
NS_IMPL_RELEASE(nsDOMClassInfo)
NS_INTERFACE_MAP_BEGIN(nsDOMClassInfo)
if (aIID.Equals(NS_GET_IID(nsXPCClassInfo)))
foundInterface = static_cast<nsIClassInfo*>(
static_cast<nsXPCClassInfo*>(this));
else
NS_INTERFACE_MAP_ENTRY(nsIXPCScriptable)
NS_INTERFACE_MAP_ENTRY(nsIClassInfo)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIClassInfo)
NS_INTERFACE_MAP_END
static const JSClass sDOMConstructorProtoClass = {
"DOM Constructor.prototype", 0
};
static const char *
CutPrefix(const char *aName) {
static const char prefix_nsIDOM[] = "nsIDOM";
static const char prefix_nsI[] = "nsI";
if (strncmp(aName, prefix_nsIDOM, sizeof(prefix_nsIDOM) - 1) == 0) {
return aName + sizeof(prefix_nsIDOM) - 1;
}
if (strncmp(aName, prefix_nsI, sizeof(prefix_nsI) - 1) == 0) {
return aName + sizeof(prefix_nsI) - 1;
}
return aName;
}
// static
nsresult
nsDOMClassInfo::RegisterClassProtos(int32_t aClassInfoID)
{
nsScriptNameSpaceManager *nameSpaceManager = GetNameSpaceManager();
NS_ENSURE_TRUE(nameSpaceManager, NS_ERROR_NOT_INITIALIZED);
bool found_old;
const nsIID *primary_iid = sClassInfoData[aClassInfoID].mProtoChainInterface;
if (!primary_iid || primary_iid == &NS_GET_IID(nsISupports)) {
return NS_OK;
}
nsCOMPtr<nsIInterfaceInfoManager>
iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID));
NS_ENSURE_TRUE(iim, NS_ERROR_NOT_AVAILABLE);
nsCOMPtr<nsIInterfaceInfo> if_info;
bool first = true;
iim->GetInfoForIID(primary_iid, getter_AddRefs(if_info));
while (if_info) {
const nsIID *iid = nullptr;
if_info->GetIIDShared(&iid);
NS_ENSURE_TRUE(iid, NS_ERROR_UNEXPECTED);
if (iid->Equals(NS_GET_IID(nsISupports))) {
break;
}
const char *name = nullptr;
if_info->GetNameShared(&name);
NS_ENSURE_TRUE(name, NS_ERROR_UNEXPECTED);
nameSpaceManager->RegisterClassProto(CutPrefix(name), iid, &found_old);
if (first) {
first = false;
} else if (found_old) {
break;
}
nsCOMPtr<nsIInterfaceInfo> tmp(if_info);
tmp->GetParent(getter_AddRefs(if_info));
}
return NS_OK;
}
#define _DOM_CLASSINFO_MAP_BEGIN(_class, _ifptr, _has_class_if) \
{ \
nsDOMClassInfoData &d = sClassInfoData[eDOMClassInfo_##_class##_id]; \
d.mProtoChainInterface = _ifptr; \
d.mHasClassInterface = _has_class_if; \
static const nsIID *interface_list[] = {
#define DOM_CLASSINFO_MAP_BEGIN(_class, _interface) \
_DOM_CLASSINFO_MAP_BEGIN(_class, &NS_GET_IID(_interface), true)
#define DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(_class, _interface) \
_DOM_CLASSINFO_MAP_BEGIN(_class, &NS_GET_IID(_interface), false)
#define DOM_CLASSINFO_MAP_ENTRY(_if) \
&NS_GET_IID(_if),
#define DOM_CLASSINFO_MAP_CONDITIONAL_ENTRY(_if, _cond) \
(_cond) ? &NS_GET_IID(_if) : nullptr,
#define DOM_CLASSINFO_MAP_END \
nullptr \
}; \
\
/* Compact the interface list */ \
size_t count = ArrayLength(interface_list); \
/* count is the number of array entries, which is one greater than the */ \
/* number of interfaces due to the terminating null */ \
for (size_t i = 0; i < count - 1; ++i) { \
if (!interface_list[i]) { \
/* We are moving the element at index i+1 and successors, */ \
/* so we must move only count - (i+1) elements total. */ \
memmove(&interface_list[i], &interface_list[i+1], \
sizeof(nsIID*) * (count - (i+1))); \
/* Make sure to examine the new pointer we ended up with at this */ \
/* slot, since it may be null too */ \
--i; \
--count; \
} \
} \
\
d.mInterfaces = interface_list; \
}
nsresult
nsDOMClassInfo::Init()
{
/* Errors that can trigger early returns are done first,
otherwise nsDOMClassInfo is left in a half inited state. */
static_assert(sizeof(uintptr_t) == sizeof(void*),
"BAD! You'll need to adjust the size of uintptr_t to the "
"size of a pointer on your platform.");
NS_ENSURE_TRUE(!sIsInitialized, NS_ERROR_ALREADY_INITIALIZED);
nsScriptNameSpaceManager *nameSpaceManager = GetNameSpaceManager();
NS_ENSURE_TRUE(nameSpaceManager, NS_ERROR_NOT_INITIALIZED);
NS_ADDREF(sXPConnect = nsContentUtils::XPConnect());
nsCOMPtr<nsIXPCFunctionThisTranslator> elt = new nsEventListenerThisTranslator();
sXPConnect->SetFunctionThisTranslator(NS_GET_IID(nsIDOMEventListener), elt);
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(DOMPrototype, nsIDOMDOMConstructor)
DOM_CLASSINFO_MAP_ENTRY(nsIDOMDOMConstructor)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN(DOMConstructor, nsIDOMDOMConstructor)
DOM_CLASSINFO_MAP_ENTRY(nsIDOMDOMConstructor)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(ContentFrameMessageManager, nsISupports)
DOM_CLASSINFO_MAP_ENTRY(nsIDOMEventTarget)
DOM_CLASSINFO_MAP_ENTRY(nsIMessageListenerManager)
DOM_CLASSINFO_MAP_ENTRY(nsIMessageSender)
DOM_CLASSINFO_MAP_ENTRY(nsISyncMessageSender)
DOM_CLASSINFO_MAP_ENTRY(nsIContentFrameMessageManager)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(ContentProcessMessageManager, nsISupports)
DOM_CLASSINFO_MAP_ENTRY(nsIMessageListenerManager)
DOM_CLASSINFO_MAP_ENTRY(nsIMessageSender)
DOM_CLASSINFO_MAP_ENTRY(nsISyncMessageSender)
DOM_CLASSINFO_MAP_ENTRY(nsIContentProcessMessageManager)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(ChromeMessageBroadcaster, nsISupports)
DOM_CLASSINFO_MAP_ENTRY(nsIFrameScriptLoader)
DOM_CLASSINFO_MAP_ENTRY(nsIProcessScriptLoader)
DOM_CLASSINFO_MAP_ENTRY(nsIGlobalProcessScriptLoader)
DOM_CLASSINFO_MAP_ENTRY(nsIMessageListenerManager)
DOM_CLASSINFO_MAP_ENTRY(nsIMessageBroadcaster)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(ChromeMessageSender, nsISupports)
DOM_CLASSINFO_MAP_ENTRY(nsIFrameScriptLoader)
DOM_CLASSINFO_MAP_ENTRY(nsIProcessScriptLoader)
DOM_CLASSINFO_MAP_ENTRY(nsIMessageListenerManager)
DOM_CLASSINFO_MAP_ENTRY(nsIMessageSender)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(XULControlElement, nsIDOMXULControlElement)
DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULControlElement)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(XULLabeledControlElement, nsIDOMXULLabeledControlElement)
DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULLabeledControlElement)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(XULButtonElement, nsIDOMXULButtonElement)
DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULButtonElement)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(XULCheckboxElement, nsIDOMXULCheckboxElement)
DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULCheckboxElement)
DOM_CLASSINFO_MAP_END
DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(XULPopupElement, nsIDOMXULPopupElement)
DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULPopupElement)
DOM_CLASSINFO_MAP_END
static_assert(MOZ_ARRAY_LENGTH(sClassInfoData) == eDOMClassInfoIDCount,
"The number of items in sClassInfoData doesn't match the "
"number of nsIDOMClassInfo ID's, this is bad! Fix it!");
#ifdef DEBUG
for (size_t i = 0; i < eDOMClassInfoIDCount; i++) {
if (!sClassInfoData[i].mConstructorFptr ||
sClassInfoData[i].mDebugID != i) {
MOZ_CRASH("Class info data out of sync, you forgot to update "
"nsDOMClassInfo.h and nsDOMClassInfo.cpp! Fix this, "
"mozilla will not work without this fixed!");
}
}
for (size_t i = 0; i < eDOMClassInfoIDCount; i++) {
if (!sClassInfoData[i].mInterfaces) {
MOZ_CRASH("Class info data without an interface list! Fix this, "
"mozilla will not work without this fixed!");
}
}
#endif
// Initialize static JSString's
DefineStaticJSVals();
int32_t i;
for (i = 0; i < eDOMClassInfoIDCount; ++i) {
if (i == eDOMClassInfo_DOMPrototype_id) {
continue;
}
nsDOMClassInfoData& data = sClassInfoData[i];
nameSpaceManager->RegisterClassName(data.mClass.name, i, data.mChromeOnly,
data.mAllowXBL, &data.mNameUTF16);
}
for (i = 0; i < eDOMClassInfoIDCount; ++i) {
RegisterClassProtos(i);
}
sIsInitialized = true;
return NS_OK;
}
NS_IMETHODIMP
nsDOMClassInfo::GetInterfaces(uint32_t *aCount, nsIID ***aArray)
{
uint32_t count = 0;
while (mData->mInterfaces[count]) {
count++;
}
*aCount = count;
if (!count) {
*aArray = nullptr;
return NS_OK;
}
*aArray = static_cast<nsIID **>(moz_xmalloc(count * sizeof(nsIID *)));
NS_ENSURE_TRUE(*aArray, NS_ERROR_OUT_OF_MEMORY);
uint32_t i;
for (i = 0; i < count; i++) {
nsIID *iid = static_cast<nsIID *>(nsMemory::Clone(mData->mInterfaces[i],
sizeof(nsIID)));
if (!iid) {
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, *aArray);
return NS_ERROR_OUT_OF_MEMORY;
}
*((*aArray) + i) = iid;
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMClassInfo::GetScriptableHelper(nsIXPCScriptable **_retval)
{
nsCOMPtr<nsIXPCScriptable> rval = this;
rval.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
nsDOMClassInfo::GetContractID(char **aContractID)
{
*aContractID = nullptr;
return NS_OK;
}
NS_IMETHODIMP
nsDOMClassInfo::GetClassDescription(char **aClassDescription)
{
return GetClassName(aClassDescription);
}
NS_IMETHODIMP
nsDOMClassInfo::GetClassID(nsCID **aClassID)
{
*aClassID = nullptr;
return NS_OK;
}
NS_IMETHODIMP
nsDOMClassInfo::GetClassIDNoAlloc(nsCID *aClassID)
{
return NS_ERROR_NOT_AVAILABLE;
}
NS_IMETHODIMP
nsDOMClassInfo::GetFlags(uint32_t *aFlags)
{
*aFlags = DOMCLASSINFO_STANDARD_FLAGS;
return NS_OK;
}
// nsIXPCScriptable
NS_IMETHODIMP
nsDOMClassInfo::GetClassName(char **aClassName)
{
*aClassName = NS_strdup(mData->mClass.name);
return NS_OK;
}
// virtual
uint32_t
nsDOMClassInfo::GetScriptableFlags()
{
return mData->mScriptableFlags;
}
// virtual
const js::Class*
nsDOMClassInfo::GetClass()
{
return &mData->mClass;
}
// virtual
const JSClass*
nsDOMClassInfo::GetJSClass()
{
return Jsvalify(&mData->mClass);
}
NS_IMETHODIMP
nsDOMClassInfo::PreCreate(nsISupports *nativeObj, JSContext *cx,
JSObject *globalObj, JSObject **parentObj)
{
*parentObj = globalObj;
return NS_OK;
}
NS_IMETHODIMP
nsDOMClassInfo::Enumerate(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *obj, bool *_retval)
{
return NS_OK;
}
NS_IMETHODIMP
nsDOMClassInfo::NewEnumerate(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *obj, JS::AutoIdVector &properties,
bool *_retval)
{
NS_WARNING("nsDOMClassInfo::NewEnumerate Don't call me!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsDOMClassInfo::Resolve(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *aObj, jsid aId, bool *resolvedp, bool *_retval)
{
JS::Rooted<JSObject*> obj(cx, aObj);
JS::Rooted<jsid> id(cx, aId);
if (id != sConstructor_id) {
*resolvedp = false;
return NS_OK;
}
JS::Rooted<JSObject*> global(cx, ::JS_GetGlobalForObject(cx, obj));
JS::Rooted<JS::PropertyDescriptor> desc(cx);
if (!JS_GetPropertyDescriptor(cx, global, mData->mClass.name, &desc)) {
return NS_ERROR_UNEXPECTED;
}
if (desc.object() && !desc.hasGetterOrSetter() && desc.value().isObject()) {
// If val is not an (non-null) object there either is no
// constructor for this class, or someone messed with
// window.classname, just fall through and let the JS engine
// return the Object constructor.
if (!::JS_DefinePropertyById(cx, obj, id, desc.value(),
JSPROP_ENUMERATE)) {
return NS_ERROR_UNEXPECTED;
}
*resolvedp = true;
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMClassInfo::Finalize(nsIXPConnectWrappedNative *wrapper, JSFreeOp *fop,
JSObject *obj)
{
NS_WARNING("nsDOMClassInfo::Finalize Don't call me!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsDOMClassInfo::Call(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *obj, const JS::CallArgs &args, bool *_retval)
{
NS_WARNING("nsDOMClassInfo::Call Don't call me!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsDOMClassInfo::Construct(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *obj, const JS::CallArgs &args,
bool *_retval)
{
NS_WARNING("nsDOMClassInfo::Construct Don't call me!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHODIMP
nsDOMClassInfo::HasInstance(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *obj, JS::Handle<JS::Value> val, bool *bp,
bool *_retval)
{
NS_WARNING("nsDOMClassInfo::HasInstance Don't call me!");
return NS_ERROR_UNEXPECTED;
}
static nsresult
ResolvePrototype(nsIXPConnect *aXPConnect, nsGlobalWindow *aWin, JSContext *cx,
JS::Handle<JSObject*> obj, const char16_t *name,
const nsDOMClassInfoData *ci_data,
const nsGlobalNameStruct *name_struct,
nsScriptNameSpaceManager *nameSpaceManager,
JSObject *dot_prototype,
JS::MutableHandle<JS::PropertyDescriptor> ctorDesc);
NS_IMETHODIMP
nsDOMClassInfo::PostCreatePrototype(JSContext * cx, JSObject * aProto)
{
JS::Rooted<JSObject*> proto(cx, aProto);
// This is called before any other location that requires
// sObjectClass, so compute it here. We assume that nobody has had a
// chance to monkey around with proto's prototype chain before this.
if (!sObjectClass) {
FindObjectClass(cx, proto);
NS_ASSERTION(sObjectClass && !strcmp(sObjectClass->name, "Object"),
"Incorrect object class!");
}
#ifdef DEBUG
JS::Rooted<JSObject*> proto2(cx);
JS_GetPrototype(cx, proto, &proto2);
NS_ASSERTION(proto2 && JS_GetClass(proto2) == sObjectClass,
"Hmm, somebody did something evil?");
#endif
#ifdef DEBUG
if (mData->mHasClassInterface && mData->mProtoChainInterface &&
mData->mProtoChainInterface != &NS_GET_IID(nsISupports)) {
nsCOMPtr<nsIInterfaceInfoManager>
iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID));
if (iim) {
nsCOMPtr<nsIInterfaceInfo> if_info;
iim->GetInfoForIID(mData->mProtoChainInterface,
getter_AddRefs(if_info));
if (if_info) {
nsCString name;
if_info->GetName(getter_Copies(name));
NS_ASSERTION(nsCRT::strcmp(CutPrefix(name.get()), mData->mClass.name) == 0,
"Class name and proto chain interface name mismatch!");
}
}
}
#endif
// Make prototype delegation work correctly. Consider if a site sets
// HTMLElement.prototype.foopy = function () { ... } Now, calling
// document.body.foopy() needs to ensure that looking up foopy on
// document.body's prototype will find the right function.
JS::Rooted<JSObject*> global(cx, ::JS_GetGlobalForObject(cx, proto));
// Only do this if the global object is a window.
nsGlobalWindow* win;
if (NS_FAILED(UNWRAP_OBJECT(Window, &global, win))) {
// Not a window.
return NS_OK;
}
if (win->IsClosedOrClosing()) {
return NS_OK;
}
// Don't overwrite a property set by content.
bool contentDefinedProperty;
if (!::JS_AlreadyHasOwnUCProperty(cx, global, reinterpret_cast<const char16_t*>(mData->mNameUTF16),
NS_strlen(mData->mNameUTF16),
&contentDefinedProperty)) {
return NS_ERROR_FAILURE;
}
nsScriptNameSpaceManager *nameSpaceManager = GetNameSpaceManager();
NS_ENSURE_TRUE(nameSpaceManager, NS_OK);
JS::Rooted<JS::PropertyDescriptor> desc(cx);
nsresult rv = ResolvePrototype(sXPConnect, win, cx, global, mData->mNameUTF16,
mData, nullptr, nameSpaceManager, proto,
&desc);
NS_ENSURE_SUCCESS(rv, rv);
if (!contentDefinedProperty && desc.object() && !desc.value().isUndefined()) {
desc.attributesRef() |= JSPROP_RESOLVING;
if (!JS_DefineUCProperty(cx, global, mData->mNameUTF16,
NS_strlen(mData->mNameUTF16), desc)) {
return NS_ERROR_UNEXPECTED;
}
}
return NS_OK;
}
// static
nsIClassInfo *
NS_GetDOMClassInfoInstance(nsDOMClassInfoID aID)
{
if (aID >= eDOMClassInfoIDCount) {
NS_ERROR("Bad ID!");
return nullptr;
}
nsresult rv = RegisterDOMNames();
NS_ENSURE_SUCCESS(rv, nullptr);
if (!sClassInfoData[aID].mCachedClassInfo) {
nsDOMClassInfoData& data = sClassInfoData[aID];
data.mCachedClassInfo = data.mConstructorFptr(&data);
NS_ENSURE_TRUE(data.mCachedClassInfo, nullptr);
NS_ADDREF(data.mCachedClassInfo);
}
return sClassInfoData[aID].mCachedClassInfo;
}
// static
void
nsDOMClassInfo::ShutDown()
{
if (sClassInfoData[0].mConstructorFptr) {
uint32_t i;
for (i = 0; i < eDOMClassInfoIDCount; i++) {
NS_IF_RELEASE(sClassInfoData[i].mCachedClassInfo);
}
}
sConstructor_id = JSID_VOID;
sWrappedJSObject_id = JSID_VOID;
NS_IF_RELEASE(sXPConnect);
sIsInitialized = false;
}
static nsresult
BaseStubConstructor(nsIWeakReference* aWeakOwner,
const nsGlobalNameStruct *name_struct, JSContext *cx,
JS::Handle<JSObject*> obj, const JS::CallArgs &args)
{
MOZ_ASSERT(obj);
MOZ_ASSERT(cx == nsContentUtils::GetCurrentJSContext());
nsresult rv;
nsCOMPtr<nsISupports> native;
if (name_struct->mType == nsGlobalNameStruct::eTypeClassConstructor) {
rv = NS_ERROR_NOT_AVAILABLE;
} else {
MOZ_ASSERT(name_struct->mType ==
nsGlobalNameStruct::eTypeExternalConstructor);
native = do_CreateInstance(name_struct->mCID, &rv);
}
if (NS_FAILED(rv)) {
NS_ERROR("Failed to create the object");
return rv;
}
js::AssertSameCompartment(cx, obj);
return nsContentUtils::WrapNative(cx, native, args.rval(), true);
}
static nsresult
DefineInterfaceConstants(JSContext *cx, JS::Handle<JSObject*> obj, const nsIID *aIID)
{
nsCOMPtr<nsIInterfaceInfoManager>
iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID));
NS_ENSURE_TRUE(iim, NS_ERROR_UNEXPECTED);
nsCOMPtr<nsIInterfaceInfo> if_info;
nsresult rv = iim->GetInfoForIID(aIID, getter_AddRefs(if_info));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && if_info, rv);
uint16_t constant_count;
if_info->GetConstantCount(&constant_count);
if (!constant_count) {
return NS_OK;
}
nsCOMPtr<nsIInterfaceInfo> parent_if_info;
rv = if_info->GetParent(getter_AddRefs(parent_if_info));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && parent_if_info, rv);
uint16_t parent_constant_count, i;
parent_if_info->GetConstantCount(&parent_constant_count);
JS::Rooted<JS::Value> v(cx);
for (i = parent_constant_count; i < constant_count; i++) {
nsCString name;
rv = if_info->GetConstant(i, &v, getter_Copies(name));
NS_ENSURE_TRUE(NS_SUCCEEDED(rv), rv);
if (!::JS_DefineProperty(cx, obj, name.get(), v,
JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT)) {
return NS_ERROR_UNEXPECTED;
}
}
return NS_OK;
}
class nsDOMConstructor final : public nsIDOMDOMConstructor
{
protected:
nsDOMConstructor(const char16_t* aName,
bool aIsConstructable,
nsPIDOMWindowInner* aOwner)
: mClassName(aName),
mConstructable(aIsConstructable),
mWeakOwner(do_GetWeakReference(aOwner))
{
}
~nsDOMConstructor() {}
public:
static nsresult Create(const char16_t* aName,
const nsGlobalNameStruct* aNameStruct,
nsPIDOMWindowInner* aOwner,
nsDOMConstructor** aResult);
NS_DECL_ISUPPORTS
NS_DECL_NSIDOMDOMCONSTRUCTOR
nsresult PreCreate(JSContext *cx, JSObject *globalObj, JSObject **parentObj);
nsresult Construct(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JS::Handle<JSObject*> obj, const JS::CallArgs &args,
bool *_retval);
nsresult HasInstance(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JS::Handle<JSObject*> obj, const JS::Value &val, bool *bp,
bool *_retval);
nsresult ResolveInterfaceConstants(JSContext *cx, JS::Handle<JSObject*> obj);
private:
const nsGlobalNameStruct *GetNameStruct()
{
if (!mClassName) {
NS_ERROR("Can't get name");
return nullptr;
}
const nsGlobalNameStruct *nameStruct;
#ifdef DEBUG
nsresult rv =
#endif
GetNameStruct(nsDependentString(mClassName), &nameStruct);
NS_ASSERTION(NS_FAILED(rv) || nameStruct, "Name isn't in hash.");
return nameStruct;
}
static nsresult GetNameStruct(const nsAString& aName,
const nsGlobalNameStruct **aNameStruct)
{
*aNameStruct = nullptr;
nsScriptNameSpaceManager *nameSpaceManager = GetNameSpaceManager();
if (!nameSpaceManager) {
NS_ERROR("Can't get namespace manager.");
return NS_ERROR_UNEXPECTED;
}
*aNameStruct = nameSpaceManager->LookupName(aName);
// Return NS_OK here, aName just isn't a DOM class but nothing failed.
return NS_OK;
}
static bool IsConstructable(const nsGlobalNameStruct *aNameStruct)
{
return aNameStruct->mType == nsGlobalNameStruct::eTypeExternalConstructor;
}
const char16_t* mClassName;
const bool mConstructable;
nsWeakPtr mWeakOwner;
};
//static
nsresult
nsDOMConstructor::Create(const char16_t* aName,
const nsGlobalNameStruct* aNameStruct,
nsPIDOMWindowInner* aOwner,
nsDOMConstructor** aResult)
{
*aResult = nullptr;
// Prevent creating a constructor if aOwner is inner window which doesn't have
// an outer window. If the outer window doesn't have an inner window or the
// caller can't access the outer window's current inner window then try to use
// the owner (so long as it is, in fact, an inner window). If that doesn't
// work then prevent creation also.
nsPIDOMWindowOuter* outerWindow = aOwner->GetOuterWindow();
nsPIDOMWindowInner* currentInner =
outerWindow ? outerWindow->GetCurrentInnerWindow() : aOwner;
if (!currentInner ||
(aOwner != currentInner &&
!nsContentUtils::CanCallerAccess(currentInner) &&
!(currentInner = aOwner)->IsInnerWindow())) {
return NS_ERROR_DOM_SECURITY_ERR;
}
bool constructable = aNameStruct && IsConstructable(aNameStruct);
*aResult = new nsDOMConstructor(aName, constructable, currentInner);
NS_ADDREF(*aResult);
return NS_OK;
}
NS_IMPL_ADDREF(nsDOMConstructor)
NS_IMPL_RELEASE(nsDOMConstructor)
NS_INTERFACE_MAP_BEGIN(nsDOMConstructor)
NS_INTERFACE_MAP_ENTRY(nsIDOMDOMConstructor)
NS_INTERFACE_MAP_ENTRY(nsISupports)
if (aIID.Equals(NS_GET_IID(nsIClassInfo))) {
#ifdef DEBUG
{
const nsGlobalNameStruct *name_struct = GetNameStruct();
NS_ASSERTION(!name_struct ||
mConstructable == IsConstructable(name_struct),
"Can't change constructability dynamically!");
}
#endif
foundInterface =
NS_GetDOMClassInfoInstance(mConstructable ?
eDOMClassInfo_DOMConstructor_id :
eDOMClassInfo_DOMPrototype_id);
if (!foundInterface) {
*aInstancePtr = nullptr;
return NS_ERROR_OUT_OF_MEMORY;
}
} else
NS_INTERFACE_MAP_END
nsresult
nsDOMConstructor::PreCreate(JSContext *cx, JSObject *globalObj, JSObject **parentObj)
{
nsCOMPtr<nsPIDOMWindowInner> owner(do_QueryReferent(mWeakOwner));
if (!owner) {
// Can't do anything.
return NS_OK;
}
nsGlobalWindow *win = nsGlobalWindow::Cast(owner);
return SetParentToWindow(win, parentObj);
}
nsresult
nsDOMConstructor::Construct(nsIXPConnectWrappedNative *wrapper, JSContext * cx,
JS::Handle<JSObject*> obj, const JS::CallArgs &args,
bool *_retval)
{
MOZ_ASSERT(obj);
const nsGlobalNameStruct *name_struct = GetNameStruct();
NS_ENSURE_TRUE(name_struct, NS_ERROR_FAILURE);
if (!IsConstructable(name_struct)) {
// ignore return value, we return false anyway
return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
}
return BaseStubConstructor(mWeakOwner, name_struct, cx, obj, args);
}
nsresult
nsDOMConstructor::HasInstance(nsIXPConnectWrappedNative *wrapper,
JSContext * cx, JS::Handle<JSObject*> obj,
const JS::Value &v, bool *bp, bool *_retval)
{
// No need to look these up in the hash.
*bp = false;
if (v.isPrimitive()) {
return NS_OK;
}
JS::Rooted<JSObject*> dom_obj(cx, v.toObjectOrNull());
NS_ASSERTION(dom_obj, "nsDOMConstructor::HasInstance couldn't get object");
// This might not be the right object, if there are wrappers. Unwrap if we can.
JSObject *wrapped_obj = js::CheckedUnwrap(dom_obj, /* stopAtWindowProxy = */ false);
if (wrapped_obj)
dom_obj = wrapped_obj;
const JSClass *dom_class = JS_GetClass(dom_obj);
if (!dom_class) {
NS_ERROR("nsDOMConstructor::HasInstance can't get class.");
return NS_ERROR_UNEXPECTED;
}
const nsGlobalNameStruct *name_struct;
nsresult rv = GetNameStruct(NS_ConvertASCIItoUTF16(dom_class->name), &name_struct);
if (NS_FAILED(rv)) {
return rv;
}
if (!name_struct) {
// This isn't a normal DOM object, see if this constructor lives on its
// prototype chain.
JS::Rooted<JS::PropertyDescriptor> desc(cx);
if (!JS_GetPropertyDescriptor(cx, obj, "prototype", &desc)) {
return NS_ERROR_UNEXPECTED;
}
if (!desc.object() || desc.hasGetterOrSetter() || !desc.value().isObject()) {
return NS_OK;
}
JS::Rooted<JSObject*> dot_prototype(cx, &desc.value().toObject());
JS::Rooted<JSObject*> proto(cx, dom_obj);
JSAutoCompartment ac(cx, proto);
if (!JS_WrapObject(cx, &dot_prototype)) {
return NS_ERROR_UNEXPECTED;
}
for (;;) {
if (!JS_GetPrototype(cx, proto, &proto)) {
return NS_ERROR_UNEXPECTED;
}
if (!proto) {
break;
}
if (proto == dot_prototype) {
*bp = true;
break;
}
}
return NS_OK;
}
if (name_struct->mType != nsGlobalNameStruct::eTypeClassConstructor) {
// Doesn't have DOM interfaces.
return NS_OK;
}
const nsGlobalNameStruct *class_name_struct = GetNameStruct();
NS_ENSURE_TRUE(class_name_struct, NS_ERROR_FAILURE);
if (name_struct == class_name_struct) {
*bp = true;
return NS_OK;
}
const nsIID *class_iid;
if (class_name_struct->mType == nsGlobalNameStruct::eTypeClassProto) {
class_iid = &class_name_struct->mIID;
} else if (class_name_struct->mType == nsGlobalNameStruct::eTypeClassConstructor) {
class_iid =
sClassInfoData[class_name_struct->mDOMClassInfoID].mProtoChainInterface;
} else {
*bp = false;
return NS_OK;
}
NS_ASSERTION(name_struct->mType == nsGlobalNameStruct::eTypeClassConstructor,
"The constructor was set up with a struct of the wrong type.");
const nsDOMClassInfoData *ci_data;
if (name_struct->mType == nsGlobalNameStruct::eTypeClassConstructor &&
name_struct->mDOMClassInfoID >= 0) {
ci_data = &sClassInfoData[name_struct->mDOMClassInfoID];
} else {
ci_data = nullptr;
}
nsCOMPtr<nsIInterfaceInfoManager>
iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID));
if (!iim) {
NS_ERROR("nsDOMConstructor::HasInstance can't get interface info mgr.");
return NS_ERROR_UNEXPECTED;
}
nsCOMPtr<nsIInterfaceInfo> if_info;
uint32_t count = 0;
const nsIID* class_interface;
while ((class_interface = ci_data->mInterfaces[count++])) {
if (class_iid->Equals(*class_interface)) {
*bp = true;
return NS_OK;
}
iim->GetInfoForIID(class_interface, getter_AddRefs(if_info));
if (!if_info) {
NS_ERROR("nsDOMConstructor::HasInstance can't get interface info.");
return NS_ERROR_UNEXPECTED;
}
if_info->HasAncestor(class_iid, bp);
if (*bp) {
return NS_OK;
}
}
return NS_OK;
}
nsresult
nsDOMConstructor::ResolveInterfaceConstants(JSContext *cx, JS::Handle<JSObject*> obj)
{
const nsGlobalNameStruct *class_name_struct = GetNameStruct();
if (!class_name_struct)
return NS_ERROR_UNEXPECTED;
const nsIID *class_iid;
if (class_name_struct->mType == nsGlobalNameStruct::eTypeClassProto) {
class_iid = &class_name_struct->mIID;
} else if (class_name_struct->mType == nsGlobalNameStruct::eTypeClassConstructor) {
class_iid =
sClassInfoData[class_name_struct->mDOMClassInfoID].mProtoChainInterface;
} else {
return NS_OK;
}
nsresult rv = DefineInterfaceConstants(cx, obj, class_iid);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP
nsDOMConstructor::ToString(nsAString &aResult)
{
aResult.AssignLiteral("[object ");
aResult.Append(mClassName);
aResult.Append(char16_t(']'));
return NS_OK;
}
static nsresult
GetXPCProto(nsIXPConnect *aXPConnect, JSContext *cx, nsGlobalWindow *aWin,
const nsGlobalNameStruct *aNameStruct,
JS::MutableHandle<JSObject*> aProto)
{
NS_ASSERTION(aNameStruct->mType == nsGlobalNameStruct::eTypeClassConstructor,
"Wrong type!");
int32_t id = aNameStruct->mDOMClassInfoID;
MOZ_ASSERT(id >= 0, "Negative DOM classinfo?!?");
nsDOMClassInfoID ci_id = (nsDOMClassInfoID)id;
nsCOMPtr<nsIClassInfo> ci = NS_GetDOMClassInfoInstance(ci_id);
NS_ENSURE_TRUE(ci, NS_ERROR_UNEXPECTED);
nsresult rv =
aXPConnect->GetWrappedNativePrototype(cx, aWin->GetGlobalJSObject(), ci, aProto.address());
NS_ENSURE_SUCCESS(rv, rv);
return JS_WrapObject(cx, aProto) ? NS_OK : NS_ERROR_FAILURE;
}
// Either ci_data must be non-null or name_struct must be non-null and of type
// eTypeClassProto.
static nsresult
ResolvePrototype(nsIXPConnect *aXPConnect, nsGlobalWindow *aWin, JSContext *cx,
JS::Handle<JSObject*> obj, const char16_t *name,
const nsDOMClassInfoData *ci_data,
const nsGlobalNameStruct *name_struct,
nsScriptNameSpaceManager *nameSpaceManager,
JSObject* aDot_prototype,
JS::MutableHandle<JS::PropertyDescriptor> ctorDesc)
{
JS::Rooted<JSObject*> dot_prototype(cx, aDot_prototype);
NS_ASSERTION(ci_data ||
(name_struct &&
name_struct->mType == nsGlobalNameStruct::eTypeClassProto),
"Wrong type or missing ci_data!");
RefPtr<nsDOMConstructor> constructor;
nsresult rv = nsDOMConstructor::Create(name, name_struct, aWin->AsInner(),
getter_AddRefs(constructor));
NS_ENSURE_SUCCESS(rv, rv);
JS::Rooted<JS::Value> v(cx);
js::AssertSameCompartment(cx, obj);
rv = nsContentUtils::WrapNative(cx, constructor,
&NS_GET_IID(nsIDOMDOMConstructor), &v,
false);
NS_ENSURE_SUCCESS(rv, rv);
FillPropertyDescriptor(ctorDesc, obj, 0, v);
// And make sure we wrap the value into the right compartment. Note that we
// do this with ctorDesc.value(), not with v, because we need v to be in the
// right compartment (that of the reflector of |constructor|) below.
if (!JS_WrapValue(cx, ctorDesc.value())) {
return NS_ERROR_UNEXPECTED;
}
JS::Rooted<JSObject*> class_obj(cx, &v.toObject());
const nsIID *primary_iid = &NS_GET_IID(nsISupports);
if (!ci_data) {
primary_iid = &name_struct->mIID;
}
else if (ci_data->mProtoChainInterface) {
primary_iid = ci_data->mProtoChainInterface;
}
nsCOMPtr<nsIInterfaceInfo> if_info;
nsCOMPtr<nsIInterfaceInfo> parent;
const char *class_parent_name = nullptr;
if (!primary_iid->Equals(NS_GET_IID(nsISupports))) {
JSAutoCompartment ac(cx, class_obj);
rv = DefineInterfaceConstants(cx, class_obj, primary_iid);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIInterfaceInfoManager>
iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID));
NS_ENSURE_TRUE(iim, NS_ERROR_NOT_AVAILABLE);
iim->GetInfoForIID(primary_iid, getter_AddRefs(if_info));
NS_ENSURE_TRUE(if_info, NS_ERROR_UNEXPECTED);
const nsIID *iid = nullptr;
if (ci_data && !ci_data->mHasClassInterface) {
if_info->GetIIDShared(&iid);
} else {
if_info->GetParent(getter_AddRefs(parent));
NS_ENSURE_TRUE(parent, NS_ERROR_UNEXPECTED);
parent->GetIIDShared(&iid);
}
if (iid) {
if (!iid->Equals(NS_GET_IID(nsISupports))) {
if (ci_data && !ci_data->mHasClassInterface) {
// If the class doesn't have a class interface the primary
// interface is the interface that should be
// constructor.prototype.__proto__.
if_info->GetNameShared(&class_parent_name);
} else {
// If the class does have a class interface (or there's no
// real class for this name) then the parent of the
// primary interface is what we want on
// constructor.prototype.__proto__.
NS_ASSERTION(parent, "Whoa, this is bad, null parent here!");
parent->GetNameShared(&class_parent_name);
}
}
}
}
{
JS::Rooted<JSObject*> winobj(cx, aWin->FastGetGlobalJSObject());
JS::Rooted<JSObject*> proto(cx);
if (class_parent_name) {
JSAutoCompartment ac(cx, winobj);
JS::Rooted<JS::PropertyDescriptor> desc(cx);
if (!JS_GetPropertyDescriptor(cx, winobj, CutPrefix(class_parent_name), &desc)) {
return NS_ERROR_UNEXPECTED;
}
if (desc.object() && !desc.hasGetterOrSetter() && desc.value().isObject()) {
JS::Rooted<JSObject*> obj(cx, &desc.value().toObject());
if (!JS_GetPropertyDescriptor(cx, obj, "prototype", &desc)) {
return NS_ERROR_UNEXPECTED;
}
if (desc.object() && !desc.hasGetterOrSetter() && desc.value().isObject()) {
proto = &desc.value().toObject();
}
}
}
if (dot_prototype) {
JSAutoCompartment ac(cx, dot_prototype);
JS::Rooted<JSObject*> xpc_proto_proto(cx);
if (!::JS_GetPrototype(cx, dot_prototype, &xpc_proto_proto)) {
return NS_ERROR_UNEXPECTED;
}
if (proto &&
(!xpc_proto_proto ||
JS_GetClass(xpc_proto_proto) == sObjectClass)) {
if (!JS_WrapObject(cx, &proto) ||
!JS_SetPrototype(cx, dot_prototype, proto)) {
return NS_ERROR_UNEXPECTED;
}
}
} else {
JSAutoCompartment ac(cx, winobj);
if (!proto) {
proto = JS_GetObjectPrototype(cx, winobj);
}
dot_prototype = ::JS_NewObjectWithUniqueType(cx,
&sDOMConstructorProtoClass,
proto);
NS_ENSURE_TRUE(dot_prototype, NS_ERROR_OUT_OF_MEMORY);
}
}
v.setObject(*dot_prototype);
JSAutoCompartment ac(cx, class_obj);
// Per ECMA, the prototype property is {DontEnum, DontDelete, ReadOnly}
if (!JS_WrapValue(cx, &v) ||
!JS_DefineProperty(cx, class_obj, "prototype", v,
JSPROP_PERMANENT | JSPROP_READONLY)) {
return NS_ERROR_UNEXPECTED;
}
return NS_OK;
}
static bool
OldBindingConstructorEnabled(const nsGlobalNameStruct *aStruct,
nsGlobalWindow *aWin, JSContext *cx)
{
MOZ_ASSERT(aStruct->mType == nsGlobalNameStruct::eTypeProperty ||
aStruct->mType == nsGlobalNameStruct::eTypeClassConstructor);
// Don't expose chrome only constructors to content windows.
if (aStruct->mChromeOnly) {
bool expose;
if (aStruct->mAllowXBL) {
expose = IsChromeOrXBL(cx, nullptr);
} else {
expose = nsContentUtils::IsSystemPrincipal(aWin->GetPrincipal());
}
if (!expose) {
return false;
}
}
return true;
}
static nsresult
LookupComponentsShim(JSContext *cx, JS::Handle<JSObject*> global,
nsPIDOMWindowInner *win,
JS::MutableHandle<JS::PropertyDescriptor> desc);
// static
bool
nsWindowSH::NameStructEnabled(JSContext* aCx, nsGlobalWindow *aWin,
const nsAString& aName,
const nsGlobalNameStruct& aNameStruct)
{
// DOMConstructor is special: creating its proto does not actually define it
// as a property on the global. So we don't want to expose its name either.
if (aName.EqualsLiteral("DOMConstructor")) {
return false;
}
const nsGlobalNameStruct* nameStruct = &aNameStruct;
return (nameStruct->mType != nsGlobalNameStruct::eTypeProperty &&
nameStruct->mType != nsGlobalNameStruct::eTypeClassConstructor) ||
OldBindingConstructorEnabled(nameStruct, aWin, aCx);
}
#ifdef RELEASE_OR_BETA
#define USE_CONTROLLERS_SHIM
#endif
#ifdef USE_CONTROLLERS_SHIM
static const JSClass ControllersShimClass = {
"Controllers", 0
};
static const JSClass XULControllersShimClass = {
"XULControllers", 0
};
#endif
// static
nsresult
nsWindowSH::GlobalResolve(nsGlobalWindow *aWin, JSContext *cx,
JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
JS::MutableHandle<JS::PropertyDescriptor> desc)
{
if (id == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_COMPONENTS)) {
return LookupComponentsShim(cx, obj, aWin->AsInner(), desc);
}
#ifdef USE_CONTROLLERS_SHIM
// Note: We use |obj| rather than |aWin| to get the principal here, because
// this is called during Window setup when the Document isn't necessarily
// hooked up yet.
if ((id == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_CONTROLLERS) ||
id == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_CONTROLLERS_CLASS)) &&
!xpc::IsXrayWrapper(obj) &&
!nsContentUtils::IsSystemPrincipal(nsContentUtils::ObjectPrincipal(obj)))
{
if (aWin->GetDoc()) {
aWin->GetDoc()->WarnOnceAbout(nsIDocument::eWindow_Cc_ontrollers);
}
const JSClass* clazz;
if (id == XPCJSRuntime::Get()->GetStringID(XPCJSContext::IDX_CONTROLLERS)) {
clazz = &XULControllersShimClass;
} else {
clazz = &ControllersShimClass;
}
MOZ_ASSERT(JS_IsGlobalObject(obj));
JS::Rooted<JSObject*> shim(cx, JS_NewObject(cx, clazz));
if (NS_WARN_IF(!shim)) {
return NS_ERROR_OUT_OF_MEMORY;
}
FillPropertyDescriptor(desc, obj, JS::ObjectValue(*shim), /* readOnly = */ false);
return NS_OK;
}
#endif
nsScriptNameSpaceManager *nameSpaceManager = GetNameSpaceManager();
NS_ENSURE_TRUE(nameSpaceManager, NS_ERROR_NOT_INITIALIZED);
// Note - Our only caller is nsGlobalWindow::DoResolve, which checks that
// JSID_IS_STRING(id) is true.
nsAutoJSString name;
if (!name.init(cx, JSID_TO_STRING(id))) {
return NS_ERROR_OUT_OF_MEMORY;
}
const char16_t *class_name = nullptr;
const nsGlobalNameStruct *name_struct =
nameSpaceManager->LookupName(name, &class_name);
if (!name_struct) {
return NS_OK;
}
// The class_name had better match our name
MOZ_ASSERT(name.Equals(class_name));
NS_ENSURE_TRUE(class_name, NS_ERROR_UNEXPECTED);
nsresult rv = NS_OK;
if (name_struct->mType == nsGlobalNameStruct::eTypeClassConstructor) {
if (!OldBindingConstructorEnabled(name_struct, aWin, cx)) {
return NS_OK;
}
// Create the XPConnect prototype for our classinfo, PostCreateProto will
// set up the prototype chain. This will go ahead and define things on the
// actual window's global.
JS::Rooted<JSObject*> dot_prototype(cx);
rv = GetXPCProto(nsDOMClassInfo::sXPConnect, cx, aWin, name_struct,
&dot_prototype);
NS_ENSURE_SUCCESS(rv, rv);
MOZ_ASSERT(dot_prototype);
bool isXray = xpc::WrapperFactory::IsXrayWrapper(obj);
MOZ_ASSERT_IF(obj != aWin->GetGlobalJSObject(), isXray);
if (!isXray) {
// GetXPCProto already defined the property for us
FillPropertyDescriptor(desc, obj, JS::UndefinedValue(), false);
return NS_OK;
}
// This is the Xray case. Look up the constructor object for this
// prototype.
return ResolvePrototype(nsDOMClassInfo::sXPConnect, aWin, cx, obj,
class_name,
&sClassInfoData[name_struct->mDOMClassInfoID],
name_struct, nameSpaceManager, dot_prototype,
desc);
}
if (name_struct->mType == nsGlobalNameStruct::eTypeClassProto) {
// We don't have a XPConnect prototype object, let ResolvePrototype create
// one.
return ResolvePrototype(nsDOMClassInfo::sXPConnect, aWin, cx, obj,
class_name, nullptr,
name_struct, nameSpaceManager, nullptr, desc);
}
if (name_struct->mType == nsGlobalNameStruct::eTypeExternalConstructor) {
RefPtr<nsDOMConstructor> constructor;
rv = nsDOMConstructor::Create(class_name, name_struct, aWin->AsInner(),
getter_AddRefs(constructor));
NS_ENSURE_SUCCESS(rv, rv);
JS::Rooted<JS::Value> val(cx);
js::AssertSameCompartment(cx, obj);
rv = nsContentUtils::WrapNative(cx, constructor,
&NS_GET_IID(nsIDOMDOMConstructor), &val,
true);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(val.isObject(), "Why didn't we get a JSObject?");
FillPropertyDescriptor(desc, obj, 0, val);
return NS_OK;
}
if (name_struct->mType == nsGlobalNameStruct::eTypeProperty) {
if (!OldBindingConstructorEnabled(name_struct, aWin, cx))
return NS_OK;
// Before defining a global property, check for a named subframe of the
// same name. If it exists, we don't want to shadow it.
if (nsCOMPtr<nsPIDOMWindowOuter> childWin = aWin->GetChildWindow(name)) {
return NS_OK;
}
nsCOMPtr<nsISupports> native(do_CreateInstance(name_struct->mCID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
JS::Rooted<JS::Value> prop_val(cx, JS::UndefinedValue()); // Property value.
nsCOMPtr<nsIDOMGlobalPropertyInitializer> gpi(do_QueryInterface(native));
if (gpi) {
rv = gpi->Init(aWin->AsInner(), &prop_val);
NS_ENSURE_SUCCESS(rv, rv);
}
if (prop_val.isPrimitive() && !prop_val.isNull()) {
rv = nsContentUtils::WrapNative(cx, native, &prop_val, true);
}
NS_ENSURE_SUCCESS(rv, rv);
if (!JS_WrapValue(cx, &prop_val)) {
return NS_ERROR_UNEXPECTED;
}
FillPropertyDescriptor(desc, obj, prop_val, false);
return NS_OK;
}
return rv;
}
struct InterfaceShimEntry {
const char *geckoName;
const char *domName;
};
// We add shims from Components.interfaces.nsIDOMFoo to window.Foo for each
// interface that has interface constants that sites might be getting off
// of Ci.
const InterfaceShimEntry kInterfaceShimMap[] =
{ { "nsIXMLHttpRequest", "XMLHttpRequest" },
{ "nsIDOMDOMException", "DOMException" },
{ "nsIDOMNode", "Node" },
{ "nsIDOMCSSPrimitiveValue", "CSSPrimitiveValue" },
{ "nsIDOMCSSRule", "CSSRule" },
{ "nsIDOMCSSValue", "CSSValue" },
{ "nsIDOMEvent", "Event" },
{ "nsIDOMNSEvent", "Event" },
{ "nsIDOMKeyEvent", "KeyEvent" },
{ "nsIDOMMouseEvent", "MouseEvent" },
{ "nsIDOMMouseScrollEvent", "MouseScrollEvent" },
{ "nsIDOMMutationEvent", "MutationEvent" },
{ "nsIDOMSimpleGestureEvent", "SimpleGestureEvent" },
{ "nsIDOMUIEvent", "UIEvent" },
{ "nsIDOMHTMLMediaElement", "HTMLMediaElement" },
{ "nsIDOMOfflineResourceList", "OfflineResourceList" },
{ "nsIDOMRange", "Range" },
{ "nsIDOMSVGLength", "SVGLength" },
{ "nsIDOMNodeFilter", "NodeFilter" },
{ "nsIDOMXPathResult", "XPathResult" } };
static nsresult
LookupComponentsShim(JSContext *cx, JS::Handle<JSObject*> global,
nsPIDOMWindowInner *win,
JS::MutableHandle<JS::PropertyDescriptor> desc)
{
// Keep track of how often this happens.
Telemetry::Accumulate(Telemetry::COMPONENTS_SHIM_ACCESSED_BY_CONTENT, true);
// Warn once.
nsCOMPtr<nsIDocument> doc = win->GetExtantDoc();
if (doc) {
doc->WarnOnceAbout(nsIDocument::eComponents, /* asError = */ true);
}
// Create a fake Components object.
AssertSameCompartment(cx, global);
JS::Rooted<JSObject*> components(cx, JS_NewPlainObject(cx));
NS_ENSURE_TRUE(components, NS_ERROR_OUT_OF_MEMORY);
// Create a fake interfaces object.
JS::Rooted<JSObject*> interfaces(cx, JS_NewPlainObject(cx));
NS_ENSURE_TRUE(interfaces, NS_ERROR_OUT_OF_MEMORY);
bool ok =
JS_DefineProperty(cx, components, "interfaces", interfaces,
JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_READONLY);
NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
// Define a bunch of shims from the Ci.nsIDOMFoo to window.Foo for DOM
// interfaces with constants.
for (uint32_t i = 0; i < ArrayLength(kInterfaceShimMap); ++i) {
// Grab the names from the table.
const char *geckoName = kInterfaceShimMap[i].geckoName;
const char *domName = kInterfaceShimMap[i].domName;
// Look up the appopriate interface object on the global.
JS::Rooted<JS::Value> v(cx, JS::UndefinedValue());
ok = JS_GetProperty(cx, global, domName, &v);
NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
if (!v.isObject()) {
NS_WARNING("Unable to find interface object on global");
continue;
}
// Define the shim on the interfaces object.
ok = JS_DefineProperty(cx, interfaces, geckoName, v,
JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_READONLY);
NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
}
FillPropertyDescriptor(desc, global, JS::ObjectValue(*components), false);
return NS_OK;
}
// EventTarget helper
NS_IMETHODIMP
nsEventTargetSH::PreCreate(nsISupports *nativeObj, JSContext *cx,
JSObject *aGlobalObj, JSObject **parentObj)
{
JS::Rooted<JSObject*> globalObj(cx, aGlobalObj);
DOMEventTargetHelper* target = DOMEventTargetHelper::FromSupports(nativeObj);
nsCOMPtr<nsIScriptGlobalObject> native_parent;
target->GetParentObject(getter_AddRefs(native_parent));
*parentObj = native_parent ? native_parent->GetGlobalJSObject() : globalObj;
return *parentObj ? NS_OK : NS_ERROR_FAILURE;
}
void
nsEventTargetSH::PreserveWrapper(nsISupports *aNative)
{
DOMEventTargetHelper* target = DOMEventTargetHelper::FromSupports(aNative);
target->PreserveWrapper(aNative);
}
// nsIDOMEventListener::HandleEvent() 'this' converter helper
NS_INTERFACE_MAP_BEGIN(nsEventListenerThisTranslator)
NS_INTERFACE_MAP_ENTRY(nsIXPCFunctionThisTranslator)
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END
NS_IMPL_ADDREF(nsEventListenerThisTranslator)
NS_IMPL_RELEASE(nsEventListenerThisTranslator)
NS_IMETHODIMP
nsEventListenerThisTranslator::TranslateThis(nsISupports *aInitialThis,
nsISupports **_retval)
{
nsCOMPtr<nsIDOMEvent> event(do_QueryInterface(aInitialThis));
NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
nsCOMPtr<EventTarget> target = event->InternalDOMEvent()->GetCurrentTarget();
target.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
nsDOMConstructorSH::PreCreate(nsISupports *nativeObj, JSContext *cx,
JSObject *aGlobalObj, JSObject **parentObj)
{
JS::Rooted<JSObject*> globalObj(cx, aGlobalObj);
nsDOMConstructor *wrapped = static_cast<nsDOMConstructor *>(nativeObj);
#ifdef DEBUG
{
nsCOMPtr<nsIDOMDOMConstructor> is_constructor =
do_QueryInterface(nativeObj);
NS_ASSERTION(is_constructor, "How did we not get a constructor?");
}
#endif
return wrapped->PreCreate(cx, globalObj, parentObj);
}
NS_IMETHODIMP
nsDOMConstructorSH::Resolve(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *aObj, jsid aId, bool *resolvedp,
bool *_retval)
{
JS::Rooted<JSObject*> obj(cx, aObj);
JS::Rooted<jsid> id(cx, aId);
// For regular DOM constructors, we have our interface constants defined on
// us by nsWindowSH::GlobalResolve. However, XrayWrappers can't see these
// interface constants (as they look like expando properties) so we have to
// specially resolve those constants here, but only for Xray wrappers.
if (!ObjectIsNativeWrapper(cx, obj)) {
return NS_OK;
}
JS::Rooted<JSObject*> nativePropsObj(cx, xpc::XrayUtils::GetNativePropertiesObject(cx, obj));
nsDOMConstructor *wrapped =
static_cast<nsDOMConstructor *>(wrapper->Native());
nsresult rv = wrapped->ResolveInterfaceConstants(cx, nativePropsObj);
NS_ENSURE_SUCCESS(rv, rv);
// Now re-lookup the ID to see if we should report back that we resolved the
// looked-for constant. Note that we don't have to worry about infinitely
// recurring back here because the Xray wrapper's holder object doesn't call
// Resolve hooks.
bool found;
if (!JS_HasPropertyById(cx, nativePropsObj, id, &found)) {
*_retval = false;
return NS_OK;
}
if (found) {
*resolvedp = true;
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMConstructorSH::Call(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *aObj, const JS::CallArgs &args, bool *_retval)
{
JS::Rooted<JSObject*> obj(cx, aObj);
MOZ_ASSERT(obj);
nsDOMConstructor *wrapped =
static_cast<nsDOMConstructor *>(wrapper->Native());
#ifdef DEBUG
{
nsCOMPtr<nsIDOMDOMConstructor> is_constructor =
do_QueryWrappedNative(wrapper);
NS_ASSERTION(is_constructor, "How did we not get a constructor?");
}
#endif
return wrapped->Construct(wrapper, cx, obj, args, _retval);
}
NS_IMETHODIMP
nsDOMConstructorSH::Construct(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *aObj, const JS::CallArgs &args, bool *_retval)
{
JS::Rooted<JSObject*> obj(cx, aObj);
MOZ_ASSERT(obj);
nsDOMConstructor *wrapped =
static_cast<nsDOMConstructor *>(wrapper->Native());
#ifdef DEBUG
{
nsCOMPtr<nsIDOMDOMConstructor> is_constructor =
do_QueryWrappedNative(wrapper);
NS_ASSERTION(is_constructor, "How did we not get a constructor?");
}
#endif
return wrapped->Construct(wrapper, cx, obj, args, _retval);
}
NS_IMETHODIMP
nsDOMConstructorSH::HasInstance(nsIXPConnectWrappedNative *wrapper,
JSContext *cx, JSObject *aObj, JS::Handle<JS::Value> val,
bool *bp, bool *_retval)
{
JS::Rooted<JSObject*> obj(cx, aObj);
nsDOMConstructor *wrapped =
static_cast<nsDOMConstructor *>(wrapper->Native());
#ifdef DEBUG
{
nsCOMPtr<nsIDOMDOMConstructor> is_constructor =
do_QueryWrappedNative(wrapper);
NS_ASSERTION(is_constructor, "How did we not get a constructor?");
}
#endif
return wrapped->HasInstance(wrapper, cx, obj, val, bp, _retval);
}
// nsContentFrameMessageManagerSH
template<typename Super>
NS_IMETHODIMP
nsMessageManagerSH<Super>::Resolve(nsIXPConnectWrappedNative* wrapper,
JSContext* cx, JSObject* obj_,
jsid id_, bool* resolvedp,
bool* _retval)
{
JS::Rooted<JSObject*> obj(cx, obj_);
JS::Rooted<jsid> id(cx, id_);
*_retval = SystemGlobalResolve(cx, obj, id, resolvedp);
NS_ENSURE_TRUE(*_retval, NS_ERROR_FAILURE);
if (*resolvedp) {
return NS_OK;
}
return Super::Resolve(wrapper, cx, obj, id, resolvedp, _retval);
}
template<typename Super>
NS_IMETHODIMP
nsMessageManagerSH<Super>::Enumerate(nsIXPConnectWrappedNative* wrapper,
JSContext* cx, JSObject* obj_,
bool* _retval)
{
JS::Rooted<JSObject*> obj(cx, obj_);
*_retval = SystemGlobalEnumerate(cx, obj);
NS_ENSURE_TRUE(*_retval, NS_ERROR_FAILURE);
// Don't call up to our superclass, since neither nsDOMGenericSH nor
// nsEventTargetSH have WANT_ENUMERATE.
return NS_OK;
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку