/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-

 * vim: set ts=8 sw=4 et tw=78:

 *

 * 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/. */

/* Sharable code and data for wrapper around JSObjects. */

#include "xpcprivate.h"

#include "nsArrayEnumerator.h"

#include "nsWrapperCache.h"

#include "XPCWrapper.h"

#include "AccessCheck.h"

#include "nsJSUtils.h"

#include "mozilla/Attributes.h"

#include "jsapi.h"

#include "jsfriendapi.h"

using namespace xpc;

using namespace JS;

NS_IMPL_THREADSAFE_ISUPPORTS1(nsXPCWrappedJSClass, nsIXPCWrappedJSClass)

// the value of this variable is never used - we use its address as a sentinel

static uint32_t zero_methods_descriptor;

bool AutoScriptEvaluate::StartEvaluating(HandleObject scope, JSErrorReporter errorReporter)

{

    NS_PRECONDITION(!mEvaluated, "AutoScriptEvaluate::Evaluate should only be called once");

    if (!mJSContext)

        return true;

    mEvaluated = true;

    if (!JS_GetErrorReporter(mJSContext)) {

        JS_SetErrorReporter(mJSContext, errorReporter);

        mErrorReporterSet = true;

    }

    JS_BeginRequest(mJSContext);

    mAutoCompartment.construct(mJSContext, scope);

    // Saving the exception state keeps us from interfering with another script

    // that may also be running on this context.  This occurred first with the

    // js debugger, as described in

    // http://bugzilla.mozilla.org/show_bug.cgi?id=88130 but presumably could

    // show up in any situation where a script calls into a wrapped js component

    // on the same context, while the context has a nonzero exception state.

    // Because JS_SaveExceptionState/JS_RestoreExceptionState use malloc

    // and addroot, we avoid them if possible by returning null (as opposed to

    // a JSExceptionState with no information) when there is no pending

    // exception.

    if (JS_IsExceptionPending(mJSContext)) {

        mState = JS_SaveExceptionState(mJSContext);

        JS_ClearPendingException(mJSContext);

    }

    return true;

}

AutoScriptEvaluate::~AutoScriptEvaluate()

{

    if (!mJSContext || !mEvaluated)

        return;

    if (mState)

        JS_RestoreExceptionState(mJSContext, mState);

    else

        JS_ClearPendingException(mJSContext);

    JS_EndRequest(mJSContext);

    // If this is a JSContext that has a private context that provides a

    // nsIXPCScriptNotify interface, then notify the object the script has

    // been executed.

    //

    // Note: We rely on the rule that if any JSContext in our JSRuntime has

    // private data that points to an nsISupports subclass, it has also set

    // the JSOPTION_PRIVATE_IS_NSISUPPORTS option.

    if (JS_GetOptions(mJSContext) & JSOPTION_PRIVATE_IS_NSISUPPORTS) {

        nsCOMPtr<nsIXPCScriptNotify> scriptNotify =

            do_QueryInterface(static_cast<nsISupports*>

                                         (JS_GetContextPrivate(mJSContext)));

        if (scriptNotify)

            scriptNotify->ScriptExecuted();

    }

    if (mErrorReporterSet)

        JS_SetErrorReporter(mJSContext, NULL);

}

// It turns out that some errors may be not worth reporting. So, this

// function is factored out to manage that.

JSBool xpc_IsReportableErrorCode(nsresult code)

{

    if (NS_SUCCEEDED(code))

        return false;

    switch (code) {

        // Error codes that we don't want to report as errors...

        // These generally indicate bad interface design AFAIC.

        case NS_ERROR_FACTORY_REGISTER_AGAIN:

        case NS_BASE_STREAM_WOULD_BLOCK:

            return false;

        default:

            return true;

    }

}

// static

nsresult

nsXPCWrappedJSClass::GetNewOrUsed(JSContext* cx, REFNSIID aIID,

                                  nsXPCWrappedJSClass** resultClazz)

{

    nsXPCWrappedJSClass* clazz = nullptr;

    XPCJSRuntime* rt = nsXPConnect::GetRuntimeInstance();

    {   // scoped lock

        XPCAutoLock lock(rt->GetMapLock());

        IID2WrappedJSClassMap* map = rt->GetWrappedJSClassMap();

        clazz = map->Find(aIID);

        NS_IF_ADDREF(clazz);

    }

    if (!clazz) {

        nsCOMPtr<nsIInterfaceInfo> info;

        nsXPConnect::XPConnect()->GetInfoForIID(&aIID, getter_AddRefs(info));

        if (info) {

            bool canScript, isBuiltin;

            if (NS_SUCCEEDED(info->IsScriptable(&canScript)) && canScript &&

                NS_SUCCEEDED(info->IsBuiltinClass(&isBuiltin)) && !isBuiltin &&

                nsXPConnect::IsISupportsDescendant(info)) {

                clazz = new nsXPCWrappedJSClass(cx, aIID, info);

                if (clazz && !clazz->mDescriptors)

                    NS_RELEASE(clazz);  // sets clazz to nullptr

            }

        }

    }

    *resultClazz = clazz;

    return NS_OK;

}

nsXPCWrappedJSClass::nsXPCWrappedJSClass(JSContext* cx, REFNSIID aIID,

                                         nsIInterfaceInfo* aInfo)

    : mRuntime(nsXPConnect::GetRuntimeInstance()),

      mInfo(aInfo),

      mName(nullptr),

      mIID(aIID),

      mDescriptors(nullptr)

{

    NS_ADDREF(mInfo);

    NS_ADDREF_THIS();

    {   // scoped lock

        XPCAutoLock lock(mRuntime->GetMapLock());

        mRuntime->GetWrappedJSClassMap()->Add(this);

    }

    uint16_t methodCount;

    if (NS_SUCCEEDED(mInfo->GetMethodCount(&methodCount))) {

        if (methodCount) {

            int wordCount = (methodCount/32)+1;

            if (nullptr != (mDescriptors = new uint32_t[wordCount])) {

                int i;

                // init flags to 0;

                for (i = wordCount-1; i >= 0; i--)

                    mDescriptors[i] = 0;

                for (i = 0; i < methodCount; i++) {

                    const nsXPTMethodInfo* info;

                    if (NS_SUCCEEDED(mInfo->GetMethodInfo(i, &info)))

                        SetReflectable(i, XPCConvert::IsMethodReflectable(*info));

                    else {

                        delete [] mDescriptors;

                        mDescriptors = nullptr;

                        break;

                    }

                }

            }

        } else {

            mDescriptors = &zero_methods_descriptor;

        }

    }

}

nsXPCWrappedJSClass::~nsXPCWrappedJSClass()

{

    if (mDescriptors && mDescriptors != &zero_methods_descriptor)

        delete [] mDescriptors;

    if (mRuntime)

    {   // scoped lock

        XPCAutoLock lock(mRuntime->GetMapLock());

        mRuntime->GetWrappedJSClassMap()->Remove(this);

    }

    if (mName)

        nsMemory::Free(mName);

    NS_IF_RELEASE(mInfo);

}

JSObject*

nsXPCWrappedJSClass::CallQueryInterfaceOnJSObject(JSContext* cx,

                                                  JSObject* jsobjArg,

                                                  REFNSIID aIID)

{

    RootedObject jsobj(cx, jsobjArg);

    JSObject* id;

    RootedValue retval(cx);

    RootedObject retObj(cx);

    JSBool success = false;

    jsid funid;

    RootedValue fun(cx);

    // Don't call the actual function on a content object. We'll determine

    // whether or not a content object is capable of implementing the

    // interface (i.e. whether the interface is scriptable) and most content

    // objects don't have QI implementations anyway. Also see bug 503926.

    if (!xpc::AccessCheck::isChrome(js::GetObjectCompartment(jsobj))) {

        return nullptr;

    }

    // OK, it looks like we'll be calling into JS code.

    AutoScriptEvaluate scriptEval(cx);

    // XXX we should install an error reporter that will send reports to

    // the JS error console service.

    if (!scriptEval.StartEvaluating(jsobj))

        return nullptr;

    // check upfront for the existence of the function property

    funid = mRuntime->GetStringID(XPCJSRuntime::IDX_QUERY_INTERFACE);

    if (!JS_GetPropertyById(cx, jsobj, funid, fun.address()) || JSVAL_IS_PRIMITIVE(fun))

        return nullptr;

    // Ensure that we are asking for a scriptable interface.

    // NB:  It's important for security that this check is here rather

    // than later, since it prevents untrusted objects from implementing

    // some interfaces in JS and aggregating a trusted object to

    // implement intentionally (for security) unscriptable interfaces.

    // We so often ask for nsISupports that we can short-circuit the test...

    if (!aIID.Equals(NS_GET_IID(nsISupports))) {

        nsCOMPtr<nsIInterfaceInfo> info;

        nsXPConnect::XPConnect()->GetInfoForIID(&aIID, getter_AddRefs(info));

        if (!info)

            return nullptr;

        bool canScript, isBuiltin;

        if (NS_FAILED(info->IsScriptable(&canScript)) || !canScript ||

            NS_FAILED(info->IsBuiltinClass(&isBuiltin)) || isBuiltin)

            return nullptr;

    }

    id = xpc_NewIDObject(cx, jsobj, aIID);

    if (id) {

        // Throwing NS_NOINTERFACE is the prescribed way to fail QI from JS. It

        // is not an exception that is ever worth reporting, but we don't want

        // to eat all exceptions either.

        uint32_t oldOpts =

          JS_SetOptions(cx, JS_GetOptions(cx) | JSOPTION_DONT_REPORT_UNCAUGHT);

        jsval args[1] = {OBJECT_TO_JSVAL(id)};

        success = JS_CallFunctionValue(cx, jsobj, fun, 1, args, retval.address());

        JS_SetOptions(cx, oldOpts);

        if (!success) {

            NS_ASSERTION(JS_IsExceptionPending(cx),

                         "JS failed without setting an exception!");

            RootedValue jsexception(cx, NullValue());

            if (JS_GetPendingException(cx, jsexception.address())) {

                nsresult rv;

                if (jsexception.isObject()) {

                    // XPConnect may have constructed an object to represent a

                    // C++ QI failure. See if that is the case.

                    nsCOMPtr<nsIXPConnectWrappedNative> wrapper;

                    nsXPConnect::XPConnect()->

                        GetWrappedNativeOfJSObject(cx,

                                                   &jsexception.toObject(),

                                                   getter_AddRefs(wrapper));

                    if (wrapper) {

                        nsCOMPtr<nsIException> exception =

                            do_QueryWrappedNative(wrapper);

                        if (exception &&

                            NS_SUCCEEDED(exception->GetResult(&rv)) &&

                            rv == NS_NOINTERFACE) {

                            JS_ClearPendingException(cx);

                        }

                    }

                } else if (JSVAL_IS_NUMBER(jsexception)) {

                    // JS often throws an nsresult.

                    if (JSVAL_IS_DOUBLE(jsexception))

                        // Visual Studio 9 doesn't allow casting directly from

                        // a double to an enumeration type, contrary to

                        // 5.2.9(10) of C++11, so add an intermediate cast.

                        rv = (nsresult)(uint32_t)(JSVAL_TO_DOUBLE(jsexception));

                    else

                        rv = (nsresult)(JSVAL_TO_INT(jsexception));

                    if (rv == NS_NOINTERFACE)

                        JS_ClearPendingException(cx);

                }

            }

            // Don't report if reporting was disabled by someone else.

            if (!(oldOpts & JSOPTION_DONT_REPORT_UNCAUGHT))

                JS_ReportPendingException(cx);

        }

    }

    if (success)

        success = JS_ValueToObject(cx, retval, retObj.address());

    return success ? retObj.get() : nullptr;

}

/***************************************************************************/

static JSBool

GetNamedPropertyAsVariantRaw(XPCCallContext& ccx,

                             JSObject* aJSObj,

                             jsid aName,

                             nsIVariant** aResult,

                             nsresult* pErr)

{

    nsXPTType type = nsXPTType((uint8_t)TD_INTERFACE_TYPE);

    RootedValue val(ccx);

    return JS_GetPropertyById(ccx, aJSObj, aName, val.address()) &&

           // Note that this always takes the T_INTERFACE path through

           // JSData2Native, so the value passed for useAllocator

           // doesn't really matter. We pass true for consistency.

           XPCConvert::JSData2Native(aResult, val, type, true,

                                     &NS_GET_IID(nsIVariant), pErr);

}

// static

nsresult

nsXPCWrappedJSClass::GetNamedPropertyAsVariant(XPCCallContext& ccx,

                                               JSObject* aJSObjArg,

                                               const nsAString& aName,

                                               nsIVariant** aResult)

{

    JSContext* cx = ccx.GetJSContext();

    RootedObject aJSObj(cx, aJSObjArg);

    JSBool ok;

    RootedId id(cx);

    nsresult rv = NS_ERROR_FAILURE;

    AutoScriptEvaluate scriptEval(cx);

    if (!scriptEval.StartEvaluating(aJSObj))

        return NS_ERROR_FAILURE;

    // Wrap the string in a jsval after the AutoScriptEvaluate, so that the

    // resulting value ends up in the correct compartment.

    nsStringBuffer* buf;

    jsval jsstr = XPCStringConvert::ReadableToJSVal(ccx, aName, &buf);

    if (JSVAL_IS_NULL(jsstr))

        return NS_ERROR_OUT_OF_MEMORY;

    if (buf)

        buf->AddRef();

    ok = JS_ValueToId(cx, jsstr, id.address()) &&

        GetNamedPropertyAsVariantRaw(ccx, aJSObj, id, aResult, &rv);

    return ok ? NS_OK : NS_FAILED(rv) ? rv : NS_ERROR_FAILURE;

}

/***************************************************************************/

// static

nsresult

nsXPCWrappedJSClass::BuildPropertyEnumerator(XPCCallContext& ccx,

                                             JSObject* aJSObjArg,

                                             nsISimpleEnumerator** aEnumerate)

{

    JSContext* cx = ccx.GetJSContext();

    RootedObject aJSObj(cx, aJSObjArg);

    AutoScriptEvaluate scriptEval(cx);

    if (!scriptEval.StartEvaluating(aJSObj))

        return NS_ERROR_FAILURE;

    AutoIdArray idArray(cx, JS_Enumerate(cx, aJSObj));