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; }