bool
WindowNamedPropertiesHandler::getOwnPropertyNames(JSContext* aCx,
JS::Handle<JSObject*> aProxy,
JS::AutoIdVector& aProps)
{
// Grab the DOM window.
JSObject* global = JS_GetGlobalForObject(aCx, aProxy);
XPCWrappedNative* wrapper = XPCWrappedNative::Get(global);
nsCOMPtr<nsPIDOMWindow> piWin = do_QueryWrappedNative(wrapper);
MOZ_ASSERT(piWin);
nsGlobalWindow* win = static_cast<nsGlobalWindow*>(piWin.get());
nsTArray<nsString> names;
win->GetSupportedNames(names);
if (!AppendNamedPropertyIds(aCx, aProxy, names, false, aProps)) {
return false;
}
names.Clear();
nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(win->GetExtantDoc());
if (!htmlDoc) {
return true;
}
nsHTMLDocument* document = static_cast<nsHTMLDocument*>(htmlDoc.get());
document->GetSupportedNames(names);
JS::AutoIdVector docProps(aCx);
if (!AppendNamedPropertyIds(aCx, aProxy, names, false, docProps)) {
return false;
}
return js::AppendUnique(aCx, aProps, docProps);
}
static JSBool
IsValFrame(JSObject *obj, jsval v, XPCWrappedNative *wn)
{
// Fast path for the common case.
if (STOBJ_GET_CLASS(obj)->name[0] != 'W') {
return JS_FALSE;
}
nsCOMPtr<nsIDOMWindow> domwin(do_QueryWrappedNative(wn));
if (!domwin) {
return JS_FALSE;
}
nsCOMPtr<nsIDOMWindowCollection> col;
domwin->GetFrames(getter_AddRefs(col));
if (!col) {
return JS_FALSE;
}
if (JSVAL_IS_INT(v)) {
col->Item(JSVAL_TO_INT(v), getter_AddRefs(domwin));
} else {
nsAutoString str(reinterpret_cast<PRUnichar *>
(JS_GetStringChars(JSVAL_TO_STRING(v))));
col->NamedItem(str, getter_AddRefs(domwin));
}
return domwin != nsnull;
}
nsresult
Statement::internalFinalize(bool aDestructing)
{
if (!mDBStatement)
return NS_OK;
#ifdef PR_LOGGING
PR_LOG(gStorageLog, PR_LOG_NOTICE, ("Finalizing statement '%s'",
::sqlite3_sql(mDBStatement)));
#endif
int srv = ::sqlite3_finalize(mDBStatement);
mDBStatement = nullptr;
if (mAsyncStatement) {
// If the destructor called us, there are no pending async statements (they
// hold a reference to us) and we can/must just kill the statement directly.
if (aDestructing)
destructorAsyncFinalize();
else
asyncFinalize();
}
// We are considered dead at this point, so any wrappers for row or params
// need to lose their reference to us.
if (mStatementParamsHolder) {
nsCOMPtr<nsIXPConnectWrappedNative> wrapper =
do_QueryInterface(mStatementParamsHolder);
nsCOMPtr<mozIStorageStatementParams> iParams =
do_QueryWrappedNative(wrapper);
StatementParams *params = static_cast<StatementParams *>(iParams.get());
params->mStatement = nullptr;
mStatementParamsHolder = nullptr;
}
if (mStatementRowHolder) {
nsCOMPtr<nsIXPConnectWrappedNative> wrapper =
do_QueryInterface(mStatementRowHolder);
nsCOMPtr<mozIStorageStatementRow> iRow =
do_QueryWrappedNative(wrapper);
StatementRow *row = static_cast<StatementRow *>(iRow.get());
row->mStatement = nullptr;
mStatementRowHolder = nullptr;
}
return convertResultCode(srv);
}
StatementRowHolder::~StatementRowHolder()
{
MOZ_ASSERT(NS_IsMainThread());
// We are considered dead at this point, so any wrappers for row or params
// need to lose their reference to the statement.
nsCOMPtr<nsIXPConnectWrappedNative> wrapper = do_QueryInterface(mHolder);
nsCOMPtr<mozIStorageStatementRow> iObj = do_QueryWrappedNative(wrapper);
StatementRow *obj = static_cast<StatementRow *>(iObj.get());
obj->mStatement = nullptr;
}
static nsGlobalWindow*
GetWindowFromGlobal(JSObject* aGlobal)
{
nsGlobalWindow* win;
if (NS_SUCCEEDED(UNWRAP_OBJECT(Window, aGlobal, win))) {
return win;
}
XPCWrappedNative* wrapper = XPCWrappedNative::Get(aGlobal);
nsCOMPtr<nsPIDOMWindow> piWin = do_QueryWrappedNative(wrapper);
MOZ_ASSERT(piWin);
return static_cast<nsGlobalWindow*>(piWin.get());
}
void
XPCWrappedNativeScope::SetGlobal(XPCCallContext& ccx, JSObject* aGlobal)
{
// We allow for calling this more than once. This feature is used by
// nsXPConnect::InitClassesWithNewWrappedGlobal.
mGlobalJSObject = aGlobal;
mScriptObjectPrincipal = nsnull;
// Now init our script object principal, if the new global has one
const JSClass* jsClass = js::GetObjectJSClass(aGlobal);
if (!(~jsClass->flags & (JSCLASS_HAS_PRIVATE |
JSCLASS_PRIVATE_IS_NSISUPPORTS))) {
// Our global has an nsISupports native pointer. Let's
// see whether it's what we want.
nsISupports* priv = (nsISupports*)xpc_GetJSPrivate(aGlobal);
nsCOMPtr<nsIXPConnectWrappedNative> native =
do_QueryInterface(priv);
nsCOMPtr<nsIScriptObjectPrincipal> sop;
if (native) {
sop = do_QueryWrappedNative(native);
}
if (!sop) {
sop = do_QueryInterface(priv);
}
mScriptObjectPrincipal = sop;
}
// Lookup 'globalObject.Object.prototype' for our wrapper's proto
{
AutoJSErrorAndExceptionEater eater(ccx); // scoped error eater
jsval val;
jsid idObj = mRuntime->GetStringID(XPCJSRuntime::IDX_OBJECT);
jsid idProto = mRuntime->GetStringID(XPCJSRuntime::IDX_PROTOTYPE);
if (JS_GetPropertyById(ccx, aGlobal, idObj, &val) &&
!JSVAL_IS_PRIMITIVE(val) &&
JS_GetPropertyById(ccx, JSVAL_TO_OBJECT(val), idProto, &val) &&
!JSVAL_IS_PRIMITIVE(val)) {
mPrototypeJSObject = JSVAL_TO_OBJECT(val);
} else {
NS_ERROR("Can't get globalObject.Object.prototype");
}
}
// Clear the no helper wrapper prototype object so that a new one
// gets created if needed.
mPrototypeNoHelper = nsnull;
}
nsIScriptGlobalObject *
nsJSUtils::GetStaticScriptGlobal(JSObject* aObj)
{
const JSClass* clazz;
JSObject* glob = aObj; // starting point for search
if (!glob)
return nullptr;
glob = js::GetGlobalForObjectCrossCompartment(glob);
NS_ABORT_IF_FALSE(glob, "Infallible returns null");
clazz = JS_GetClass(glob);
// Whenever we end up with globals that are JSCLASS_IS_DOMJSCLASS
// and have an nsISupports DOM object, we will need to modify this
// check here.
MOZ_ASSERT(!(clazz->flags & JSCLASS_IS_DOMJSCLASS));
nsISupports* supports;
if (!(clazz->flags & JSCLASS_HAS_PRIVATE) ||
!(clazz->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS) ||
!(supports = (nsISupports*)::JS_GetPrivate(glob))) {
return nullptr;
}
// We might either have a window directly (e.g. if the global is a
// sandbox whose script object principal pointer is a window), or an
// XPCWrappedNative for a window. We could also have other
// sandbox-related script object principals, but we can't do much
// about those short of trying to walk the proto chain of |glob|
// looking for a window or something.
nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryInterface(supports));
if (!sgo) {
nsCOMPtr<nsIXPConnectWrappedNative> wrapper(do_QueryInterface(supports));
if (!wrapper) {
return nullptr;
}
sgo = do_QueryWrappedNative(wrapper);
}
// We're returning a pointer to something that's about to be
// released, but that's ok here.
return sgo;
}
nsIScriptGlobalObject *
nsJSUtils::GetStaticScriptGlobal(JSContext* aContext, JSObject* aObj)
{
nsISupports* supports;
JSClass* clazz;
JSObject* glob = aObj; // starting point for search
if (!glob)
return nsnull;
glob = JS_GetGlobalForObject(aContext, glob);
NS_ABORT_IF_FALSE(glob, "Infallible returns null");
clazz = JS_GetClass(glob);
if (!clazz ||
!(clazz->flags & JSCLASS_HAS_PRIVATE) ||
!(clazz->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS) ||
!(supports = (nsISupports*)::JS_GetPrivate(glob))) {
return nsnull;
}
// We might either have a window directly (e.g. if the global is a
// sandbox whose script object principal pointer is a window), or an
// XPCWrappedNative for a window. We could also have other
// sandbox-related script object principals, but we can't do much
// about those short of trying to walk the proto chain of |glob|
// looking for a window or something.
nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryInterface(supports));
if (!sgo) {
nsCOMPtr<nsIXPConnectWrappedNative> wrapper(do_QueryInterface(supports));
NS_ENSURE_TRUE(wrapper, nsnull);
sgo = do_QueryWrappedNative(wrapper);
}
// We're returning a pointer to something that's about to be
// released, but that's ok here.
return sgo;
}
nsIScriptGlobalObject *
nsWWJSUtils::GetStaticScriptGlobal(JSContext* aContext, JSObject* aObj)
{
nsISupports* supports;
JSClass* clazz;
JSObject* parent;
JSObject* glob = aObj; // starting point for search
if (!glob)
return nsnull;
while (nsnull != (parent = JS_GetParent(aContext, glob)))
glob = parent;
#ifdef JS_THREADSAFE
clazz = JS_GetClass(aContext, glob);
#else
clazz = JS_GetClass(glob);
#endif
if (!clazz ||
!(clazz->flags & JSCLASS_HAS_PRIVATE) ||
!(clazz->flags & JSCLASS_PRIVATE_IS_NSISUPPORTS) ||
!(supports = (nsISupports*) JS_GetPrivate(aContext, glob))) {
return nsnull;
}
nsCOMPtr<nsIXPConnectWrappedNative> wrapper(do_QueryInterface(supports));
NS_ENSURE_TRUE(wrapper, nsnull);
nsCOMPtr<nsIScriptGlobalObject> sgo(do_QueryWrappedNative(wrapper));
// This will return a pointer to something we're about to release,
// but that's ok here.
return sgo;
}
bool
WindowNamedPropertiesHandler::getOwnPropertyDescriptor(JSContext* aCx,
JS::Handle<JSObject*> aProxy,
JS::Handle<jsid> aId,
JS::MutableHandle<JSPropertyDescriptor> aDesc,
unsigned aFlags)
{
if (!JSID_IS_STRING(aId)) {
// Nothing to do if we're resolving a non-string property.
return true;
}
JS::Rooted<JSObject*> global(aCx, JS_GetGlobalForObject(aCx, aProxy));
if (HasPropertyOnPrototype(aCx, aProxy, aId)) {
return true;
}
nsDependentJSString str(aId);
// Grab the DOM window.
XPCWrappedNative* wrapper = XPCWrappedNative::Get(global);
nsCOMPtr<nsPIDOMWindow> piWin = do_QueryWrappedNative(wrapper);
MOZ_ASSERT(piWin);
nsGlobalWindow* win = static_cast<nsGlobalWindow*>(piWin.get());
if (win->GetLength() > 0) {
nsCOMPtr<nsIDOMWindow> childWin = win->GetChildWindow(str);
if (childWin && ShouldExposeChildWindow(str, childWin)) {
// We found a subframe of the right name. Shadowing via |var foo| in
// global scope is still allowed, since |var| only looks up |own|
// properties. But unqualified shadowing will fail, per-spec.
JS::Rooted<JS::Value> v(aCx);
if (!WrapObject(aCx, aProxy, childWin, &v)) {
return false;
}
aDesc.object().set(aProxy);
aDesc.value().set(v);
aDesc.setAttributes(JSPROP_ENUMERATE);
return true;
}
}
// The rest of this function is for HTML documents only.
nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(win->GetExtantDoc());
if (!htmlDoc) {
return true;
}
nsHTMLDocument* document = static_cast<nsHTMLDocument*>(htmlDoc.get());
Element* element = document->GetElementById(str);
if (element) {
JS::Rooted<JS::Value> v(aCx);
if (!WrapObject(aCx, aProxy, element, &v)) {
return false;
}
aDesc.object().set(aProxy);
aDesc.value().set(v);
aDesc.setAttributes(JSPROP_ENUMERATE);
return true;
}
nsWrapperCache* cache;
nsISupports* result = document->ResolveName(str, &cache);
if (!result) {
return true;
}
JS::Rooted<JS::Value> v(aCx);
if (!WrapObject(aCx, aProxy, result, cache, nullptr, &v)) {
return false;
}
aDesc.object().set(aProxy);
aDesc.value().set(v);
aDesc.setAttributes(JSPROP_ENUMERATE);
return true;
}
static JSBool
XBLResolve(JSContext *cx, JSHandleObject obj, JSHandleId id, unsigned flags,
JSObject **objp)
{
// Note: if we get here, that means that the implementation for some binding
// was installed, which means that AllowScripts() tested true. Hence no need
// to do checks like that here.
// Default to not resolving things.
NS_ASSERTION(*objp, "Must have starting object");
JSObject* origObj = *objp;
*objp = NULL;
if (!JSID_IS_STRING(id)) {
return JS_TRUE;
}
nsDependentJSString fieldName(id);
jsval slotVal = ::JS_GetReservedSlot(obj, 0);
NS_ASSERTION(!JSVAL_IS_VOID(slotVal), "How did that happen?");
nsXBLPrototypeBinding* protoBinding =
static_cast<nsXBLPrototypeBinding*>(JSVAL_TO_PRIVATE(slotVal));
NS_ASSERTION(protoBinding, "Must have prototype binding!");
nsXBLProtoImplField* field = protoBinding->FindField(fieldName);
if (!field) {
return JS_TRUE;
}
// We have this field. Time to install it. Get our node.
JSClass* nodeClass = ::JS_GetClass(origObj);
if (!nodeClass) {
return JS_FALSE;
}
if (~nodeClass->flags &
(JSCLASS_HAS_PRIVATE | JSCLASS_PRIVATE_IS_NSISUPPORTS)) {
nsDOMClassInfo::ThrowJSException(cx, NS_ERROR_UNEXPECTED);
return JS_FALSE;
}
nsCOMPtr<nsIXPConnectWrappedNative> xpcWrapper =
do_QueryInterface(static_cast<nsISupports*>(::JS_GetPrivate(origObj)));
if (!xpcWrapper) {
// Looks like whatever |origObj| is it's not our nsIContent. It might well
// be the proto our binding installed, however, where the private is the
// nsXBLDocumentInfo, so just baul out quietly. Do NOT throw an exception
// here.
// We could make this stricter by checking the class maybe, but whatever
return JS_TRUE;
}
nsCOMPtr<nsIContent> content = do_QueryWrappedNative(xpcWrapper);
if (!content) {
nsDOMClassInfo::ThrowJSException(cx, NS_ERROR_UNEXPECTED);
return JS_FALSE;
}
// This mirrors code in nsXBLProtoImpl::InstallImplementation
nsIDocument* doc = content->OwnerDoc();
nsIScriptGlobalObject* global = doc->GetScriptGlobalObject();
if (!global) {
return JS_TRUE;
}
nsCOMPtr<nsIScriptContext> context = global->GetContext();
if (!context) {
return JS_TRUE;
}
// Now we either resolve or fail
bool didInstall;
nsresult rv = field->InstallField(context, origObj,
content->NodePrincipal(),
protoBinding->DocURI(),
&didInstall);
if (NS_FAILED(rv)) {
if (!::JS_IsExceptionPending(cx)) {
nsDOMClassInfo::ThrowJSException(cx, rv);
}
return JS_FALSE;
}
if (didInstall) {
*objp = origObj;
}
// else we didn't resolve this field after all
return JS_TRUE;
}
