bool
SmsRequest::SetSuccessInternal(nsISupports* aObject)
{
NS_PRECONDITION(!mDone, "mDone shouldn't have been set to true already!");
NS_PRECONDITION(mError == eNoError, "mError shouldn't have been set!");
NS_PRECONDITION(mResult == JSVAL_VOID, "mResult shouldn't have been set!");
JSContext* cx = mScriptContext->GetNativeContext();
NS_ASSERTION(cx, "Failed to get a context!");
JSObject* global = mScriptContext->GetNativeGlobal();
NS_ASSERTION(global, "Failed to get global object!");
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, global)) {
SetError(eInternalError);
return false;
}
RootResult();
if (NS_FAILED(nsContentUtils::WrapNative(cx, global, aObject, &mResult))) {
UnrootResult();
mResult = JSVAL_VOID;
SetError(eInternalError);
return false;
}
mDone = true;
return true;
}
// Try to get the the document corresponding to the given JSStackFrame.
static already_AddRefed<nsIDocument>
GetFrameDocument(JSContext *cx, JSStackFrame *fp)
{
if (!cx || !fp)
return nsnull;
JSObject* scope = JS_GetGlobalForFrame(fp);
if (!scope)
return nsnull;
JSAutoEnterCompartment ac;
if (!ac.enter(cx, scope))
return nsnull;
nsCOMPtr<nsIDOMWindow> window =
do_QueryInterface(nsJSUtils::GetStaticScriptGlobal(cx, scope));
if (!window)
return nsnull;
// If it's a window, get its document.
nsCOMPtr<nsIDOMDocument> domDoc;
window->GetDocument(getter_AddRefs(domDoc));
nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
return doc.forget();
}
// Caller must root *aJSVal!
bool
nsEventListenerInfo::GetJSVal(JSContext* aCx, JSAutoEnterCompartment& aAc, jsval* aJSVal)
{
*aJSVal = JSVAL_NULL;
nsCOMPtr<nsIXPConnectWrappedJS> wrappedJS = do_QueryInterface(mListener);
if (wrappedJS) {
JSObject* object = nsnull;
if (NS_FAILED(wrappedJS->GetJSObject(&object)) || !aAc.enter(aCx, object)) {
return false;
}
*aJSVal = OBJECT_TO_JSVAL(object);
return true;
}
nsCOMPtr<nsIJSEventListener> jsl = do_QueryInterface(mListener);
if (jsl) {
JSObject *handler = static_cast<JSObject*>(jsl->GetHandler());
if (handler) {
if (!aAc.enter(aCx, handler)) {
return false;
}
*aJSVal = OBJECT_TO_JSVAL(handler);
return true;
}
}
return false;
}
bool
JSRuntime::initSelfHosting(JSContext *cx)
{
JS_ASSERT(!selfHostedGlobal_);
RootedObject savedGlobal(cx, JS_GetGlobalObject(cx));
if (!(selfHostedGlobal_ = JS_NewGlobalObject(cx, &self_hosting_global_class, NULL)))
return false;
JS_SetGlobalObject(cx, selfHostedGlobal_);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, cx->global()))
return false;
const char *src = selfhosted::raw_sources;
uint32_t srcLen = selfhosted::GetRawScriptsSize();
CompileOptions options(cx);
options.setFileAndLine("self-hosted", 1);
options.setSelfHostingMode(true);
RootedObject shg(cx, selfHostedGlobal_);
Value rv;
if (!Evaluate(cx, shg, options, src, srcLen, &rv))
return false;
JS_SetGlobalObject(cx, savedGlobal);
return true;
}
static JSBool
holder_set(JSContext *cx, JSObject *wrapper, jsid id, JSBool strict, jsval *vp)
{
wrapper = FindWrapper(wrapper);
JSObject *holder = GetHolder(wrapper);
if (IsResolving(holder, id)) {
return true;
}
XPCWrappedNative *wn = GetWrappedNativeFromHolder(holder);
if (NATIVE_HAS_FLAG(wn, WantSetProperty)) {
JSAutoEnterCompartment ac;
if (!ac.enter(cx, holder))
return false;
PRBool retval = true;
nsresult rv = wn->GetScriptableCallback()->SetProperty(wn, cx, wrapper, id, vp, &retval);
if (NS_FAILED(rv) || !retval) {
if (retval)
XPCThrower::Throw(rv, cx);
return false;
}
}
return true;
}
bool
XrayWrapper<Base>::delete_(JSContext *cx, JSObject *wrapper, jsid id, bool *bp)
{
JSObject *holder = GetHolder(wrapper);
jsval v;
JSBool b;
// Redirect access straight to the wrapper if we should be transparent.
if (XrayUtils::IsTransparent(cx, wrapper)) {
JSObject *wnObject = GetWrappedNativeObjectFromHolder(holder);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, wnObject))
return false;
if (!JS_DeletePropertyById2(cx, wnObject, id, &v) || !JS_ValueToBoolean(cx, v, &b))
return false;
*bp = !!b;
return true;
}
JSObject *expando = GetExpandoObject(holder);
b = true;
if (expando &&
(!JS_DeletePropertyById2(cx, expando, id, &v) ||
!JS_ValueToBoolean(cx, v, &b))) {
return false;
}
*bp = !!b;
return true;
}
JSBool
TestShellCommandParent::RunCallback(const nsString& aResponse)
{
NS_ENSURE_TRUE(mCallback != JSVAL_NULL && mCx, JS_FALSE);
JSAutoRequest ar(mCx);
JSObject* global = JS_GetGlobalObject(mCx);
NS_ENSURE_TRUE(global, JS_FALSE);
JSAutoEnterCompartment ac;
if (!ac.enter(mCx, global)) {
NS_ERROR("Failed to enter compartment!");
return false;
}
JSString* str = JS_NewUCStringCopyN(mCx, aResponse.get(), aResponse.Length());
NS_ENSURE_TRUE(str, JS_FALSE);
jsval argv[] = { STRING_TO_JSVAL(str) };
int argc = NS_ARRAY_LENGTH(argv);
jsval rval;
JSBool ok = JS_CallFunctionValue(mCx, global, mCallback, argc, argv, &rval);
NS_ENSURE_TRUE(ok, JS_FALSE);
return JS_TRUE;
}
nsresult
RadioManager::Init()
{
NS_ASSERTION(NS_IsMainThread(), "We can only initialize on the main thread");
nsCOMPtr<nsIObserverService> obs =
do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
if (!obs) {
NS_WARNING("Failed to get observer service!");
return NS_ERROR_FAILURE;
}
nsresult rv = obs->AddObserver(this, PROFILE_BEFORE_CHANGE_TOPIC, false);
NS_ENSURE_SUCCESS(rv, rv);
// The telephony worker component is a hack that gives us a global object for
// our own functions and makes creating the worker possible.
nsCOMPtr<nsIRadioWorker> worker(do_CreateInstance(kTelephonyWorkerCID));
NS_ENSURE_TRUE(worker, NS_ERROR_FAILURE);
jsval workerval;
rv = worker->GetWorker(&workerval);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(!JSVAL_IS_PRIMITIVE(workerval), "bad worker value");
JSContext *cx;
rv = nsContentUtils::ThreadJSContextStack()->GetSafeJSContext(&cx);
NS_ENSURE_SUCCESS(rv, rv);
nsCxPusher pusher;
if (!cx || !pusher.Push(cx, false)) {
return NS_ERROR_FAILURE;
}
JSObject *workerobj = JSVAL_TO_OBJECT(workerval);
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, workerobj)) {
return NS_ERROR_OUT_OF_MEMORY;
}
WorkerCrossThreadDispatcher *wctd = GetWorkerCrossThreadDispatcher(cx, workerval);
if (!wctd) {
return NS_ERROR_FAILURE;
}
nsRefPtr<ConnectWorkerToRIL> connection = new ConnectWorkerToRIL();
if (!wctd->PostTask(connection)) {
return NS_ERROR_UNEXPECTED;
}
// Now that we're set up, connect ourselves to the RIL thread.
mozilla::RefPtr<RILReceiver> receiver = new RILReceiver(wctd);
StartRil(receiver);
mTelephone = do_QueryInterface(worker);
NS_ENSURE_TRUE(mTelephone, NS_ERROR_FAILURE);
return NS_OK;
}
nsresult
IDBRequest::NotifyHelperCompleted(HelperBase* aHelper)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(!mHaveResultOrErrorCode, "Already called!");
NS_ASSERTION(JSVAL_IS_VOID(mResultVal), "Should be undefined!");
// See if our window is still valid. If not then we're going to pretend that
// we never completed.
if (NS_FAILED(CheckInnerWindowCorrectness())) {
return NS_OK;
}
mHaveResultOrErrorCode = true;
nsresult rv = aHelper->GetResultCode();
// If the request failed then set the error code and return.
if (NS_FAILED(rv)) {
SetError(rv);
return NS_OK;
}
// Otherwise we need to get the result from the helper.
JSContext* cx = GetJSContext();
if (!cx) {
NS_WARNING("Failed to get safe JSContext!");
rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
SetError(rv);
return rv;
}
JSObject* global = GetParentObject();
NS_ASSERTION(global, "This should never be null!");
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (ac.enter(cx, global)) {
AssertIsRooted();
rv = aHelper->GetSuccessResult(cx, &mResultVal);
if (NS_FAILED(rv)) {
NS_WARNING("GetSuccessResult failed!");
}
}
else {
NS_WARNING("Failed to enter correct compartment!");
rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (NS_SUCCEEDED(rv)) {
mError = nullptr;
}
else {
SetError(rv);
mResultVal = JSVAL_VOID;
}
return rv;
}
nsresult CentralizedAdminPrefManagerInit()
{
nsresult rv;
JSRuntime *rt;
// If autoconfig_cx already created, no need to create it again
if (autoconfig_cx)
return NS_OK;
// We need the XPCONNECT service
nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID(), &rv);
if (NS_FAILED(rv)) {
return rv;
}
// Get the JS RunTime
nsCOMPtr<nsIJSRuntimeService> rtsvc =
do_GetService("@mozilla.org/js/xpc/RuntimeService;1", &rv);
if (NS_SUCCEEDED(rv))
rv = rtsvc->GetRuntime(&rt);
if (NS_FAILED(rv)) {
NS_ERROR("Couldn't get JS RunTime");
return rv;
}
// Create a new JS context for autoconfig JS script
autoconfig_cx = JS_NewContext(rt, 1024);
if (!autoconfig_cx)
return NS_ERROR_OUT_OF_MEMORY;
JSAutoRequest ar(autoconfig_cx);
JS_SetErrorReporter(autoconfig_cx, autoConfigErrorReporter);
// Create a new Security Manger and set it for the new JS context
nsCOMPtr<nsIXPCSecurityManager> secman =
static_cast<nsIXPCSecurityManager*>(new AutoConfigSecMan());
xpc->SetSecurityManagerForJSContext(autoconfig_cx, secman, 0);
autoconfig_glob = JS_NewGlobalObject(autoconfig_cx, &global_class, NULL);
if (autoconfig_glob) {
JSAutoEnterCompartment ac;
if(!ac.enter(autoconfig_cx, autoconfig_glob))
return NS_ERROR_FAILURE;
if (JS_InitStandardClasses(autoconfig_cx, autoconfig_glob)) {
// XPCONNECT enable this JS context
rv = xpc->InitClasses(autoconfig_cx, autoconfig_glob);
if (NS_SUCCEEDED(rv))
return NS_OK;
}
}
// failue exit... clean up the JS context
JS_DestroyContext(autoconfig_cx);
autoconfig_cx = nsnull;
return NS_ERROR_FAILURE;
}
nsresult
nsXBLProtoImplProperty::InstallMember(nsIScriptContext* aContext,
nsIContent* aBoundElement,
void* aScriptObject,
void* aTargetClassObject,
const nsCString& aClassStr)
{
NS_PRECONDITION(mIsCompiled,
"Should not be installing an uncompiled property");
JSContext* cx = aContext->GetNativeContext();
nsIDocument *ownerDoc = aBoundElement->GetOwnerDoc();
nsIScriptGlobalObject *sgo;
if (!ownerDoc || !(sgo = ownerDoc->GetScopeObject())) {
return NS_ERROR_UNEXPECTED;
}
JSObject * scriptObject = (JSObject *) aScriptObject;
NS_ASSERTION(scriptObject, "uh-oh, script Object should NOT be null or bad things will happen");
if (!scriptObject)
return NS_ERROR_FAILURE;
JSObject * targetClassObject = (JSObject *) aTargetClassObject;
JSObject * globalObject = sgo->GetGlobalJSObject();
// now we want to reevaluate our property using aContext and the script object for this window...
if ((mJSGetterObject || mJSSetterObject) && targetClassObject) {
JSObject * getter = nsnull;
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, globalObject))
return NS_ERROR_UNEXPECTED;
if (mJSGetterObject)
if (!(getter = ::JS_CloneFunctionObject(cx, mJSGetterObject, globalObject)))
return NS_ERROR_OUT_OF_MEMORY;
JSObject * setter = nsnull;
if (mJSSetterObject)
if (!(setter = ::JS_CloneFunctionObject(cx, mJSSetterObject, globalObject)))
return NS_ERROR_OUT_OF_MEMORY;
nsDependentString name(mName);
if (!::JS_DefineUCProperty(cx, targetClassObject,
reinterpret_cast<const jschar*>(mName),
name.Length(), JSVAL_VOID,
JS_DATA_TO_FUNC_PTR(JSPropertyOp, getter),
JS_DATA_TO_FUNC_PTR(JSStrictPropertyOp, setter),
mJSAttributes))
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
static JSObject *
wrap(JSContext *cx, JS::HandleObject toWrap, JS::HandleObject target)
{
JSAutoEnterCompartment ac;
if (!ac.enter(cx, target))
return NULL;
JS::RootedObject wrapper(cx, toWrap);
if (!JS_WrapObject(cx, wrapper.address()))
return NULL;
return wrapper;
}
static JSObject *
wrap(JSContext *cx, JSObject *toWrap, JSObject *target)
{
JSAutoEnterCompartment ac;
if (!ac.enter(cx, target))
return NULL;
JSObject *wrapper = toWrap;
if (!JS_WrapObject(cx, &wrapper))
return NULL;
return wrapper;
}
// DoubleWrap is called from PrepareForWrapping to maintain the state that
// we're supposed to waive Xray wrappers for the given on. On entrance, it
// expects |cx->compartment != obj->compartment()|. The returned object will
// be in the same compartment as |obj|.
JSObject *
WrapperFactory::DoubleWrap(JSContext *cx, JSObject *obj, unsigned flags)
{
if (flags & WrapperFactory::WAIVE_XRAY_WRAPPER_FLAG) {
JSAutoEnterCompartment ac;
if (!ac.enter(cx, obj))
return nsnull;
return WaiveXray(cx, obj);
}
return obj;
}
bool
XPCShellEnvironment::EvaluateString(const nsString& aString,
nsString* aResult)
{
XPCShellEnvironment* env = Environment(mCx);
XPCShellEnvironment::AutoContextPusher pusher(env);
JSAutoRequest ar(mCx);
JS_ClearPendingException(mCx);
JSObject* global = GetGlobalObject();
JSAutoEnterCompartment ac;
if (!ac.enter(mCx, global)) {
NS_ERROR("Failed to enter compartment!");
return false;
}
JSScript* script =
JS_CompileUCScriptForPrincipals(mCx, global, GetPrincipal(),
aString.get(), aString.Length(),
"typein", 0);
if (!script) {
return false;
}
if (!ShouldCompileOnly()) {
if (aResult) {
aResult->Truncate();
}
jsval result;
JSBool ok = JS_ExecuteScript(mCx, global, script, &result);
if (ok && result != JSVAL_VOID) {
JSErrorReporter old = JS_SetErrorReporter(mCx, NULL);
JSString* str = JS_ValueToString(mCx, result);
nsDependentJSString depStr;
if (str)
depStr.init(mCx, str);
JS_SetErrorReporter(mCx, old);
if (!depStr.IsEmpty() && aResult) {
aResult->Assign(depStr);
}
}
}
JS_DestroyScript(mCx, script);
return true;
}
bool
JetpackChild::RecvSendMessage(const nsString& messageName,
const InfallibleTArray<Variant>& data)
{
JSAutoRequest request(mCx);
JSObject *global = JS_GetGlobalObject(mCx);
JSAutoEnterCompartment ac;
if (!ac.enter(mCx, global))
return false;
return JetpackActorCommon::RecvMessage(mCx, messageName, data, NULL);
}
nsresult
ArchiveRequest::ReaderReady(nsTArray<nsCOMPtr<nsIDOMFile> >& aFileList,
nsresult aStatus)
{
if (NS_FAILED(aStatus)) {
FireError(aStatus);
return NS_OK;
}
jsval result;
nsresult rv;
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
NS_ENSURE_STATE(sc);
JSContext* cx = sc->GetNativeContext();
NS_ASSERTION(cx, "Failed to get a context!");
JSObject* global = sc->GetNativeGlobal();
NS_ASSERTION(global, "Failed to get global object!");
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (ac.enter(cx, global)) {
switch (mOperation) {
case GetFilenames:
rv = GetFilenamesResult(cx, &result, aFileList);
break;
case GetFile:
rv = GetFileResult(cx, &result, aFileList);
break;
}
if (NS_FAILED(rv)) {
NS_WARNING("Get*Result failed!");
}
} else {
NS_WARNING("Failed to enter correct compartment!");
rv = NS_ERROR_FAILURE;
}
if (NS_SUCCEEDED(rv)) {
FireSuccess(result);
}
else {
FireError(rv);
}
return NS_OK;
}
JSObject *
WrapperFactory::WaiveXray(JSContext *cx, JSObject *obj)
{
obj = UnwrapObject(obj);
// We have to make sure that if we're wrapping an outer window, that
// the .wrappedJSObject also wraps the outer window.
obj = GetCurrentOuter(cx, obj);
{
// See if we already have a waiver wrapper for this object.
CompartmentPrivate *priv =
(CompartmentPrivate *)JS_GetCompartmentPrivate(js::GetObjectCompartment(obj));
JSObject *wobj = nsnull;
if (priv && priv->waiverWrapperMap) {
wobj = priv->waiverWrapperMap->Find(obj);
xpc_UnmarkGrayObject(wobj);
}
// No wrapper yet, make one.
if (!wobj) {
JSObject *proto = js::GetObjectProto(obj);
if (proto && !(proto = WaiveXray(cx, proto)))
return nsnull;
JSAutoEnterCompartment ac;
if (!ac.enter(cx, obj) || !JS_WrapObject(cx, &proto))
return nsnull;
wobj = Wrapper::New(cx, obj, proto, JS_GetGlobalForObject(cx, obj),
&WaiveXrayWrapperWrapper);
if (!wobj)
return nsnull;
// Add the new wrapper so we find it next time.
if (priv) {
if (!priv->waiverWrapperMap) {
priv->waiverWrapperMap = JSObject2JSObjectMap::newMap(XPC_WRAPPER_MAP_SIZE);
if (!priv->waiverWrapperMap)
return nsnull;
}
if (!priv->waiverWrapperMap->Add(obj, wobj))
return nsnull;
}
}
obj = wobj;
}
return obj;
}
nsresult
nsXBLProtoImplMethod::InstallMember(nsIScriptContext* aContext,
nsIContent* aBoundElement,
void* aScriptObject,
void* aTargetClassObject,
const nsCString& aClassStr)
{
NS_PRECONDITION(IsCompiled(),
"Should not be installing an uncompiled method");
JSContext* cx = aContext->GetNativeContext();
nsIDocument *ownerDoc = aBoundElement->OwnerDoc();
nsIScriptGlobalObject *sgo;
if (!(sgo = ownerDoc->GetScopeObject())) {
return NS_ERROR_UNEXPECTED;
}
JSObject * scriptObject = (JSObject *) aScriptObject;
NS_ASSERTION(scriptObject, "uh-oh, script Object should NOT be null or bad things will happen");
if (!scriptObject)
return NS_ERROR_FAILURE;
JSObject * targetClassObject = (JSObject *) aTargetClassObject;
JSObject * globalObject = sgo->GetGlobalJSObject();
// now we want to reevaluate our property using aContext and the script object for this window...
if (mJSMethodObject && targetClassObject) {
nsDependentString name(mName);
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, globalObject)) {
return NS_ERROR_UNEXPECTED;
}
JSObject * method = ::JS_CloneFunctionObject(cx, mJSMethodObject, globalObject);
if (!method) {
return NS_ERROR_OUT_OF_MEMORY;
}
if (!::JS_DefineUCProperty(cx, targetClassObject,
reinterpret_cast<const jschar*>(mName),
name.Length(), OBJECT_TO_JSVAL(method),
NULL, NULL, JSPROP_ENUMERATE)) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
return NS_OK;
}
nsresult
nsStructuredCloneContainer::InitFromVariant(nsIVariant *aData, JSContext *aCx)
{
NS_ENSURE_STATE(!mData);
NS_ENSURE_ARG_POINTER(aData);
NS_ENSURE_ARG_POINTER(aCx);
// First, try to extract a jsval from the variant |aData|. This works only
// if the variant implements GetAsJSVal.
jsval jsData;
nsresult rv = aData->GetAsJSVal(&jsData);
NS_ENSURE_SUCCESS(rv, NS_ERROR_UNEXPECTED);
// Make sure that we serialize in the right context.
JSAutoRequest ar(aCx);
JSAutoEnterCompartment ac;
NS_ENSURE_STATE(ac.enter(aCx, JS_GetGlobalObject(aCx)));
JS_WrapValue(aCx, &jsData);
nsCxPusher cxPusher;
cxPusher.Push(aCx);
uint64_t* jsBytes = nullptr;
bool success = JS_WriteStructuredClone(aCx, jsData, &jsBytes, &mSize,
nullptr, nullptr);
NS_ENSURE_STATE(success);
NS_ENSURE_STATE(jsBytes);
// Copy jsBytes into our own buffer.
mData = (uint64_t*) malloc(mSize);
if (!mData) {
mSize = 0;
mVersion = 0;
// FIXME This should really be js::Foreground::Free, but that's not public.
JS_free(aCx, jsBytes);
return NS_ERROR_FAILURE;
}
else {
mVersion = JS_STRUCTURED_CLONE_VERSION;
}
memcpy(mData, jsBytes, mSize);
// FIXME Similarly, this should be js::Foreground::free.
JS_free(aCx, jsBytes);
return NS_OK;
}
bool
JetpackChild::RecvEvalScript(const nsString& code)
{
JSAutoRequest request(mCx);
JSObject *global = JS_GetGlobalObject(mCx);
JSAutoEnterCompartment ac;
if (!ac.enter(mCx, global))
return false;
jsval ignored;
(void) JS_EvaluateUCScript(mCx, global, code.get(),
code.Length(), "", 1, &ignored);
return true;
}
nsresult
mozilla::dom::bluetooth::StringArrayToJSArray(JSContext* aCx, JSObject* aGlobal,
const nsTArray<nsString>& aSourceArray,
JSObject** aResultArray)
{
NS_ASSERTION(aCx, "Null context!");
NS_ASSERTION(aGlobal, "Null global!");
JSAutoRequest ar(aCx);
JSAutoEnterCompartment ac;
if (!ac.enter(aCx, aGlobal)) {
NS_WARNING("Failed to enter compartment!");
return NS_ERROR_FAILURE;
}
JSObject* arrayObj;
if (aSourceArray.IsEmpty()) {
arrayObj = JS_NewArrayObject(aCx, 0, nullptr);
} else {
uint32_t valLength = aSourceArray.Length();
mozilla::ScopedDeleteArray<jsval> valArray(new jsval[valLength]);
JS::AutoArrayRooter tvr(aCx, valLength, valArray);
for (PRUint32 index = 0; index < valLength; index++) {
JSString* s = JS_NewUCStringCopyN(aCx, aSourceArray[index].BeginReading(),
aSourceArray[index].Length());
if(!s) {
NS_WARNING("Memory allocation error!");
return NS_ERROR_OUT_OF_MEMORY;
}
valArray[index] = STRING_TO_JSVAL(s);
}
arrayObj = JS_NewArrayObject(aCx, valLength, valArray);
}
if (!arrayObj) {
return NS_ERROR_OUT_OF_MEMORY;
}
// XXX This is not what Jonas wants. He wants it to be live.
// Followup at bug 717414
if (!JS_FreezeObject(aCx, arrayObj)) {
return NS_ERROR_FAILURE;
}
*aResultArray = arrayObj;
return NS_OK;
}
bool
XrayWrapper<Base>::defineProperty(JSContext *cx, JSObject *wrapper, jsid id,
js::PropertyDescriptor *desc)
{
JSObject *holder = GetHolder(wrapper);
JSPropertyDescriptor *jsdesc = desc;
// Redirect access straight to the wrapper if we should be transparent.
if (XrayUtils::IsTransparent(cx, wrapper)) {
JSObject *wnObject = GetWrappedNativeObjectFromHolder(holder);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, wnObject))
return false;
if (!JS_WrapPropertyDescriptor(cx, desc))
return false;
return JS_DefinePropertyById(cx, wnObject, id, jsdesc->value, jsdesc->getter, jsdesc->setter,
jsdesc->attrs);
}
PropertyDescriptor existing_desc;
if (!getOwnPropertyDescriptor(cx, wrapper, id, true, &existing_desc))
return false;
if (existing_desc.obj && (existing_desc.attrs & JSPROP_PERMANENT))
return true; // silently ignore attempt to overwrite native property
if (IsResolving(holder, id)) {
if (!(jsdesc->attrs & (JSPROP_GETTER | JSPROP_SETTER))) {
if (!desc->getter)
jsdesc->getter = holder_get;
if (!desc->setter)
jsdesc->setter = holder_set;
}
return JS_DefinePropertyById(cx, holder, id, jsdesc->value, jsdesc->getter, jsdesc->setter,
jsdesc->attrs);
}
JSObject *expando = EnsureExpandoObject(cx, holder);
if (!expando)
return false;
return JS_DefinePropertyById(cx, expando, id, jsdesc->value, jsdesc->getter, jsdesc->setter,
jsdesc->attrs);
}
JSBool
JetpackChild::EvalInSandbox(JSContext* cx, uintN argc, jsval* vp)
{
if (argc != 2) {
JS_ReportError(cx, "evalInSandbox takes two arguments");
return JS_FALSE;
}
jsval* argv = JS_ARGV(cx, vp);
JSObject* obj;
if (!JSVAL_IS_OBJECT(argv[0]) ||
!(obj = JSVAL_TO_OBJECT(argv[0]))) {
JS_ReportError(cx, "The first argument to evalInSandbox must be a global object created using createSandbox.");
JS_ASSERT(JS_FALSE);
return JS_FALSE;
}
// Unwrap, and switch compartments
obj = js::UnwrapObject(obj);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, obj))
return JS_FALSE;
if (&sGlobalClass != JS_GetClass(cx, obj) ||
obj == JS_GetGlobalObject(cx)) {
JS_ReportError(cx, "The first argument to evalInSandbox must be a global object created using createSandbox.");
JS_ASSERT(JS_FALSE);
return JS_FALSE;
}
if (!JS_WrapValue(cx, &argv[1]))
return JS_FALSE;
JSString* str = JS_ValueToString(cx, argv[1]);
if (!str)
return JS_FALSE;
size_t length;
const jschar* chars = JS_GetStringCharsAndLength(cx, str, &length);
if (!chars)
return JS_FALSE;
js::AutoValueRooter ignored(cx);
return JS_EvaluateUCScript(cx, obj, chars, length, "", 1, ignored.jsval_addr());
}
static bool
EnumerateNames(JSContext *cx, JSObject *wrapper, uintN flags, js::AutoIdVector &props)
{
JSObject *holder = GetHolder(wrapper);
JSObject *wnObject = GetWrappedNativeObjectFromHolder(holder);
// Redirect access straight to the wrapper if we should be transparent.
if (XrayUtils::IsTransparent(cx, wrapper)) {
JSAutoEnterCompartment ac;
if (!ac.enter(cx, wnObject))
return false;
return js::GetPropertyNames(cx, wnObject, flags, &props);
}
if (WrapperFactory::IsPartiallyTransparent(wrapper)) {
JS_ReportError(cx, "Not allowed to enumerate cross origin objects");
return false;
}
// Enumerate expando properties first.
JSObject *expando = GetExpandoObject(holder);
if (expando && !js::GetPropertyNames(cx, expando, flags, &props))
return false;
// Force all native properties to be materialized onto the wrapped native.
js::AutoIdVector wnProps(cx);
{
JSAutoEnterCompartment ac;
if (!ac.enter(cx, wnObject))
return false;
if (!js::GetPropertyNames(cx, wnObject, flags, &wnProps))
return false;
}
// Go through the properties we got and enumerate all native ones.
for (size_t n = 0; n < wnProps.length(); ++n) {
jsid id = wnProps[n];
JSBool hasProp;
if (!JS_HasPropertyById(cx, wrapper, id, &hasProp))
return false;
if (hasProp)
props.append(id);
}
return true;
}
bool
JetpackChild::Init(base::ProcessHandle aParentProcessHandle,
MessageLoop* aIOLoop,
IPC::Channel* aChannel)
{
if (!Open(aChannel, aParentProcessHandle, aIOLoop))
return false;
if (!(mRuntime = JS_NewRuntime(32L * 1024L * 1024L)) ||
!(mCx = JS_NewContext(mRuntime, 8192)))
return false;
JS_SetVersion(mCx, JSVERSION_LATEST);
JS_SetOptions(mCx, JS_GetOptions(mCx) |
JSOPTION_DONT_REPORT_UNCAUGHT |
JSOPTION_ATLINE |
JSOPTION_JIT);
JS_SetErrorReporter(mCx, ReportError);
{
JSAutoRequest request(mCx);
JS_SetContextPrivate(mCx, this);
JSObject* implGlobal =
JS_NewCompartmentAndGlobalObject(mCx, const_cast<JSClass*>(&sGlobalClass), NULL);
if (!implGlobal)
return false;
JSAutoEnterCompartment ac;
if (!ac.enter(mCx, implGlobal))
return false;
jsval ctypes;
if (!JS_InitStandardClasses(mCx, implGlobal) ||
#ifdef BUILD_CTYPES
!JS_InitCTypesClass(mCx, implGlobal) ||
!JS_GetProperty(mCx, implGlobal, "ctypes", &ctypes) ||
!JS_SetCTypesCallbacks(mCx, JSVAL_TO_OBJECT(ctypes), &sCallbacks) ||
#endif
!JS_DefineFunctions(mCx, implGlobal,
const_cast<JSFunctionSpec*>(sImplMethods)))
return false;
}
return true;
}
bool
XrayWrapper<Base>::getOwnPropertyDescriptor(JSContext *cx, JSObject *wrapper, jsid id,
bool set, PropertyDescriptor *desc)
{
JSObject *holder = GetHolder(wrapper);
if (IsResolving(holder, id)) {
desc->obj = NULL;
return true;
}
bool status;
JSWrapper::Action action = set ? JSWrapper::SET : JSWrapper::GET;
desc->obj = NULL; // default value
if (!this->enter(cx, wrapper, id, action, &status))
return status;
AutoLeaveHelper<Base> helper(*this, cx, wrapper);
ResolvingId resolving(holder, id);
// NB: Nothing we do here acts on the wrapped native itself, so we don't
// enter our policy.
// Redirect access straight to the wrapper if we should be transparent.
if (XrayUtils::IsTransparent(cx, wrapper)) {
JSObject *wnObject = GetWrappedNativeObjectFromHolder(holder);
{
JSAutoEnterCompartment ac;
if (!ac.enter(cx, wnObject))
return false;
if (!JS_GetPropertyDescriptorById(cx, wnObject, id,
(set ? JSRESOLVE_ASSIGNING : 0) | JSRESOLVE_QUALIFIED,
desc)) {
return false;
}
}
desc->obj = (desc->obj == wnObject) ? wrapper : nsnull;
return JS_WrapPropertyDescriptor(cx, desc);
}
return this->resolveOwnProperty(cx, wrapper, id, set, desc);
}
JSBool
CallTrusted(JSContext *cx, unsigned argc, jsval *vp)
{
if (!JS_SaveFrameChain(cx))
return JS_FALSE;
JSBool ok = JS_FALSE;
{
JSAutoEnterCompartment ac;
ok = ac.enter(cx, trusted_glob.get());
if (!ok)
goto out;
ok = JS_CallFunctionValue(cx, NULL, OBJECT_TO_JSVAL(trusted_fun.get()),
0, NULL, vp);
}
out:
JS_RestoreFrameChain(cx);
return ok;
}
NS_IMETHODIMP
nsJSON::EncodeFromJSVal(JS::Value *value, JSContext *cx, nsAString &result)
{
result.Truncate();
// Begin a new request
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
nsIScriptSecurityManager *ssm = nsnull;
if (value->isObject()) {
JSObject *obj = &value->toObject();
if (!ac.enter(cx, obj)) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIPrincipal> principal;
ssm = nsContentUtils::GetSecurityManager();
nsresult rv = ssm->GetObjectPrincipal(cx, obj, getter_AddRefs(principal));
NS_ENSURE_SUCCESS(rv, rv);
JSStackFrame *fp = nsnull;
rv = ssm->PushContextPrincipal(cx, JS_FrameIterator(cx, &fp), principal);
NS_ENSURE_SUCCESS(rv, rv);
}
nsJSONWriter writer;
JSBool ok = JS_Stringify(cx, value, NULL, JSVAL_NULL,
WriteCallback, &writer);
if (ssm) {
ssm->PopContextPrincipal(cx);
}
if (!ok) {
return NS_ERROR_XPC_BAD_CONVERT_JS;
}
NS_ENSURE_TRUE(writer.DidWrite(), NS_ERROR_UNEXPECTED);
writer.FlushBuffer();
result.Assign(writer.mOutputString);
return NS_OK;
}
bool testIndirectEval(JSObject *scope, JSObject *g, const char *code, int expectedHits)
{
EXEC("hits = 0;");
{
JSAutoEnterCompartment ae;
CHECK(ae.enter(cx, scope));
JSString *codestr = JS_NewStringCopyZ(cx, code);
CHECK(codestr);
jsval argv[1] = { STRING_TO_JSVAL(codestr) };
jsval v;
CHECK(JS_CallFunctionName(cx, g, "eval", 1, argv, &v));
}
jsval hitsv;
EVAL("hits", &hitsv);
CHECK_SAME(hitsv, INT_TO_JSVAL(expectedHits));
return true;
}