gecko-dev/dom/xslt/xpath/txXPCOMExtensionFunction.cpp

618 lines
17 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 "nsAutoPtr.h"
#include "nsComponentManagerUtils.h"
#include "nsDependentString.h"
#include "nsIAtom.h"
#include "nsIInterfaceInfoManager.h"
#include "nsServiceManagerUtils.h"
#include "txExpr.h"
#include "txIFunctionEvaluationContext.h"
#include "txIXPathContext.h"
#include "txNodeSetAdaptor.h"
#include "txXPathTreeWalker.h"
#include "xptcall.h"
#include "txXPathObjectAdaptor.h"
#include "mozilla/Attributes.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/dom/ScriptSettings.h"
#include "nsIClassInfo.h"
#include "nsIInterfaceInfo.h"
#include "js/RootingAPI.h"
NS_IMPL_ISUPPORTS(txXPathObjectAdaptor, txIXPathObject)
class txFunctionEvaluationContext final : public txIFunctionEvaluationContext
{
public:
txFunctionEvaluationContext(txIEvalContext *aContext, nsISupports *aState);
NS_DECL_ISUPPORTS
NS_DECL_TXIFUNCTIONEVALUATIONCONTEXT
void ClearContext()
{
mContext = nullptr;
}
private:
~txFunctionEvaluationContext() {}
txIEvalContext *mContext;
nsCOMPtr<nsISupports> mState;
};
txFunctionEvaluationContext::txFunctionEvaluationContext(txIEvalContext *aContext,
nsISupports *aState)
: mContext(aContext),
mState(aState)
{
}
NS_IMPL_ISUPPORTS(txFunctionEvaluationContext, txIFunctionEvaluationContext)
NS_IMETHODIMP
txFunctionEvaluationContext::GetPosition(uint32_t *aPosition)
{
NS_ENSURE_TRUE(mContext, NS_ERROR_FAILURE);
*aPosition = mContext->position();
return NS_OK;
}
NS_IMETHODIMP
txFunctionEvaluationContext::GetSize(uint32_t *aSize)
{
NS_ENSURE_TRUE(mContext, NS_ERROR_FAILURE);
*aSize = mContext->size();
return NS_OK;
}
NS_IMETHODIMP
txFunctionEvaluationContext::GetContextNode(nsIDOMNode **aNode)
{
NS_ENSURE_TRUE(mContext, NS_ERROR_FAILURE);
return txXPathNativeNode::getNode(mContext->getContextNode(), aNode);
}
NS_IMETHODIMP
txFunctionEvaluationContext::GetState(nsISupports **aState)
{
NS_IF_ADDREF(*aState = mState);
return NS_OK;
}
enum txArgumentType {
eBOOLEAN = nsXPTType::T_BOOL,
eNUMBER = nsXPTType::T_DOUBLE,
eSTRING = nsXPTType::T_DOMSTRING,
eNODESET,
eCONTEXT,
eOBJECT,
eUNKNOWN
};
class txXPCOMExtensionFunctionCall : public FunctionCall
{
public:
txXPCOMExtensionFunctionCall(nsISupports *aHelper, const nsIID &aIID,
uint16_t aMethodIndex,
#ifdef TX_TO_STRING
nsIAtom *aName,
#endif
nsISupports *aState);
TX_DECL_FUNCTION
private:
txArgumentType GetParamType(const nsXPTParamInfo &aParam,
nsIInterfaceInfo *aInfo);
nsCOMPtr<nsISupports> mHelper;
nsIID mIID;
uint16_t mMethodIndex;
#ifdef TX_TO_STRING
nsCOMPtr<nsIAtom> mName;
#endif
nsCOMPtr<nsISupports> mState;
};
txXPCOMExtensionFunctionCall::txXPCOMExtensionFunctionCall(nsISupports *aHelper,
const nsIID &aIID,
uint16_t aMethodIndex,
#ifdef TX_TO_STRING
nsIAtom *aName,
#endif
nsISupports *aState)
: mHelper(aHelper),
mIID(aIID),
mMethodIndex(aMethodIndex),
#ifdef TX_TO_STRING
mName(aName),
#endif
mState(aState)
{
}
class txInterfacesArrayHolder
{
public:
txInterfacesArrayHolder(nsIID **aArray, uint32_t aCount) : mArray(aArray),
mCount(aCount)
{
}
~txInterfacesArrayHolder()
{
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mCount, mArray);
}
private:
nsIID **mArray;
uint32_t mCount;
};
static nsresult
LookupFunction(const char *aContractID, nsIAtom* aName, nsIID &aIID,
uint16_t &aMethodIndex, nsISupports **aHelper)
{
nsresult rv;
nsCOMPtr<nsISupports> helper = do_GetService(aContractID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIClassInfo> classInfo = do_QueryInterface(helper, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIInterfaceInfoManager> iim =
do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID);
NS_ENSURE_TRUE(iim, NS_ERROR_FAILURE);
nsIID** iidArray = nullptr;
uint32_t iidCount = 0;
rv = classInfo->GetInterfaces(&iidCount, &iidArray);
NS_ENSURE_SUCCESS(rv, rv);
txInterfacesArrayHolder holder(iidArray, iidCount);
// Remove any minus signs and uppercase the following letter (so
// foo-bar becomes fooBar). Note that if there are any names that already
// have uppercase letters they might cause false matches (both fooBar and
// foo-bar matching fooBar).
const char16_t *name = aName->GetUTF16String();
nsAutoCString methodName;
char16_t letter;
bool upperNext = false;
while ((letter = *name)) {
if (letter == '-') {
upperNext = true;
}
else {
MOZ_ASSERT(nsCRT::IsAscii(letter),
"invalid static_cast coming up");
methodName.Append(upperNext ?
nsCRT::ToUpper(static_cast<char>(letter)) :
letter);
upperNext = false;
}
++name;
}
uint32_t i;
for (i = 0; i < iidCount; ++i) {
nsIID *iid = iidArray[i];
nsCOMPtr<nsIInterfaceInfo> info;
rv = iim->GetInfoForIID(iid, getter_AddRefs(info));
NS_ENSURE_SUCCESS(rv, rv);
uint16_t methodIndex;
const nsXPTMethodInfo *methodInfo;
rv = info->GetMethodInfoForName(methodName.get(), &methodIndex,
&methodInfo);
if (NS_SUCCEEDED(rv)) {
// Exclude notxpcom and hidden. Also check that we have at least a
// return value (the xpidl compiler ensures that that return value
// is the last argument).
uint8_t paramCount = methodInfo->GetParamCount();
if (methodInfo->IsNotXPCOM() || methodInfo->IsHidden() ||
paramCount == 0 ||
!methodInfo->GetParam(paramCount - 1).IsRetval()) {
return NS_ERROR_FAILURE;
}
aIID = *iid;
aMethodIndex = methodIndex;
return helper->QueryInterface(aIID, (void**)aHelper);
}
}
return NS_ERROR_XPATH_UNKNOWN_FUNCTION;
}
/* static */
nsresult
TX_ResolveFunctionCallXPCOM(const nsCString &aContractID, int32_t aNamespaceID,
nsIAtom* aName, nsISupports *aState,
FunctionCall **aFunction)
{
nsIID iid;
uint16_t methodIndex = 0;
nsCOMPtr<nsISupports> helper;
nsresult rv = LookupFunction(aContractID.get(), aName, iid, methodIndex,
getter_AddRefs(helper));
NS_ENSURE_SUCCESS(rv, rv);
if (!aFunction) {
return NS_OK;
}
*aFunction = new txXPCOMExtensionFunctionCall(helper, iid, methodIndex,
#ifdef TX_TO_STRING
aName,
#endif
aState);
return NS_OK;
}
txArgumentType
txXPCOMExtensionFunctionCall::GetParamType(const nsXPTParamInfo &aParam,
nsIInterfaceInfo *aInfo)
{
uint8_t tag = aParam.GetType().TagPart();
switch (tag) {
case nsXPTType::T_BOOL:
case nsXPTType::T_DOUBLE:
case nsXPTType::T_DOMSTRING:
{
return txArgumentType(tag);
}
case nsXPTType::T_INTERFACE:
case nsXPTType::T_INTERFACE_IS:
{
nsIID iid;
aInfo->GetIIDForParamNoAlloc(mMethodIndex, &aParam, &iid);
if (iid.Equals(NS_GET_IID(txINodeSet))) {
return eNODESET;
}
if (iid.Equals(NS_GET_IID(txIFunctionEvaluationContext))) {
return eCONTEXT;
}
if (iid.Equals(NS_GET_IID(txIXPathObject))) {
return eOBJECT;
}
return eUNKNOWN;
}
default:
{
// XXX Error!
return eUNKNOWN;
}
}
}
class txParamArrayHolder
{
public:
txParamArrayHolder()
: mCount(0)
{
}
txParamArrayHolder(txParamArrayHolder&& rhs)
: mArray(mozilla::Move(rhs.mArray))
, mCount(rhs.mCount)
{
rhs.mCount = 0;
}
~txParamArrayHolder();
bool Init(uint8_t aCount);
operator nsXPTCVariant*() const
{
return mArray.get();
}
void trace(JSTracer* trc) {
for (uint8_t i = 0; i < mCount; ++i) {
if (mArray[i].type == nsXPTType::T_JSVAL) {
JS::UnsafeTraceRoot(trc, &mArray[i].val.j, "txParam value");
}
}
}
private:
mozilla::UniquePtr<nsXPTCVariant[]> mArray;
uint8_t mCount;
};
txParamArrayHolder::~txParamArrayHolder()
{
uint8_t i;
for (i = 0; i < mCount; ++i) {
nsXPTCVariant &variant = mArray[i];
if (variant.DoesValNeedCleanup()) {
if (variant.type.TagPart() == nsXPTType::T_DOMSTRING)
delete (nsAString*)variant.val.p;
else {
MOZ_ASSERT(variant.type.TagPart() == nsXPTType::T_INTERFACE ||
variant.type.TagPart() == nsXPTType::T_INTERFACE_IS,
"We only support cleanup of strings and interfaces "
"here, and this looks like neither!");
static_cast<nsISupports*>(variant.val.p)->Release();
}
}
}
}
bool
txParamArrayHolder::Init(uint8_t aCount)
{
mCount = aCount;
mArray = mozilla::MakeUnique<nsXPTCVariant[]>(mCount);
if (!mArray) {
return false;
}
memset(mArray.get(), 0, mCount * sizeof(nsXPTCVariant));
return true;
}
nsresult
txXPCOMExtensionFunctionCall::evaluate(txIEvalContext* aContext,
txAExprResult** aResult)
{
nsCOMPtr<nsIInterfaceInfoManager> iim =
do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID);
NS_ENSURE_TRUE(iim, NS_ERROR_FAILURE);
nsCOMPtr<nsIInterfaceInfo> info;
nsresult rv = iim->GetInfoForIID(&mIID, getter_AddRefs(info));
NS_ENSURE_SUCCESS(rv, rv);
const nsXPTMethodInfo *methodInfo;
rv = info->GetMethodInfo(mMethodIndex, &methodInfo);
NS_ENSURE_SUCCESS(rv, rv);
uint8_t paramCount = methodInfo->GetParamCount();
uint8_t inArgs = paramCount - 1;
JS::Rooted<txParamArrayHolder> invokeParams(mozilla::dom::RootingCx());
if (!invokeParams.get().Init(paramCount)) {
return NS_ERROR_OUT_OF_MEMORY;
}
const nsXPTParamInfo &paramInfo = methodInfo->GetParam(0);
txArgumentType type = GetParamType(paramInfo, info);
if (type == eUNKNOWN) {
return NS_ERROR_FAILURE;
}
txFunctionEvaluationContext *context;
uint32_t paramStart = 0;
if (type == eCONTEXT) {
if (paramInfo.IsOut()) {
// We don't support out values.
return NS_ERROR_FAILURE;
}
// Create context wrapper.
context = new txFunctionEvaluationContext(aContext, mState);
nsXPTCVariant &invokeParam = invokeParams.get()[0];
invokeParam.type = paramInfo.GetType();
invokeParam.SetValNeedsCleanup();
NS_ADDREF((txIFunctionEvaluationContext*&)invokeParam.val.p = context);
// Skip first argument, since it's the context.
paramStart = 1;
}
else {
context = nullptr;
}
// XXX varargs
if (!requireParams(inArgs - paramStart, inArgs - paramStart, aContext)) {
return NS_ERROR_FAILURE;
}
uint32_t i;
for (i = paramStart; i < inArgs; ++i) {
Expr* expr = mParams[i - paramStart];
const nsXPTParamInfo &paramInfo = methodInfo->GetParam(i);
txArgumentType type = GetParamType(paramInfo, info);
if (type == eUNKNOWN) {
return NS_ERROR_FAILURE;
}
nsXPTCVariant &invokeParam = invokeParams.get()[i];
if (paramInfo.IsOut()) {
// We don't support out values.
return NS_ERROR_FAILURE;
}
invokeParam.type = paramInfo.GetType();
switch (type) {
case eNODESET:
{
RefPtr<txNodeSet> nodes;
rv = evaluateToNodeSet(expr, aContext, getter_AddRefs(nodes));
NS_ENSURE_SUCCESS(rv, rv);
txNodeSetAdaptor *adaptor = new txNodeSetAdaptor(nodes);
if (!adaptor) {
return NS_ERROR_OUT_OF_MEMORY;
}
nsCOMPtr<txINodeSet> nodeSet = adaptor;
rv = adaptor->Init();
NS_ENSURE_SUCCESS(rv, rv);
invokeParam.SetValNeedsCleanup();
nodeSet.swap((txINodeSet*&)invokeParam.val.p);
break;
}
case eBOOLEAN:
{
rv = expr->evaluateToBool(aContext, invokeParam.val.b);
NS_ENSURE_SUCCESS(rv, rv);
break;
}
case eNUMBER:
{
double dbl;
rv = evaluateToNumber(mParams[0], aContext, &dbl);
NS_ENSURE_SUCCESS(rv, rv);
invokeParam.val.d = dbl;
break;
}
case eSTRING:
{
nsString *value = new nsString();
if (!value) {
return NS_ERROR_OUT_OF_MEMORY;
}
rv = expr->evaluateToString(aContext, *value);
NS_ENSURE_SUCCESS(rv, rv);
invokeParam.SetValNeedsCleanup();
invokeParam.val.p = value;
break;
}
case eOBJECT:
{
RefPtr<txAExprResult> exprRes;
rv = expr->evaluate(aContext, getter_AddRefs(exprRes));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<txIXPathObject> adaptor =
new txXPathObjectAdaptor(exprRes);
if (!adaptor) {
return NS_ERROR_OUT_OF_MEMORY;
}
invokeParam.SetValNeedsCleanup();
adaptor.swap((txIXPathObject*&)invokeParam.val.p);
break;
}
case eCONTEXT:
case eUNKNOWN:
{
// We only support passing the context as the *first* argument.
return NS_ERROR_FAILURE;
}
}
}
const nsXPTParamInfo &returnInfo = methodInfo->GetParam(inArgs);
txArgumentType returnType = GetParamType(returnInfo, info);
if (returnType == eUNKNOWN) {
return NS_ERROR_FAILURE;
}
nsXPTCVariant &returnParam = invokeParams.get()[inArgs];
returnParam.type = returnInfo.GetType();
if (returnType == eSTRING) {
nsString *value = new nsString();
returnParam.SetValNeedsCleanup();
returnParam.val.p = value;
}
else {
returnParam.SetIndirect();
if (returnType == eNODESET || returnType == eOBJECT) {
returnParam.SetValNeedsCleanup();
}
}
rv = NS_InvokeByIndex(mHelper, mMethodIndex, paramCount, invokeParams.get());
// In case someone is holding on to the txFunctionEvaluationContext which
// could thus stay alive longer than this function.
if (context) {
context->ClearContext();
}
NS_ENSURE_SUCCESS(rv, rv);
switch (returnType) {
case eNODESET:
{
txINodeSet* nodeSet = static_cast<txINodeSet*>(returnParam.val.p);
nsCOMPtr<txIXPathObject> object = do_QueryInterface(nodeSet, &rv);
NS_ENSURE_SUCCESS(rv, rv);
NS_ADDREF(*aResult = object->GetResult());
return NS_OK;
}
case eBOOLEAN:
{
aContext->recycler()->getBoolResult(returnParam.val.b, aResult);
return NS_OK;
}
case eNUMBER:
{
return aContext->recycler()->getNumberResult(returnParam.val.d,
aResult);
}
case eSTRING:
{
nsString *returned = static_cast<nsString*>
(returnParam.val.p);
return aContext->recycler()->getStringResult(*returned, aResult);
}
case eOBJECT:
{
txIXPathObject *object =
static_cast<txIXPathObject*>(returnParam.val.p);
NS_ADDREF(*aResult = object->GetResult());
return NS_OK;
}
default:
{
// Huh?
return NS_ERROR_FAILURE;
}
}
}
Expr::ResultType
txXPCOMExtensionFunctionCall::getReturnType()
{
// It doesn't really matter what we return here, but it might
// be a good idea to try to keep this as unoptimizable as possible
return ANY_RESULT;
}
bool
txXPCOMExtensionFunctionCall::isSensitiveTo(ContextSensitivity aContext)
{
// It doesn't really matter what we return here, but it might
// be a good idea to try to keep this as unoptimizable as possible
return true;
}
#ifdef TX_TO_STRING
nsresult
txXPCOMExtensionFunctionCall::getNameAtom(nsIAtom** aAtom)
{
NS_ADDREF(*aAtom = mName);
return NS_OK;
}
#endif