2005-11-02 10:35:22 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
2012-05-21 15:12:37 +04:00
|
|
|
/* 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/. */
|
2005-11-02 10:35:22 +03:00
|
|
|
|
2013-07-04 19:39:24 +04:00
|
|
|
#include "mozilla/dom/XPathEvaluator.h"
|
2014-05-08 02:05:37 +04:00
|
|
|
#include "mozilla/Move.h"
|
2005-11-02 10:35:22 +03:00
|
|
|
#include "nsCOMPtr.h"
|
2005-11-02 10:42:24 +03:00
|
|
|
#include "nsIAtom.h"
|
2013-07-04 19:40:10 +04:00
|
|
|
#include "mozilla/dom/XPathExpression.h"
|
2013-07-04 19:39:28 +04:00
|
|
|
#include "XPathResult.h"
|
2005-11-02 10:37:50 +03:00
|
|
|
#include "nsContentCID.h"
|
2005-11-02 20:34:14 +03:00
|
|
|
#include "txExpr.h"
|
|
|
|
#include "txExprParser.h"
|
2012-07-27 18:03:27 +04:00
|
|
|
#include "nsError.h"
|
2005-11-02 10:38:12 +03:00
|
|
|
#include "txURIUtils.h"
|
2005-11-02 10:40:13 +03:00
|
|
|
#include "nsIDocument.h"
|
2005-11-02 10:39:54 +03:00
|
|
|
#include "nsIDOMDocument.h"
|
2005-11-02 10:41:59 +03:00
|
|
|
#include "nsDOMString.h"
|
2014-02-28 03:04:46 +04:00
|
|
|
#include "nsNameSpaceManager.h"
|
2005-11-02 20:34:14 +03:00
|
|
|
#include "nsContentUtils.h"
|
2013-07-09 20:09:39 +04:00
|
|
|
#include "txIXPathContext.h"
|
2012-12-14 23:10:49 +04:00
|
|
|
#include "mozilla/dom/XPathEvaluatorBinding.h"
|
2013-07-04 19:40:06 +04:00
|
|
|
#include "mozilla/dom/BindingUtils.h"
|
2014-10-14 18:27:24 +04:00
|
|
|
#include "mozilla/dom/XPathNSResolverBinding.h"
|
2012-12-14 23:10:49 +04:00
|
|
|
|
2013-08-24 01:11:30 +04:00
|
|
|
extern nsresult
|
|
|
|
TX_ResolveFunctionCallXPCOM(const nsCString &aContractID, int32_t aNamespaceID,
|
|
|
|
nsIAtom *aName, nsISupports *aState,
|
|
|
|
FunctionCall **aFunction);
|
|
|
|
|
|
|
|
namespace mozilla {
|
|
|
|
namespace dom {
|
2005-11-02 10:35:22 +03:00
|
|
|
|
2005-11-18 16:39:43 +03:00
|
|
|
// txIParseContext implementation
|
2013-08-24 01:11:30 +04:00
|
|
|
class XPathEvaluatorParseContext : public txIParseContext
|
2005-11-18 16:39:43 +03:00
|
|
|
{
|
|
|
|
public:
|
2014-10-14 18:27:24 +04:00
|
|
|
XPathEvaluatorParseContext(XPathNSResolver* aResolver,
|
2013-08-24 01:11:30 +04:00
|
|
|
bool aIsCaseSensitive)
|
2012-08-10 22:01:16 +04:00
|
|
|
: mResolver(aResolver),
|
2013-09-02 20:01:55 +04:00
|
|
|
mResolverNode(nullptr),
|
|
|
|
mLastError(NS_OK),
|
|
|
|
mIsCaseSensitive(aIsCaseSensitive)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
XPathEvaluatorParseContext(nsINode* aResolver,
|
|
|
|
bool aIsCaseSensitive)
|
|
|
|
: mResolver(nullptr),
|
|
|
|
mResolverNode(aResolver),
|
2005-11-18 16:39:43 +03:00
|
|
|
mLastError(NS_OK),
|
|
|
|
mIsCaseSensitive(aIsCaseSensitive)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult getError()
|
|
|
|
{
|
|
|
|
return mLastError;
|
|
|
|
}
|
|
|
|
|
2012-08-22 19:56:38 +04:00
|
|
|
nsresult resolveNamespacePrefix(nsIAtom* aPrefix, int32_t& aID);
|
|
|
|
nsresult resolveFunctionCall(nsIAtom* aName, int32_t aID,
|
2006-11-17 00:42:25 +03:00
|
|
|
FunctionCall** aFunction);
|
2011-09-29 10:19:26 +04:00
|
|
|
bool caseInsensitiveNameTests();
|
2012-08-22 19:56:38 +04:00
|
|
|
void SetErrorOffset(uint32_t aOffset);
|
2005-11-18 16:39:43 +03:00
|
|
|
|
|
|
|
private:
|
2014-10-14 18:27:24 +04:00
|
|
|
XPathNSResolver* mResolver;
|
2013-09-02 20:01:55 +04:00
|
|
|
nsINode* mResolverNode;
|
2005-11-18 16:39:43 +03:00
|
|
|
nsresult mLastError;
|
2011-09-29 10:19:26 +04:00
|
|
|
bool mIsCaseSensitive;
|
2005-11-18 16:39:43 +03:00
|
|
|
};
|
|
|
|
|
2014-04-27 11:06:00 +04:00
|
|
|
NS_IMPL_ISUPPORTS(XPathEvaluator, nsIDOMXPathEvaluator)
|
2005-11-02 10:35:22 +03:00
|
|
|
|
2013-07-04 19:39:24 +04:00
|
|
|
XPathEvaluator::XPathEvaluator(nsIDocument* aDocument)
|
|
|
|
: mDocument(do_GetWeakReference(aDocument))
|
2005-11-02 10:35:22 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-06-23 23:56:07 +04:00
|
|
|
XPathEvaluator::~XPathEvaluator()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-11-02 10:35:22 +03:00
|
|
|
NS_IMETHODIMP
|
2013-08-24 01:11:30 +04:00
|
|
|
XPathEvaluator::Evaluate(const nsAString & aExpression,
|
|
|
|
nsIDOMNode *aContextNode,
|
2014-10-14 18:27:24 +04:00
|
|
|
nsIDOMNode *aResolver,
|
2013-08-24 01:11:30 +04:00
|
|
|
uint16_t aType,
|
|
|
|
nsISupports *aInResult,
|
|
|
|
nsISupports **aResult)
|
2005-11-02 10:35:22 +03:00
|
|
|
{
|
2014-10-14 18:27:24 +04:00
|
|
|
nsCOMPtr<nsINode> resolver = do_QueryInterface(aResolver);
|
2014-06-27 23:39:50 +04:00
|
|
|
ErrorResult rv;
|
|
|
|
nsAutoPtr<XPathExpression> expression(CreateExpression(aExpression,
|
2014-10-14 18:27:24 +04:00
|
|
|
resolver, rv));
|
2014-06-27 23:39:50 +04:00
|
|
|
if (rv.Failed()) {
|
2015-04-27 16:18:51 +03:00
|
|
|
return rv.StealNSResult();
|
2014-06-27 23:39:50 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsINode> node = do_QueryInterface(aContextNode);
|
|
|
|
if (!node) {
|
|
|
|
return NS_ERROR_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsIXPathResult> inResult = do_QueryInterface(aInResult);
|
|
|
|
nsRefPtr<XPathResult> result =
|
|
|
|
expression->Evaluate(*node, aType,
|
|
|
|
static_cast<XPathResult*>(inResult.get()), rv);
|
|
|
|
if (rv.Failed()) {
|
2015-04-27 16:18:51 +03:00
|
|
|
return rv.StealNSResult();
|
2014-06-27 23:39:50 +04:00
|
|
|
}
|
2005-11-02 10:35:22 +03:00
|
|
|
|
2014-06-27 23:39:50 +04:00
|
|
|
*aResult = ToSupports(result.forget().take());
|
|
|
|
|
|
|
|
return NS_OK;
|
2005-11-02 10:35:22 +03:00
|
|
|
}
|
2005-11-02 10:37:50 +03:00
|
|
|
|
2013-09-02 20:01:55 +04:00
|
|
|
XPathExpression*
|
|
|
|
XPathEvaluator::CreateExpression(const nsAString& aExpression,
|
2014-10-14 18:27:24 +04:00
|
|
|
XPathNSResolver* aResolver, ErrorResult& aRv)
|
2013-09-02 20:01:55 +04:00
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocument);
|
2015-03-03 14:08:59 +03:00
|
|
|
XPathEvaluatorParseContext pContext(aResolver,
|
|
|
|
!(doc && doc->IsHTMLDocument()));
|
2013-09-02 20:01:55 +04:00
|
|
|
return CreateExpression(aExpression, &pContext, doc, aRv);
|
|
|
|
}
|
|
|
|
|
|
|
|
XPathExpression*
|
|
|
|
XPathEvaluator::CreateExpression(const nsAString& aExpression,
|
|
|
|
nsINode* aResolver, ErrorResult& aRv)
|
|
|
|
{
|
|
|
|
nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocument);
|
2015-03-03 14:08:59 +03:00
|
|
|
XPathEvaluatorParseContext pContext(aResolver,
|
|
|
|
!(doc && doc->IsHTMLDocument()));
|
2013-09-02 20:01:55 +04:00
|
|
|
return CreateExpression(aExpression, &pContext, doc, aRv);
|
|
|
|
}
|
2005-11-02 10:39:52 +03:00
|
|
|
|
2014-06-27 23:39:50 +04:00
|
|
|
XPathExpression*
|
2013-08-24 01:11:30 +04:00
|
|
|
XPathEvaluator::CreateExpression(const nsAString & aExpression,
|
2013-09-02 20:01:55 +04:00
|
|
|
txIParseContext* aContext,
|
|
|
|
nsIDocument* aDocument,
|
2014-06-27 23:39:50 +04:00
|
|
|
ErrorResult& aRv)
|
2006-07-13 18:21:53 +04:00
|
|
|
{
|
|
|
|
if (!mRecycler) {
|
2014-06-05 17:14:56 +04:00
|
|
|
mRecycler = new txResultRecycler;
|
2006-07-13 18:21:53 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
nsAutoPtr<Expr> expression;
|
2013-09-02 20:01:55 +04:00
|
|
|
aRv = txExprParser::createExpr(PromiseFlatString(aExpression), aContext,
|
2014-06-27 23:39:50 +04:00
|
|
|
getter_Transfers(expression));
|
|
|
|
if (aRv.Failed()) {
|
2015-04-27 16:18:52 +03:00
|
|
|
if (!aRv.ErrorCodeIs(NS_ERROR_DOM_NAMESPACE_ERR)) {
|
|
|
|
aRv.SuppressException();
|
2014-06-27 23:39:50 +04:00
|
|
|
aRv.Throw(NS_ERROR_DOM_INVALID_EXPRESSION_ERR);
|
2006-07-13 18:21:53 +04:00
|
|
|
}
|
|
|
|
|
2014-06-27 23:39:50 +04:00
|
|
|
return nullptr;
|
2006-07-13 18:21:53 +04:00
|
|
|
}
|
|
|
|
|
2013-09-02 20:01:55 +04:00
|
|
|
return new XPathExpression(Move(expression), mRecycler, aDocument);
|
2006-07-13 18:21:53 +04:00
|
|
|
}
|
|
|
|
|
2015-01-09 00:56:42 +03:00
|
|
|
bool
|
|
|
|
XPathEvaluator::WrapObject(JSContext* aCx,
|
Bug 1117172 part 2. Change the non-wrappercached WrapObject methods to allow passing in aGivenProto. r=peterv
The only manual changes here are to BindingUtils.h, Codegen.py, and
StructuredClone.cpp. The rest of this diff was generated by running the following commands:
find . -name "*.h" -o -name "*.cpp" | xargs perl -pi -e 'BEGIN { $/ = undef } s/WrapObject\((JSContext *\* *(?:aCx|cx)),(\s*)(JS::MutableHandle<JSObject\*> aReflector)/WrapObject(\1,\2JS::Handle<JSObject*> aGivenProto,\2\3/g'
find . -name "*.h" -o -name "*.cpp" | xargs perl -pi -e 'BEGIN { $/ = undef } s/(Binding(?:_workers)?::Wrap\((?:aCx|cx)), this, aReflector/\1, this, aGivenProto, aReflector/'
2015-03-19 17:13:32 +03:00
|
|
|
JS::Handle<JSObject*> aGivenProto,
|
2015-01-09 00:56:42 +03:00
|
|
|
JS::MutableHandle<JSObject*> aReflector)
|
2012-12-14 23:10:49 +04:00
|
|
|
{
|
Bug 1117172 part 2. Change the non-wrappercached WrapObject methods to allow passing in aGivenProto. r=peterv
The only manual changes here are to BindingUtils.h, Codegen.py, and
StructuredClone.cpp. The rest of this diff was generated by running the following commands:
find . -name "*.h" -o -name "*.cpp" | xargs perl -pi -e 'BEGIN { $/ = undef } s/WrapObject\((JSContext *\* *(?:aCx|cx)),(\s*)(JS::MutableHandle<JSObject\*> aReflector)/WrapObject(\1,\2JS::Handle<JSObject*> aGivenProto,\2\3/g'
find . -name "*.h" -o -name "*.cpp" | xargs perl -pi -e 'BEGIN { $/ = undef } s/(Binding(?:_workers)?::Wrap\((?:aCx|cx)), this, aReflector/\1, this, aGivenProto, aReflector/'
2015-03-19 17:13:32 +03:00
|
|
|
return dom::XPathEvaluatorBinding::Wrap(aCx, this, aGivenProto, aReflector);
|
2012-12-14 23:10:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* static */
|
2013-08-24 01:11:30 +04:00
|
|
|
already_AddRefed<XPathEvaluator>
|
|
|
|
XPathEvaluator::Constructor(const GlobalObject& aGlobal,
|
|
|
|
ErrorResult& rv)
|
2012-12-14 23:10:49 +04:00
|
|
|
{
|
2013-08-24 01:11:30 +04:00
|
|
|
nsRefPtr<XPathEvaluator> newObj = new XPathEvaluator(nullptr);
|
2012-12-14 23:10:49 +04:00
|
|
|
return newObj.forget();
|
|
|
|
}
|
|
|
|
|
2013-07-04 19:40:06 +04:00
|
|
|
already_AddRefed<XPathResult>
|
|
|
|
XPathEvaluator::Evaluate(JSContext* aCx, const nsAString& aExpression,
|
2014-11-04 12:20:08 +03:00
|
|
|
nsINode& aContextNode, XPathNSResolver* aResolver,
|
|
|
|
uint16_t aType, JS::Handle<JSObject*> aResult,
|
|
|
|
ErrorResult& rv)
|
2012-12-14 23:10:49 +04:00
|
|
|
{
|
2014-10-14 18:27:24 +04:00
|
|
|
nsAutoPtr<XPathExpression> expression(CreateExpression(aExpression,
|
|
|
|
aResolver, rv));
|
|
|
|
if (rv.Failed()) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2014-11-04 12:20:08 +03:00
|
|
|
return expression->Evaluate(aCx, aContextNode, aType, aResult, rv);
|
2012-12-14 23:10:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-11-02 10:37:50 +03:00
|
|
|
/*
|
2013-08-24 01:11:30 +04:00
|
|
|
* Implementation of txIParseContext private to XPathEvaluator, based on a
|
2014-10-14 18:27:24 +04:00
|
|
|
* XPathNSResolver
|
2005-11-02 10:37:50 +03:00
|
|
|
*/
|
|
|
|
|
2013-08-24 01:11:30 +04:00
|
|
|
nsresult XPathEvaluatorParseContext::resolveNamespacePrefix
|
2012-08-22 19:56:38 +04:00
|
|
|
(nsIAtom* aPrefix, int32_t& aID)
|
2005-11-02 10:37:50 +03:00
|
|
|
{
|
2005-11-02 10:40:54 +03:00
|
|
|
aID = kNameSpaceID_Unknown;
|
|
|
|
|
2013-09-02 20:01:55 +04:00
|
|
|
if (!mResolver && !mResolverNode) {
|
2005-11-02 10:40:54 +03:00
|
|
|
return NS_ERROR_DOM_NAMESPACE_ERR;
|
|
|
|
}
|
|
|
|
|
2005-11-02 10:37:50 +03:00
|
|
|
nsAutoString prefix;
|
|
|
|
if (aPrefix) {
|
|
|
|
aPrefix->ToString(prefix);
|
|
|
|
}
|
2005-11-02 10:40:54 +03:00
|
|
|
|
2005-11-02 10:41:16 +03:00
|
|
|
nsVoidableString ns;
|
2013-09-02 20:01:55 +04:00
|
|
|
if (mResolver) {
|
2014-10-14 18:27:24 +04:00
|
|
|
ErrorResult rv;
|
|
|
|
mResolver->LookupNamespaceURI(prefix, ns, rv);
|
|
|
|
if (rv.Failed()) {
|
2015-04-27 16:18:51 +03:00
|
|
|
return rv.StealNSResult();
|
2014-10-14 18:27:24 +04:00
|
|
|
}
|
2013-09-02 20:01:55 +04:00
|
|
|
} else {
|
2014-10-14 18:27:24 +04:00
|
|
|
if (aPrefix == nsGkAtoms::xml) {
|
|
|
|
ns.AssignLiteral("http://www.w3.org/XML/1998/namespace");
|
|
|
|
} else {
|
|
|
|
mResolverNode->LookupNamespaceURI(prefix, ns);
|
|
|
|
}
|
2013-09-02 20:01:55 +04:00
|
|
|
}
|
2005-11-02 10:37:50 +03:00
|
|
|
|
2005-11-02 10:41:16 +03:00
|
|
|
if (DOMStringIsNull(ns)) {
|
|
|
|
return NS_ERROR_DOM_NAMESPACE_ERR;
|
|
|
|
}
|
|
|
|
|
2005-11-02 10:37:50 +03:00
|
|
|
if (ns.IsEmpty()) {
|
2005-11-02 10:40:54 +03:00
|
|
|
aID = kNameSpaceID_None;
|
|
|
|
|
2005-11-02 10:37:50 +03:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the namespaceID for the URI
|
2005-11-02 20:34:14 +03:00
|
|
|
return nsContentUtils::NameSpaceManager()->RegisterNameSpace(ns, aID);
|
2005-11-02 10:37:50 +03:00
|
|
|
}
|
|
|
|
|
2005-11-02 10:41:11 +03:00
|
|
|
nsresult
|
2013-08-24 01:11:30 +04:00
|
|
|
XPathEvaluatorParseContext::resolveFunctionCall(nsIAtom* aName,
|
|
|
|
int32_t aID,
|
|
|
|
FunctionCall** aFn)
|
2005-11-02 10:37:50 +03:00
|
|
|
{
|
2013-07-04 19:29:29 +04:00
|
|
|
return NS_ERROR_XPATH_UNKNOWN_FUNCTION;
|
2005-11-02 10:37:50 +03:00
|
|
|
}
|
|
|
|
|
2013-08-24 01:11:30 +04:00
|
|
|
bool XPathEvaluatorParseContext::caseInsensitiveNameTests()
|
2005-11-02 10:39:52 +03:00
|
|
|
{
|
2005-11-02 10:40:13 +03:00
|
|
|
return !mIsCaseSensitive;
|
2005-11-02 10:39:52 +03:00
|
|
|
}
|
|
|
|
|
2005-11-02 10:41:11 +03:00
|
|
|
void
|
2013-08-24 01:11:30 +04:00
|
|
|
XPathEvaluatorParseContext::SetErrorOffset(uint32_t aOffset)
|
2005-11-02 10:37:50 +03:00
|
|
|
{
|
|
|
|
}
|
2013-08-24 01:11:30 +04:00
|
|
|
|
|
|
|
} // namespace dom
|
|
|
|
} // namespace mozilla
|