diff --git a/browser/components/sessionstore/SessionCookies.jsm b/browser/components/sessionstore/SessionCookies.jsm
index 49763ef6fd69..882ec45e66e1 100644
--- a/browser/components/sessionstore/SessionCookies.jsm
+++ b/browser/components/sessionstore/SessionCookies.jsm
@@ -28,8 +28,8 @@ this.SessionCookies = Object.freeze({
SessionCookiesInternal.update(windows);
},
- getHostsForWindow(window, checkPrivacy = false) {
- return SessionCookiesInternal.getHostsForWindow(window, checkPrivacy);
+ getHostsForWindow(window) {
+ return SessionCookiesInternal.getHostsForWindow(window);
},
restore(cookies) {
@@ -58,16 +58,20 @@ var SessionCookiesInternal = {
update(windows) {
this._ensureInitialized();
+ // Check whether we're allowed to store cookies.
+ let storeAnyCookies = PrivacyLevel.canSave(false);
+ let storeSecureCookies = PrivacyLevel.canSave(true);
+
for (let window of windows) {
let cookies = [];
- // Collect all cookies for the current window.
- for (let host of this.getHostsForWindow(window, true)) {
- for (let cookie of CookieStore.getCookiesForHost(host)) {
- // getCookiesForHost() will only return hosts with the right privacy
- // rules. Check again here to exclude HTTPS-only cookies if needed.
- if (PrivacyLevel.canSave(cookie.secure)) {
- cookies.push(cookie);
+ if (storeAnyCookies) {
+ // Collect all cookies for the current window.
+ for (let host of this.getHostsForWindow(window)) {
+ for (let cookie of CookieStore.getCookiesForHost(host)) {
+ if (!cookie.secure || storeSecureCookies) {
+ cookies.push(cookie);
+ }
}
}
}
@@ -87,16 +91,14 @@ var SessionCookiesInternal = {
*
* @param window
* A window state object containing tabs with history entries.
- * @param checkPrivacy (bool)
- * Whether to check the privacy level for each host.
* @return {set} A set of hosts for a given window state object.
*/
- getHostsForWindow(window, checkPrivacy = false) {
+ getHostsForWindow(window) {
let hosts = new Set();
for (let tab of window.tabs) {
for (let entry of tab.entries) {
- this._extractHostsFromEntry(entry, hosts, checkPrivacy);
+ this._extractHostsFromEntry(entry, hosts);
}
}
@@ -171,26 +173,19 @@ var SessionCookiesInternal = {
* the history entry, serialized
* @param hosts
* the set that will be used to store hosts
- * @param checkPrivacy
- * should we check the privacy level for https
*/
- _extractHostsFromEntry(entry, hosts, checkPrivacy) {
+ _extractHostsFromEntry(entry, hosts) {
try {
// It's alright if this throws for about: URIs.
let {host, scheme} = Utils.makeURI(entry.url);
-
- if (scheme == "file") {
+ if (/^(file|https?)$/.test(scheme)) {
hosts.add(host);
- } else if (/https?/.test(scheme)) {
- if (!checkPrivacy || PrivacyLevel.canSave(scheme == "https")) {
- hosts.add(host);
- }
}
} catch (ex) { }
if (entry.children) {
for (let child of entry.children) {
- this._extractHostsFromEntry(child, hosts, checkPrivacy);
+ this._extractHostsFromEntry(child, hosts);
}
}
},
diff --git a/browser/components/sessionstore/test/browser_cookies.js b/browser/components/sessionstore/test/browser_cookies.js
index be94d2046075..5e346642928c 100644
--- a/browser/components/sessionstore/test/browser_cookies.js
+++ b/browser/components/sessionstore/test/browser_cookies.js
@@ -6,7 +6,7 @@ const PATH = "/browser/browser/components/sessionstore/test/";
* Remove all cookies to start off a clean slate.
*/
add_task(function* test_setup() {
- requestLongerTimeout(2);
+ requestLongerTimeout(3);
Services.cookies.removeAll();
});
@@ -79,6 +79,104 @@ add_task(function* test_run() {
});
});
+/**
+ * Test multiple scenarios with different privacy levels.
+ */
+add_task(function* test_run_privacy_level() {
+ registerCleanupFunction(() => {
+ Services.prefs.clearUserPref("browser.sessionstore.privacy_level");
+ });
+
+ // With the default privacy level we collect all cookies.
+ yield testCookieCollection({
+ host: "http://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ cookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH],
+ noCookieURIs: ["about:robots"]
+ });
+
+ // With the default privacy level we collect all cookies.
+ yield testCookieCollection({
+ host: "https://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ cookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH],
+ noCookieURIs: ["about:robots"]
+ });
+
+ // With the default privacy level we collect all cookies.
+ yield testCookieCollection({
+ isSecure: true,
+ host: "https://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ cookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH],
+ noCookieURIs: ["about:robots"]
+ });
+
+ // Set level=encrypted, don't store any secure cookies.
+ Services.prefs.setIntPref("browser.sessionstore.privacy_level", 1);
+
+ // With level=encrypted, non-secure cookies will be stored.
+ yield testCookieCollection({
+ host: "http://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ cookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH],
+ noCookieURIs: ["about:robots"]
+ });
+
+ // With level=encrypted, non-secure cookies will be stored,
+ // even if sent by an HTTPS site.
+ yield testCookieCollection({
+ host: "https://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ cookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH],
+ noCookieURIs: ["about:robots"]
+ });
+
+ // With level=encrypted, secure cookies will NOT be stored.
+ yield testCookieCollection({
+ isSecure: true,
+ host: "https://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ noCookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH]
+ });
+
+ // Set level=full, don't store any cookies.
+ Services.prefs.setIntPref("browser.sessionstore.privacy_level", 2);
+
+ // With level=full we must not store any cookies.
+ yield testCookieCollection({
+ host: "http://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ noCookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH]
+ });
+
+ // With level=full we must not store any cookies.
+ yield testCookieCollection({
+ host: "https://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ noCookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH]
+ });
+
+ // With level=full we must not store any cookies.
+ yield testCookieCollection({
+ isSecure: true,
+ host: "https://example.com",
+ domain: ".example.com",
+ cookieHost: ".example.com",
+ noCookieURIs: ["https://example.com/" + PATH, "http://example.com/" + PATH]
+ });
+
+ Services.prefs.clearUserPref("browser.sessionstore.privacy_level");
+});
+
/**
* Generic test function to check sessionstore's cookie collection module with
* different cookie domains given in the Set-Cookie header. See above for some
@@ -96,6 +194,10 @@ var testCookieCollection = async function(params) {
urlParams.append("domain", params.domain);
}
+ if (params.isSecure) {
+ urlParams.append("secure", "1");
+ }
+
// Construct request URI.
let requestUri = `${params.host}${PATH}browser_cookies.sjs?${urlParams}`;
diff --git a/browser/components/sessionstore/test/browser_cookies.sjs b/browser/components/sessionstore/test/browser_cookies.sjs
index bffbd66d9797..67d20ccd8407 100644
--- a/browser/components/sessionstore/test/browser_cookies.sjs
+++ b/browser/components/sessionstore/test/browser_cookies.sjs
@@ -12,10 +12,15 @@ function handleRequest(req, resp) {
let value = params.get("value");
let domain = "";
- if (params.has("domain")) {
+ if (params.has("domain")) {
domain = `; Domain=${params.get("domain")}`;
}
- resp.setHeader("Set-Cookie", `foobar=${value}${domain}`);
+ let secure = "";
+ if (params.has("secure")) {
+ secure = "; Secure";
+ }
+
+ resp.setHeader("Set-Cookie", `foobar=${value}${domain}${secure}`);
resp.write("hi");
}
diff --git a/dom/media/webaudio/test/test_nodeCreationDocumentGone.html b/dom/media/webaudio/test/test_nodeCreationDocumentGone.html
index da164401b02d..b586569bbf0f 100644
--- a/dom/media/webaudio/test/test_nodeCreationDocumentGone.html
+++ b/dom/media/webaudio/test/test_nodeCreationDocumentGone.html
@@ -9,28 +9,36 @@
+
+
diff --git a/dom/xslt/crashtests/crashtests.list b/dom/xslt/crashtests/crashtests.list
index 5958655d6473..8e9a9e72dbdf 100644
--- a/dom/xslt/crashtests/crashtests.list
+++ b/dom/xslt/crashtests/crashtests.list
@@ -18,3 +18,4 @@ load 667315.xml
load 1089049.html
load 1205163.xml
load 1243337.xml
+load 1338277.html
diff --git a/dom/xslt/xpath/XPathExpression.cpp b/dom/xslt/xpath/XPathExpression.cpp
index 2f92a120fbac..88bbc1b84fe0 100644
--- a/dom/xslt/xpath/XPathExpression.cpp
+++ b/dom/xslt/xpath/XPathExpression.cpp
@@ -206,10 +206,12 @@ EvalContextImpl::getVariable(int32_t aNamespace,
return NS_ERROR_INVALID_ARG;
}
-bool
-EvalContextImpl::isStripSpaceAllowed(const txXPathNode& aNode)
+nsresult
+EvalContextImpl::isStripSpaceAllowed(const txXPathNode& aNode, bool& aAllowed)
{
- return false;
+ aAllowed = false;
+
+ return NS_OK;
}
void*
diff --git a/dom/xslt/xpath/txExpr.h b/dom/xslt/xpath/txExpr.h
index 562fca7a3293..4b0b8bcbc3a6 100644
--- a/dom/xslt/xpath/txExpr.h
+++ b/dom/xslt/xpath/txExpr.h
@@ -28,6 +28,7 @@ class txIMatchContext;
class txIEvalContext;
class txNodeSet;
class txXPathNode;
+class txXPathTreeWalker;
/**
* A Base Class for all XSL Expressions
@@ -394,8 +395,9 @@ public:
* standalone. The NodeTest node() is different to the
* Pattern "node()" (document node isn't matched)
*/
- virtual bool matches(const txXPathNode& aNode,
- txIMatchContext* aContext) = 0;
+ virtual nsresult matches(const txXPathNode& aNode,
+ txIMatchContext* aContext,
+ bool& aMatched) = 0;
virtual double getDefaultPriority() = 0;
/**
@@ -424,7 +426,9 @@ public:
#define TX_DECL_NODE_TEST \
TX_DECL_TOSTRING \
- bool matches(const txXPathNode& aNode, txIMatchContext* aContext) override; \
+ nsresult matches(const txXPathNode& aNode, \
+ txIMatchContext* aContext, \
+ bool& aMatched) override; \
double getDefaultPriority() override; \
bool isSensitiveTo(Expr::ContextSensitivity aContext) override;
@@ -630,10 +634,30 @@ public:
}
private:
- void fromDescendants(const txXPathNode& aNode, txIMatchContext* aCs,
- txNodeSet* aNodes);
- void fromDescendantsRev(const txXPathNode& aNode, txIMatchContext* aCs,
- txNodeSet* aNodes);
+ /**
+ * Append the current position of aWalker to aNodes if it matches mNodeTest,
+ * using aContext as the context for matching.
+ */
+ nsresult appendIfMatching(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes);
+
+ /**
+ * Append the descendants of the current position of aWalker to aNodes if
+ * they match mNodeTest, using aContext as the context for matching.
+ */
+ nsresult appendMatchingDescendants(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes);
+
+ /**
+ * Append the descendants of the current position of aWalker to aNodes in
+ * reverse order if they match mNodeTest, using aContext as the context for
+ * matching.
+ */
+ nsresult appendMatchingDescendantsRev(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes);
nsAutoPtr mNodeTest;
LocationStepType mAxisIdentifier;
diff --git a/dom/xslt/xpath/txForwardContext.cpp b/dom/xslt/xpath/txForwardContext.cpp
index e2367a3aeb71..73bd6a626938 100644
--- a/dom/xslt/xpath/txForwardContext.cpp
+++ b/dom/xslt/xpath/txForwardContext.cpp
@@ -30,10 +30,11 @@ nsresult txForwardContext::getVariable(int32_t aNamespace, nsIAtom* aLName,
return mInner->getVariable(aNamespace, aLName, aResult);
}
-bool txForwardContext::isStripSpaceAllowed(const txXPathNode& aNode)
+nsresult
+txForwardContext::isStripSpaceAllowed(const txXPathNode& aNode, bool& aAllowed)
{
NS_ASSERTION(mInner, "mInner is null!!!");
- return mInner->isStripSpaceAllowed(aNode);
+ return mInner->isStripSpaceAllowed(aNode, aAllowed);
}
void* txForwardContext::getPrivateContext()
diff --git a/dom/xslt/xpath/txIXPathContext.h b/dom/xslt/xpath/txIXPathContext.h
index ed5f81a53265..66b1905d363c 100644
--- a/dom/xslt/xpath/txIXPathContext.h
+++ b/dom/xslt/xpath/txIXPathContext.h
@@ -88,7 +88,8 @@ public:
* Is whitespace stripping allowed for the given node?
* See http://www.w3.org/TR/xslt#strip
*/
- virtual bool isStripSpaceAllowed(const txXPathNode& aNode) = 0;
+ virtual nsresult isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) = 0;
/**
* Returns a pointer to the private context
@@ -106,7 +107,7 @@ public:
#define TX_DECL_MATCH_CONTEXT \
nsresult getVariable(int32_t aNamespace, nsIAtom* aLName, \
txAExprResult*& aResult); \
- bool isStripSpaceAllowed(const txXPathNode& aNode); \
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode, bool& aAllowed); \
void* getPrivateContext(); \
txResultRecycler* recycler(); \
void receiveError(const nsAString& aMsg, nsresult aRes)
diff --git a/dom/xslt/xpath/txLocationStep.cpp b/dom/xslt/xpath/txLocationStep.cpp
index f945b750fe44..6351359290aa 100644
--- a/dom/xslt/xpath/txLocationStep.cpp
+++ b/dom/xslt/xpath/txLocationStep.cpp
@@ -49,9 +49,8 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
nodes->setReverse();
do {
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
} while (walker.moveToParent());
break;
@@ -63,29 +62,29 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
}
do {
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
} while (walker.moveToNextAttribute());
break;
}
case DESCENDANT_OR_SELF_AXIS:
{
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
MOZ_FALLTHROUGH;
}
case DESCENDANT_AXIS:
{
- fromDescendants(walker.getCurrentPosition(), aContext, nodes);
+ rv = appendMatchingDescendants(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
break;
}
case FOLLOWING_AXIS:
{
if (txXPathNodeUtils::isAttribute(walker.getCurrentPosition())) {
walker.moveToParent();
- fromDescendants(walker.getCurrentPosition(), aContext, nodes);
+ rv = appendMatchingDescendants(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
}
bool cont = true;
while (!walker.moveToNextSibling()) {
@@ -95,11 +94,11 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
}
}
while (cont) {
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
- fromDescendants(walker.getCurrentPosition(), aContext, nodes);
+ rv = appendMatchingDescendants(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
while (!walker.moveToNextSibling()) {
if (!walker.moveToParent()) {
@@ -113,9 +112,8 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
case FOLLOWING_SIBLING_AXIS:
{
while (walker.moveToNextSibling()) {
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
}
break;
}
@@ -127,9 +125,9 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
break;
case PARENT_AXIS :
{
- if (walker.moveToParent() &&
- mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
+ if (walker.moveToParent()) {
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
}
break;
}
@@ -145,11 +143,11 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
}
}
while (cont) {
- fromDescendantsRev(walker.getCurrentPosition(), aContext, nodes);
+ rv = appendMatchingDescendantsRev(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
while (!walker.moveToPreviousSibling()) {
if (!walker.moveToParent()) {
@@ -165,17 +163,15 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
nodes->setReverse();
while (walker.moveToPreviousSibling()) {
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
}
break;
}
case SELF_AXIS:
{
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
break;
}
default: // Children Axis
@@ -185,9 +181,8 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
}
do {
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
- nodes->append(walker.getCurrentPosition());
- }
+ rv = appendIfMatching(walker, aContext, nodes);
+ NS_ENSURE_SUCCESS(rv, rv);
} while (walker.moveToNextSibling());
break;
}
@@ -206,42 +201,62 @@ LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
return NS_OK;
}
-void LocationStep::fromDescendants(const txXPathNode& aNode,
- txIMatchContext* aCs,
- txNodeSet* aNodes)
+nsresult
+LocationStep::appendIfMatching(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes)
{
- txXPathTreeWalker walker(aNode);
- if (!walker.moveToFirstChild()) {
- return;
- }
+ bool matched;
+ const txXPathNode& child = aWalker.getCurrentPosition();
+ nsresult rv = mNodeTest->matches(child, aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
- do {
- const txXPathNode& child = walker.getCurrentPosition();
- if (mNodeTest->matches(child, aCs)) {
- aNodes->append(child);
- }
- fromDescendants(child, aCs, aNodes);
- } while (walker.moveToNextSibling());
+ if (matched) {
+ aNodes->append(child);
+ }
+ return NS_OK;
}
-void LocationStep::fromDescendantsRev(const txXPathNode& aNode,
- txIMatchContext* aCs,
- txNodeSet* aNodes)
+nsresult
+LocationStep::appendMatchingDescendants(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes)
{
- txXPathTreeWalker walker(aNode);
- if (!walker.moveToLastChild()) {
- return;
+ txXPathTreeWalker walker(aWalker);
+ if (!walker.moveToFirstChild()) {
+ return NS_OK;
}
do {
- const txXPathNode& child = walker.getCurrentPosition();
- fromDescendantsRev(child, aCs, aNodes);
+ nsresult rv = appendIfMatching(walker, aContext, aNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
- if (mNodeTest->matches(child, aCs)) {
- aNodes->append(child);
- }
+ rv = appendMatchingDescendants(walker, aContext, aNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } while (walker.moveToNextSibling());
+ return NS_OK;
+}
+
+nsresult
+LocationStep::appendMatchingDescendantsRev(const txXPathTreeWalker& aWalker,
+ txIMatchContext* aContext,
+ txNodeSet* aNodes)
+{
+ txXPathTreeWalker walker(aWalker);
+ if (!walker.moveToLastChild()) {
+ return NS_OK;
+ }
+
+ do {
+ nsresult rv = appendMatchingDescendantsRev(walker, aContext, aNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = appendIfMatching(walker, aContext, aNodes);
+ NS_ENSURE_SUCCESS(rv, rv);
} while (walker.moveToPreviousSibling());
+
+ return NS_OK;
}
Expr::ExprType
diff --git a/dom/xslt/xpath/txNameTest.cpp b/dom/xslt/xpath/txNameTest.cpp
index bad0432825ea..d2bb87c72716 100644
--- a/dom/xslt/xpath/txNameTest.cpp
+++ b/dom/xslt/xpath/txNameTest.cpp
@@ -23,7 +23,9 @@ txNameTest::txNameTest(nsIAtom* aPrefix, nsIAtom* aLocalName, int32_t aNSID,
"Go fix txNameTest::matches");
}
-bool txNameTest::matches(const txXPathNode& aNode, txIMatchContext* aContext)
+nsresult
+txNameTest::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
if ((mNodeType == txXPathNodeType::ELEMENT_NODE &&
!txXPathNodeUtils::isElement(aNode)) ||
@@ -31,26 +33,34 @@ bool txNameTest::matches(const txXPathNode& aNode, txIMatchContext* aContext)
!txXPathNodeUtils::isAttribute(aNode)) ||
(mNodeType == txXPathNodeType::DOCUMENT_NODE &&
!txXPathNodeUtils::isRoot(aNode))) {
- return false;
+ aMatched = false;
+ return NS_OK;
}
// Totally wild?
- if (mLocalName == nsGkAtoms::_asterisk && !mPrefix)
- return true;
+ if (mLocalName == nsGkAtoms::_asterisk && !mPrefix) {
+ aMatched = true;
+ return NS_OK;
+ }
// Compare namespaces
if (mNamespace != txXPathNodeUtils::getNamespaceID(aNode)
&& !(mNamespace == kNameSpaceID_None &&
txXPathNodeUtils::isHTMLElementInHTMLDocument(aNode))
- )
- return false;
+ ) {
+ aMatched = false;
+ return NS_OK;
+ }
// Name wild?
- if (mLocalName == nsGkAtoms::_asterisk)
- return true;
+ if (mLocalName == nsGkAtoms::_asterisk) {
+ aMatched = true;
+ return NS_OK;
+ }
// Compare local-names
- return txXPathNodeUtils::localNameEquals(aNode, mLocalName);
+ aMatched = txXPathNodeUtils::localNameEquals(aNode, mLocalName);
+ return NS_OK;
}
/*
diff --git a/dom/xslt/xpath/txNodeSetContext.cpp b/dom/xslt/xpath/txNodeSetContext.cpp
index 7d98391fdea0..578e1d82f13c 100644
--- a/dom/xslt/xpath/txNodeSetContext.cpp
+++ b/dom/xslt/xpath/txNodeSetContext.cpp
@@ -29,10 +29,11 @@ nsresult txNodeSetContext::getVariable(int32_t aNamespace, nsIAtom* aLName,
return mInner->getVariable(aNamespace, aLName, aResult);
}
-bool txNodeSetContext::isStripSpaceAllowed(const txXPathNode& aNode)
+nsresult
+txNodeSetContext::isStripSpaceAllowed(const txXPathNode& aNode, bool& aAllowed)
{
NS_ASSERTION(mInner, "mInner is null!!!");
- return mInner->isStripSpaceAllowed(aNode);
+ return mInner->isStripSpaceAllowed(aNode, aAllowed);
}
void* txNodeSetContext::getPrivateContext()
diff --git a/dom/xslt/xpath/txNodeTypeTest.cpp b/dom/xslt/xpath/txNodeTypeTest.cpp
index 650a1ae5fefc..4c519d38276c 100644
--- a/dom/xslt/xpath/txNodeTypeTest.cpp
+++ b/dom/xslt/xpath/txNodeTypeTest.cpp
@@ -8,32 +8,54 @@
#include "txIXPathContext.h"
#include "txXPathTreeWalker.h"
-bool txNodeTypeTest::matches(const txXPathNode& aNode,
- txIMatchContext* aContext)
+nsresult
+txNodeTypeTest::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
switch (mNodeType) {
case COMMENT_TYPE:
{
- return txXPathNodeUtils::isComment(aNode);
+ aMatched = txXPathNodeUtils::isComment(aNode);
+ return NS_OK;
}
case TEXT_TYPE:
{
- return txXPathNodeUtils::isText(aNode) &&
- !aContext->isStripSpaceAllowed(aNode);
+ aMatched = txXPathNodeUtils::isText(aNode);
+ if (aMatched) {
+ bool allowed;
+ nsresult rv = aContext->isStripSpaceAllowed(aNode, allowed);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aMatched = !allowed;
+ }
+ return NS_OK;
}
case PI_TYPE:
{
- return txXPathNodeUtils::isProcessingInstruction(aNode) &&
- (!mNodeName ||
- txXPathNodeUtils::localNameEquals(aNode, mNodeName));
+ aMatched = txXPathNodeUtils::isProcessingInstruction(aNode) &&
+ (!mNodeName ||
+ txXPathNodeUtils::localNameEquals(aNode, mNodeName));
+ return NS_OK;
}
case NODE_TYPE:
{
- return !txXPathNodeUtils::isText(aNode) ||
- !aContext->isStripSpaceAllowed(aNode);
+ if (txXPathNodeUtils::isText(aNode)) {
+ bool allowed;
+ nsresult rv = aContext->isStripSpaceAllowed(aNode, allowed);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aMatched = !allowed;
+ } else {
+ aMatched = true;
+ }
+ return NS_OK;
}
}
- return true;
+
+ NS_NOTREACHED("Didn't deal with all values of the NodeType enum!");
+
+ aMatched = false;
+ return NS_OK;
}
txNodeTest::NodeTestType
diff --git a/dom/xslt/xpath/txPathExpr.cpp b/dom/xslt/xpath/txPathExpr.cpp
index bcff47e9f788..d36d615fc71c 100644
--- a/dom/xslt/xpath/txPathExpr.cpp
+++ b/dom/xslt/xpath/txPathExpr.cpp
@@ -160,7 +160,9 @@ PathExpr::evalDescendants(Expr* aStep, const txXPathNode& aNode,
resNodes->addAndTransfer(newSet);
- bool filterWS = aContext->isStripSpaceAllowed(aNode);
+ bool filterWS;
+ rv = aContext->isStripSpaceAllowed(aNode, filterWS);
+ NS_ENSURE_SUCCESS(rv, rv);
txXPathTreeWalker walker(aNode);
if (!walker.moveToFirstChild()) {
diff --git a/dom/xslt/xpath/txPredicatedNodeTest.cpp b/dom/xslt/xpath/txPredicatedNodeTest.cpp
index 4726f48f280b..598f05f78299 100644
--- a/dom/xslt/xpath/txPredicatedNodeTest.cpp
+++ b/dom/xslt/xpath/txPredicatedNodeTest.cpp
@@ -16,20 +16,25 @@ txPredicatedNodeTest::txPredicatedNodeTest(txNodeTest* aNodeTest,
"predicate must not be context-nodeset-sensitive");
}
-bool
+nsresult
txPredicatedNodeTest::matches(const txXPathNode& aNode,
- txIMatchContext* aContext)
+ txIMatchContext* aContext,
+ bool& aMatched)
{
- if (!mNodeTest->matches(aNode, aContext)) {
- return false;
+ nsresult rv = mNodeTest->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!aMatched) {
+ return NS_OK;
}
txSingleNodeContext context(aNode, aContext);
RefPtr res;
- nsresult rv = mPredicate->evaluate(&context, getter_AddRefs(res));
- NS_ENSURE_SUCCESS(rv, false);
+ rv = mPredicate->evaluate(&context, getter_AddRefs(res));
+ NS_ENSURE_SUCCESS(rv, rv);
- return res->booleanValue();
+ aMatched = res->booleanValue();
+ return NS_OK;
}
double
diff --git a/dom/xslt/xpath/txSingleNodeContext.h b/dom/xslt/xpath/txSingleNodeContext.h
index e66083d80ac2..dd470294c645 100644
--- a/dom/xslt/xpath/txSingleNodeContext.h
+++ b/dom/xslt/xpath/txSingleNodeContext.h
@@ -27,10 +27,11 @@ public:
return mInner->getVariable(aNamespace, aLName, aResult);
}
- bool isStripSpaceAllowed(const txXPathNode& aNode) override
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode,
+ bool& aAllowed) override
{
NS_ASSERTION(mInner, "mInner is null!!!");
- return mInner->isStripSpaceAllowed(aNode);
+ return mInner->isStripSpaceAllowed(aNode, aAllowed);
}
void* getPrivateContext() override
diff --git a/dom/xslt/xpath/txUnionNodeTest.cpp b/dom/xslt/xpath/txUnionNodeTest.cpp
index 421ea680c0a4..b8ac34f87d4f 100644
--- a/dom/xslt/xpath/txUnionNodeTest.cpp
+++ b/dom/xslt/xpath/txUnionNodeTest.cpp
@@ -10,18 +10,22 @@
#include "txExprResult.h"
#include "txSingleNodeContext.h"
-bool
-txUnionNodeTest::matches(const txXPathNode& aNode,
- txIMatchContext* aContext)
+nsresult
+txUnionNodeTest::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
uint32_t i, len = mNodeTests.Length();
for (i = 0; i < len; ++i) {
- if (mNodeTests[i]->matches(aNode, aContext)) {
- return true;
+ nsresult rv = mNodeTests[i]->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (aMatched) {
+ return NS_OK;
}
}
- return false;
+ aMatched = false;
+ return NS_OK;
}
double
diff --git a/dom/xslt/xpath/txXPathOptimizer.cpp b/dom/xslt/xpath/txXPathOptimizer.cpp
index 756dd253d7f4..070302692b24 100644
--- a/dom/xslt/xpath/txXPathOptimizer.cpp
+++ b/dom/xslt/xpath/txXPathOptimizer.cpp
@@ -26,7 +26,7 @@ public:
{
MOZ_CRASH("shouldn't depend on this context");
}
- bool isStripSpaceAllowed(const txXPathNode& aNode)
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode, bool& aAllowed)
{
MOZ_CRASH("shouldn't depend on this context");
}
diff --git a/dom/xslt/xslt/txExecutionState.cpp b/dom/xslt/xslt/txExecutionState.cpp
index a32fdb0b8065..de439f78953b 100644
--- a/dom/xslt/xslt/txExecutionState.cpp
+++ b/dom/xslt/xslt/txExecutionState.cpp
@@ -87,10 +87,7 @@ txExecutionState::~txExecutionState()
txStackIterator handlerIter(&mResultHandlerStack);
while (handlerIter.hasNext()) {
- txAXMLEventHandler* handler = (txAXMLEventHandler*)handlerIter.next();
- if (handler != mObsoleteHandler) {
- delete handler;
- }
+ delete (txAXMLEventHandler*)handlerIter.next();
}
txStackIterator paramIter(&mParamStack);
@@ -141,8 +138,11 @@ txExecutionState::init(const txXPathNode& aNode,
// might use us.
txStylesheet::ImportFrame* frame = 0;
txExpandedName nullName;
- txInstruction* templ = mStylesheet->findTemplate(aNode, nullName,
- this, nullptr, &frame);
+ txInstruction* templ;
+ rv = mStylesheet->findTemplate(aNode, nullName, this, nullptr, &templ,
+ &frame);
+ NS_ENSURE_SUCCESS(rv, rv);
+
pushTemplateRule(frame, nullName, nullptr);
return runTemplate(templ);
@@ -162,17 +162,6 @@ txExecutionState::end(nsresult aResult)
return mOutputHandler->endDocument(aResult);
}
-void
-txExecutionState::popAndDeleteEvalContext()
-{
- if (!mEvalContextStack.isEmpty()) {
- auto ctx = popEvalContext();
- if (ctx != mInitialEvalContext) {
- delete ctx;
- }
- }
-}
-
void
txExecutionState::popAndDeleteEvalContextUntil(txIEvalContext* aContext)
{
@@ -306,10 +295,10 @@ txExecutionState::getVariable(int32_t aNamespace, nsIAtom* aLName,
return NS_OK;
}
-bool
-txExecutionState::isStripSpaceAllowed(const txXPathNode& aNode)
+nsresult
+txExecutionState::isStripSpaceAllowed(const txXPathNode& aNode, bool& aAllowed)
{
- return mStylesheet->isStripSpaceAllowed(aNode, this);
+ return mStylesheet->isStripSpaceAllowed(aNode, this, aAllowed);
}
void*
diff --git a/dom/xslt/xslt/txExecutionState.h b/dom/xslt/xslt/txExecutionState.h
index 3aa6d5a660bf..44f1918c86b0 100644
--- a/dom/xslt/xslt/txExecutionState.h
+++ b/dom/xslt/xslt/txExecutionState.h
@@ -95,8 +95,6 @@ public:
nsresult pushEvalContext(txIEvalContext* aContext);
txIEvalContext* popEvalContext();
- void popAndDeleteEvalContext();
-
/**
* Helper that deletes all entries before |aContext| and then
* pops it off the stack. The caller must delete |aContext| if
diff --git a/dom/xslt/xslt/txInstructions.cpp b/dom/xslt/xslt/txInstructions.cpp
index f769680474f3..e891b2f3b0bb 100644
--- a/dom/xslt/xslt/txInstructions.cpp
+++ b/dom/xslt/xslt/txInstructions.cpp
@@ -27,9 +27,11 @@ txApplyDefaultElementTemplate::execute(txExecutionState& aEs)
txExecutionState::TemplateRule* rule = aEs.getCurrentTemplateRule();
txExpandedName mode(rule->mModeNsId, rule->mModeLocalName);
txStylesheet::ImportFrame* frame = 0;
- txInstruction* templ =
+ txInstruction* templ;
+ nsresult rv =
aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
- mode, &aEs, nullptr, &frame);
+ mode, &aEs, nullptr, &templ, &frame);
+ NS_ENSURE_SUCCESS(rv, rv);
aEs.pushTemplateRule(frame, mode, aEs.mTemplateParams);
@@ -53,9 +55,11 @@ txApplyImports::execute(txExecutionState& aEs)
txStylesheet::ImportFrame* frame = 0;
txExpandedName mode(rule->mModeNsId, rule->mModeLocalName);
- txInstruction* templ =
- aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
- mode, &aEs, rule->mFrame, &frame);
+ txInstruction* templ;
+ rv = aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
+ mode, &aEs, rule->mFrame, &templ,
+ &frame);
+ NS_ENSURE_SUCCESS(rv, rv);
aEs.pushTemplateRule(frame, mode, rule->mParams);
@@ -76,9 +80,11 @@ nsresult
txApplyTemplates::execute(txExecutionState& aEs)
{
txStylesheet::ImportFrame* frame = 0;
- txInstruction* templ =
+ txInstruction* templ;
+ nsresult rv =
aEs.mStylesheet->findTemplate(aEs.getEvalContext()->getContextNode(),
- mMode, &aEs, nullptr, &frame);
+ mMode, &aEs, nullptr, &templ, &frame);
+ NS_ENSURE_SUCCESS(rv, rv);
aEs.pushTemplateRule(frame, mMode, aEs.mTemplateParams);
@@ -470,7 +476,7 @@ txLoopNodeSet::execute(txExecutionState& aEs)
txNodeSetContext* context =
static_cast(aEs.getEvalContext());
if (!context->hasNext()) {
- aEs.popAndDeleteEvalContext();
+ delete aEs.popEvalContext();
return NS_OK;
}
diff --git a/dom/xslt/xslt/txKeyFunctionCall.cpp b/dom/xslt/xslt/txKeyFunctionCall.cpp
index ae76275ffddf..d10229f24694 100644
--- a/dom/xslt/xslt/txKeyFunctionCall.cpp
+++ b/dom/xslt/xslt/txKeyFunctionCall.cpp
@@ -338,7 +338,11 @@ nsresult txXSLKey::testNode(const txXPathNode& aNode,
nsAutoString val;
uint32_t currKey, numKeys = mKeys.Length();
for (currKey = 0; currKey < numKeys; ++currKey) {
- if (mKeys[currKey].matchPattern->matches(aNode, &aEs)) {
+ bool matched;
+ nsresult rv = mKeys[currKey].matchPattern->matches(aNode, &aEs, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
txSingleNodeContext *evalContext =
new txSingleNodeContext(aNode, &aEs);
NS_ENSURE_TRUE(evalContext, NS_ERROR_OUT_OF_MEMORY);
diff --git a/dom/xslt/xslt/txMozillaXSLTProcessor.cpp b/dom/xslt/xslt/txMozillaXSLTProcessor.cpp
index 35c4b08b3d0b..9424d1110593 100644
--- a/dom/xslt/xslt/txMozillaXSLTProcessor.cpp
+++ b/dom/xslt/xslt/txMozillaXSLTProcessor.cpp
@@ -441,9 +441,11 @@ public:
aResult = nullptr;
return NS_ERROR_INVALID_ARG;
}
- bool isStripSpaceAllowed(const txXPathNode& aNode)
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode, bool& aAllowed)
{
- return false;
+ aAllowed = false;
+
+ return NS_OK;
}
void* getPrivateContext()
{
diff --git a/dom/xslt/xslt/txStylesheet.cpp b/dom/xslt/xslt/txStylesheet.cpp
index b680da01f94a..37052c00f5fc 100644
--- a/dom/xslt/xslt/txStylesheet.cpp
+++ b/dom/xslt/xslt/txStylesheet.cpp
@@ -88,17 +88,18 @@ txStylesheet::~txStylesheet()
}
}
-txInstruction*
+nsresult
txStylesheet::findTemplate(const txXPathNode& aNode,
const txExpandedName& aMode,
txIMatchContext* aContext,
ImportFrame* aImportedBy,
+ txInstruction** aTemplate,
ImportFrame** aImportFrame)
{
NS_ASSERTION(aImportFrame, "missing ImportFrame pointer");
+ *aTemplate = nullptr;
*aImportFrame = nullptr;
- txInstruction* matchTemplate = nullptr;
ImportFrame* endFrame = nullptr;
txListIterator frameIter(&mImportFrames);
@@ -115,7 +116,7 @@ txStylesheet::findTemplate(const txXPathNode& aNode,
#endif
ImportFrame* frame;
- while (!matchTemplate &&
+ while (!*aTemplate &&
(frame = static_cast(frameIter.next())) &&
frame != endFrame) {
@@ -126,10 +127,14 @@ txStylesheet::findTemplate(const txXPathNode& aNode,
if (templates) {
// Find template with highest priority
uint32_t i, len = templates->Length();
- for (i = 0; i < len && !matchTemplate; ++i) {
+ for (i = 0; i < len && !*aTemplate; ++i) {
MatchableTemplate& templ = (*templates)[i];
- if (templ.mMatch->matches(aNode, aContext)) {
- matchTemplate = templ.mFirstInstruction;
+ bool matched;
+ nsresult rv = templ.mMatch->matches(aNode, aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ *aTemplate = templ.mFirstInstruction;
*aImportFrame = frame;
#if defined(TX_TO_STRING)
match = templ.mMatch;
@@ -145,7 +150,7 @@ txStylesheet::findTemplate(const txXPathNode& aNode,
aMode.mLocalName->ToString(mode);
}
txXPathNodeUtils::getNodeName(aNode, nodeName);
- if (matchTemplate) {
+ if (*aTemplate) {
nsAutoString matchAttr;
#ifdef TX_TO_STRING
match->toString(matchAttr);
@@ -164,23 +169,23 @@ txStylesheet::findTemplate(const txXPathNode& aNode,
}
}
- if (!matchTemplate) {
+ if (!*aTemplate) {
// Test for these first since a node can be both a text node
// and a root (if it is orphaned)
if (txXPathNodeUtils::isAttribute(aNode) ||
txXPathNodeUtils::isText(aNode)) {
- matchTemplate = mCharactersTemplate;
+ *aTemplate = mCharactersTemplate;
}
else if (txXPathNodeUtils::isElement(aNode) ||
txXPathNodeUtils::isRoot(aNode)) {
- matchTemplate = mContainerTemplate;
+ *aTemplate = mContainerTemplate;
}
else {
- matchTemplate = mEmptyTemplate;
+ *aTemplate = mEmptyTemplate;
}
}
- return matchTemplate;
+ return NS_OK;
}
txDecimalFormat*
@@ -219,37 +224,53 @@ txStylesheet::getKeyMap()
return mKeys;
}
-bool
-txStylesheet::isStripSpaceAllowed(const txXPathNode& aNode, txIMatchContext* aContext)
+nsresult
+txStylesheet::isStripSpaceAllowed(const txXPathNode& aNode,
+ txIMatchContext* aContext, bool& aAllowed)
{
int32_t frameCount = mStripSpaceTests.Length();
if (frameCount == 0) {
- return false;
+ aAllowed = false;
+
+ return NS_OK;
}
txXPathTreeWalker walker(aNode);
if (txXPathNodeUtils::isText(walker.getCurrentPosition()) &&
(!txXPathNodeUtils::isWhitespace(aNode) || !walker.moveToParent())) {
- return false;
+ aAllowed = false;
+
+ return NS_OK;
}
const txXPathNode& node = walker.getCurrentPosition();
if (!txXPathNodeUtils::isElement(node)) {
- return false;
+ aAllowed = false;
+
+ return NS_OK;
}
// check Whitespace stipping handling list against given Node
int32_t i;
for (i = 0; i < frameCount; ++i) {
txStripSpaceTest* sst = mStripSpaceTests[i];
- if (sst->matches(node, aContext)) {
- return sst->stripsSpace() && !XMLUtils::getXMLSpacePreserve(node);
+ bool matched;
+ nsresult rv = sst->matches(node, aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ aAllowed = sst->stripsSpace() &&
+ !XMLUtils::getXMLSpacePreserve(node);
+
+ return NS_OK;
}
}
- return false;
+ aAllowed = false;
+
+ return NS_OK;
}
nsresult
diff --git a/dom/xslt/xslt/txStylesheet.h b/dom/xslt/xslt/txStylesheet.h
index 978527a13e4d..370f4d6fa78f 100644
--- a/dom/xslt/xslt/txStylesheet.h
+++ b/dom/xslt/xslt/txStylesheet.h
@@ -35,19 +35,21 @@ public:
NS_INLINE_DECL_REFCOUNTING(txStylesheet)
- txInstruction* findTemplate(const txXPathNode& aNode,
- const txExpandedName& aMode,
- txIMatchContext* aContext,
- ImportFrame* aImportedBy,
- ImportFrame** aImportFrame);
+ nsresult findTemplate(const txXPathNode& aNode,
+ const txExpandedName& aMode,
+ txIMatchContext* aContext,
+ ImportFrame* aImportedBy,
+ txInstruction** aTemplate,
+ ImportFrame** aImportFrame);
txDecimalFormat* getDecimalFormat(const txExpandedName& aName);
txInstruction* getAttributeSet(const txExpandedName& aName);
txInstruction* getNamedTemplate(const txExpandedName& aName);
txOutputFormat* getOutputFormat();
GlobalVariable* getGlobalVariable(const txExpandedName& aName);
const txOwningExpandedNameMap& getKeyMap();
- bool isStripSpaceAllowed(const txXPathNode& aNode,
- txIMatchContext* aContext);
+ nsresult isStripSpaceAllowed(const txXPathNode& aNode,
+ txIMatchContext* aContext,
+ bool& aAllowed);
/**
* Called by the stylesheet compiler once all stylesheets has been read.
@@ -166,8 +168,10 @@ public:
{
}
- bool matches(const txXPathNode& aNode, txIMatchContext* aContext) {
- return mNameTest.matches(aNode, aContext);
+ nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
+ {
+ return mNameTest.matches(aNode, aContext, aMatched);
}
bool stripsSpace() {
diff --git a/dom/xslt/xslt/txXSLTNumber.cpp b/dom/xslt/xslt/txXSLTNumber.cpp
index 237a46ec539d..96e21dfe01d1 100644
--- a/dom/xslt/xslt/txXSLTNumber.cpp
+++ b/dom/xslt/xslt/txXSLTNumber.cpp
@@ -108,13 +108,12 @@ txXSLTNumber::getValueList(Expr* aValueExpr, txPattern* aCountPattern,
// Otherwise use count/from/level
txPattern* countPattern = aCountPattern;
- bool ownsCountPattern = false;
+ nsAutoPtr newCountPattern;
const txXPathNode& currNode = aContext->getContextNode();
// Parse count- and from-attributes
if (!aCountPattern) {
- ownsCountPattern = true;
txNodeTest* nodeTest;
uint16_t nodeType = txXPathNodeUtils::getNodeType(currNode);
switch (nodeType) {
@@ -160,7 +159,7 @@ txXSLTNumber::getValueList(Expr* aValueExpr, txPattern* aCountPattern,
}
}
MOZ_ASSERT(nodeTest);
- countPattern = new txStepPattern(nodeTest, false);
+ countPattern = newCountPattern = new txStepPattern(nodeTest, false);
}
@@ -170,14 +169,28 @@ txXSLTNumber::getValueList(Expr* aValueExpr, txPattern* aCountPattern,
if (aLevel == eLevelSingle) {
txXPathTreeWalker walker(currNode);
do {
- if (aFromPattern && !walker.isOnNode(currNode) &&
- aFromPattern->matches(walker.getCurrentPosition(), aContext)) {
- break;
+ if (aFromPattern && !walker.isOnNode(currNode)) {
+ bool matched;
+ rv = aFromPattern->matches(walker.getCurrentPosition(),
+ aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ break;
+ }
}
- if (countPattern->matches(walker.getCurrentPosition(), aContext)) {
- aValues.add(NS_INT32_TO_PTR(getSiblingCount(walker, countPattern,
- aContext)));
+ bool matched;
+ rv = countPattern->matches(walker.getCurrentPosition(), aContext,
+ matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ int32_t count;
+ rv = getSiblingCount(walker, countPattern, aContext, &count);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aValues.add(NS_INT32_TO_PTR(count));
break;
}
@@ -189,7 +202,12 @@ txXSLTNumber::getValueList(Expr* aValueExpr, txPattern* aCountPattern,
if (aFromPattern && aValues.getLength()) {
bool hasParent;
while ((hasParent = walker.moveToParent())) {
- if (aFromPattern->matches(walker.getCurrentPosition(), aContext)) {
+ bool matched;
+ rv = aFromPattern->matches(walker.getCurrentPosition(),
+ aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
break;
}
}
@@ -205,16 +223,28 @@ txXSLTNumber::getValueList(Expr* aValueExpr, txPattern* aCountPattern,
txXPathTreeWalker walker(currNode);
bool matchedFrom = false;
do {
- if (aFromPattern && !walker.isOnNode(currNode) &&
- aFromPattern->matches(walker.getCurrentPosition(), aContext)) {
- //... we find one that matches from
- matchedFrom = true;
- break;
+ if (aFromPattern && !walker.isOnNode(currNode)) {
+ rv = aFromPattern->matches(walker.getCurrentPosition(),
+ aContext, matchedFrom);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matchedFrom) {
+ //... we find one that matches from
+ break;
+ }
}
- if (countPattern->matches(walker.getCurrentPosition(), aContext)) {
- aValues.add(NS_INT32_TO_PTR(getSiblingCount(walker, countPattern,
- aContext)));
+ bool matched;
+ rv = countPattern->matches(walker.getCurrentPosition(), aContext,
+ matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
+ int32_t count;
+ rv = getSiblingCount(walker, countPattern, aContext, &count);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aValues.add(NS_INT32_TO_PTR(count));
}
} while (walker.moveToParent());
@@ -232,13 +262,22 @@ txXSLTNumber::getValueList(Expr* aValueExpr, txPattern* aCountPattern,
txXPathTreeWalker walker(currNode);
do {
- if (aFromPattern && !walker.isOnNode(currNode) &&
- aFromPattern->matches(walker.getCurrentPosition(), aContext)) {
- matchedFrom = true;
- break;
+ if (aFromPattern && !walker.isOnNode(currNode)) {
+ rv = aFromPattern->matches(walker.getCurrentPosition(),
+ aContext, matchedFrom);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matchedFrom) {
+ break;
+ }
}
- if (countPattern->matches(walker.getCurrentPosition(), aContext)) {
+ bool matched;
+ rv = countPattern->matches(walker.getCurrentPosition(), aContext,
+ matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
++value;
}
@@ -256,10 +295,6 @@ txXSLTNumber::getValueList(Expr* aValueExpr, txPattern* aCountPattern,
}
}
- if (ownsCountPattern) {
- delete countPattern;
- }
-
return NS_OK;
}
@@ -388,18 +423,27 @@ txXSLTNumber::getCounters(Expr* aGroupSize, Expr* aGroupSeparator,
return NS_OK;
}
-int32_t
+nsresult
txXSLTNumber::getSiblingCount(txXPathTreeWalker& aWalker,
txPattern* aCountPattern,
- txIMatchContext* aContext)
+ txIMatchContext* aContext,
+ int32_t* aCount)
{
int32_t value = 1;
while (aWalker.moveToPreviousSibling()) {
- if (aCountPattern->matches(aWalker.getCurrentPosition(), aContext)) {
+ bool matched;
+ nsresult rv = aCountPattern->matches(aWalker.getCurrentPosition(),
+ aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
++value;
}
}
- return value;
+
+ *aCount = value;
+
+ return NS_OK;
}
bool
diff --git a/dom/xslt/xslt/txXSLTNumber.h b/dom/xslt/xslt/txXSLTNumber.h
index e6cdd421009c..73326d3ab513 100644
--- a/dom/xslt/xslt/txXSLTNumber.h
+++ b/dom/xslt/xslt/txXSLTNumber.h
@@ -46,9 +46,10 @@ private:
* position.
*
*/
- static int32_t getSiblingCount(txXPathTreeWalker& aWalker,
- txPattern* aCountPattern,
- txIMatchContext* aContext);
+ static nsresult getSiblingCount(txXPathTreeWalker& aWalker,
+ txPattern* aCountPattern,
+ txIMatchContext* aContext,
+ int32_t* aCount);
static bool getPrevInDocumentOrder(txXPathTreeWalker& aWalker);
diff --git a/dom/xslt/xslt/txXSLTPatterns.cpp b/dom/xslt/xslt/txXSLTPatterns.cpp
index c8fe71f72369..e5775dd3ef3b 100644
--- a/dom/xslt/xslt/txXSLTPatterns.cpp
+++ b/dom/xslt/xslt/txXSLTPatterns.cpp
@@ -32,15 +32,25 @@ double txUnionPattern::getDefaultPriority()
* This should be called on the simple patterns for xsl:template,
* but is fine for xsl:key and xsl:number
*/
-bool txUnionPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
+nsresult
+txUnionPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
uint32_t i, len = mLocPathPatterns.Length();
for (i = 0; i < len; ++i) {
- if (mLocPathPatterns[i]->matches(aNode, aContext)) {
- return true;
+ nsresult rv = mLocPathPatterns[i]->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (aMatched) {
+ aMatched = true;
+
+ return NS_OK;
}
}
- return false;
+
+ aMatched = false;
+
+ return NS_OK;
}
txPattern::Type
@@ -103,7 +113,9 @@ nsresult txLocPathPattern::addStep(txPattern* aPattern, bool isChild)
return NS_OK;
}
-bool txLocPathPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
+nsresult
+txLocPathPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
NS_ASSERTION(mSteps.Length() > 1, "Internal error");
@@ -121,18 +133,39 @@ bool txLocPathPattern::matches(const txXPathNode& aNode, txIMatchContext* aConte
uint32_t pos = mSteps.Length();
Step* step = &mSteps[--pos];
- if (!step->pattern->matches(aNode, aContext))
- return false;
+ nsresult rv = step->pattern->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!aMatched) {
+ return NS_OK;
+ }
txXPathTreeWalker walker(aNode);
bool hasParent = walker.moveToParent();
while (step->isChild) {
- if (!pos)
- return true; // all steps matched
+ if (!pos) {
+ aMatched = true;
+
+ return NS_OK; // all steps matched
+ }
+
+ if (!hasParent) {
+ // no more ancestors
+ aMatched = false;
+
+ return NS_OK;
+ }
+
step = &mSteps[--pos];
- if (!hasParent || !step->pattern->matches(walker.getCurrentPosition(), aContext))
- return false; // no more ancestors or no match
+ rv = step->pattern->matches(walker.getCurrentPosition(), aContext,
+ aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!aMatched) {
+ // no match
+ return NS_OK;
+ }
hasParent = walker.moveToParent();
}
@@ -142,12 +175,19 @@ bool txLocPathPattern::matches(const txXPathNode& aNode, txIMatchContext* aConte
uint32_t blockPos = pos;
while (pos) {
- if (!hasParent)
- return false; // There are more steps in the current block
- // than ancestors of the tested node
+ if (!hasParent) {
+ aMatched = false; // There are more steps in the current block
+ // than ancestors of the tested node
+ return NS_OK;
+ }
step = &mSteps[--pos];
- if (!step->pattern->matches(walker.getCurrentPosition(), aContext)) {
+ bool matched;
+ rv = step->pattern->matches(walker.getCurrentPosition(), aContext,
+ matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!matched) {
// Didn't match. We restart at beginning of block using a new
// start node
pos = blockPos;
@@ -164,7 +204,9 @@ bool txLocPathPattern::matches(const txXPathNode& aNode, txIMatchContext* aConte
}
}
- return true;
+ aMatched = true;
+
+ return NS_OK;
} // txLocPathPattern::matches
double txLocPathPattern::getDefaultPriority()
@@ -218,9 +260,13 @@ txLocPathPattern::toString(nsAString& aDest)
* a txPattern matching the document node, or '/'
*/
-bool txRootPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
+nsresult
+txRootPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
- return txXPathNodeUtils::isRoot(aNode);
+ aMatched = txXPathNodeUtils::isRoot(aNode);
+
+ return NS_OK;
}
double txRootPattern::getDefaultPriority()
@@ -264,10 +310,14 @@ txIdPattern::txIdPattern(const nsSubstring& aString)
}
}
-bool txIdPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
+nsresult
+txIdPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
if (!txXPathNodeUtils::isElement(aNode)) {
- return false;
+ aMatched = false;
+
+ return NS_OK;
}
// Get a ID attribute, if there is
@@ -275,7 +325,9 @@ bool txIdPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
NS_ASSERTION(content, "a Element without nsIContent");
nsIAtom* id = content->GetID();
- return id && mIds.IndexOf(id) > -1;
+ aMatched = id && mIds.IndexOf(id) > -1;
+
+ return NS_OK;
}
double txIdPattern::getDefaultPriority()
@@ -320,18 +372,22 @@ txIdPattern::toString(nsAString& aDest)
* argument.
*/
-bool txKeyPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
+nsresult
+txKeyPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
txExecutionState* es = (txExecutionState*)aContext->getPrivateContext();
nsAutoPtr contextDoc(txXPathNodeUtils::getOwnerDocument(aNode));
- NS_ENSURE_TRUE(contextDoc, false);
+ NS_ENSURE_TRUE(contextDoc, NS_ERROR_FAILURE);
RefPtr nodes;
nsresult rv = es->getKeyNodes(mName, *contextDoc, mValue, true,
getter_AddRefs(nodes));
- NS_ENSURE_SUCCESS(rv, false);
+ NS_ENSURE_SUCCESS(rv, rv);
- return nodes->contains(aNode);
+ aMatched = nodes->contains(aNode);
+
+ return NS_OK;
}
double txKeyPattern::getDefaultPriority()
@@ -373,21 +429,32 @@ txKeyPattern::toString(nsAString& aDest)
* a txPattern to hold the NodeTest and the Predicates of a StepPattern
*/
-bool txStepPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
+nsresult
+txStepPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext,
+ bool& aMatched)
{
NS_ASSERTION(mNodeTest, "Internal error");
- if (!mNodeTest->matches(aNode, aContext))
- return false;
+ nsresult rv = mNodeTest->matches(aNode, aContext, aMatched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!aMatched) {
+ return NS_OK;
+ }
txXPathTreeWalker walker(aNode);
if ((!mIsAttr &&
txXPathNodeUtils::isAttribute(walker.getCurrentPosition())) ||
!walker.moveToParent()) {
- return false;
+ aMatched = false;
+
+ return NS_OK;
}
+
if (isEmpty()) {
- return true;
+ aMatched = true;
+
+ return NS_OK;
}
/*
@@ -410,13 +477,17 @@ bool txStepPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
// Create the context node set for evaluating the predicates
RefPtr nodes;
- nsresult rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodes));
- NS_ENSURE_SUCCESS(rv, false);
+ rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodes));
+ NS_ENSURE_SUCCESS(rv, rv);
bool hasNext = mIsAttr ? walker.moveToFirstAttribute() :
walker.moveToFirstChild();
while (hasNext) {
- if (mNodeTest->matches(walker.getCurrentPosition(), aContext)) {
+ bool matched;
+ rv = mNodeTest->matches(walker.getCurrentPosition(), aContext, matched);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (matched) {
nodes->append(walker.getCurrentPosition());
}
hasNext = mIsAttr ? walker.moveToNextAttribute() :
@@ -426,7 +497,7 @@ bool txStepPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
Expr* predicate = mPredicates[0];
RefPtr newNodes;
rv = aContext->recycler()->getNodeSet(getter_AddRefs(newNodes));
- NS_ENSURE_SUCCESS(rv, false);
+ NS_ENSURE_SUCCESS(rv, rv);
uint32_t i, predLen = mPredicates.Length();
for (i = 1; i < predLen; ++i) {
@@ -437,7 +508,7 @@ bool txStepPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
predContext.next();
RefPtr exprResult;
rv = predicate->evaluate(&predContext, getter_AddRefs(exprResult));
- NS_ENSURE_SUCCESS(rv, false);
+ NS_ENSURE_SUCCESS(rv, rv);
switch(exprResult->getResultType()) {
case txAExprResult::NUMBER:
@@ -464,20 +535,25 @@ bool txStepPattern::matches(const txXPathNode& aNode, txIMatchContext* aContext)
nodes->clear();
nodes->append(*newNodes);
if (!contextIsInPredicate) {
- return false;
+ aMatched = false;
+
+ return NS_OK;
}
predicate = mPredicates[i];
}
txForwardContext evalContext(aContext, aNode, nodes);
RefPtr exprResult;
rv = predicate->evaluate(&evalContext, getter_AddRefs(exprResult));
- NS_ENSURE_SUCCESS(rv, false);
+ NS_ENSURE_SUCCESS(rv, rv);
- if (exprResult->getResultType() == txAExprResult::NUMBER)
+ if (exprResult->getResultType() == txAExprResult::NUMBER) {
// handle default, [position() == numberValue()]
- return ((double)evalContext.position() == exprResult->numberValue());
+ aMatched = ((double)evalContext.position() == exprResult->numberValue());
+ } else {
+ aMatched = exprResult->booleanValue();
+ }
- return exprResult->booleanValue();
+ return NS_OK;
} // matches
double txStepPattern::getDefaultPriority()
diff --git a/dom/xslt/xslt/txXSLTPatterns.h b/dom/xslt/xslt/txXSLTPatterns.h
index d93d54fe0eec..e7bab74f05c0 100644
--- a/dom/xslt/xslt/txXSLTPatterns.h
+++ b/dom/xslt/xslt/txXSLTPatterns.h
@@ -26,8 +26,9 @@ public:
/*
* Determines whether this Pattern matches the given node.
*/
- virtual bool matches(const txXPathNode& aNode,
- txIMatchContext* aContext) = 0;
+ virtual nsresult matches(const txXPathNode& aNode,
+ txIMatchContext* aContext,
+ bool& aMatched) = 0;
/*
* Returns the default priority of this Pattern.
@@ -86,7 +87,8 @@ public:
};
#define TX_DECL_PATTERN_BASE \
- bool matches(const txXPathNode& aNode, txIMatchContext* aContext) override; \
+ nsresult matches(const txXPathNode& aNode, txIMatchContext* aContext, \
+ bool& aMatched) override; \
double getDefaultPriority() override; \
virtual Expr* getSubExprAt(uint32_t aPos) override; \
virtual void setSubExprAt(uint32_t aPos, Expr* aExpr) override; \
diff --git a/image/encoders/bmp/nsBMPEncoder.cpp b/image/encoders/bmp/nsBMPEncoder.cpp
index 97f03f690be5..eda273604906 100644
--- a/image/encoders/bmp/nsBMPEncoder.cpp
+++ b/image/encoders/bmp/nsBMPEncoder.cpp
@@ -10,6 +10,7 @@
#include "nsString.h"
#include "nsStreamUtils.h"
#include "nsTArray.h"
+#include "mozilla/CheckedInt.h"
using namespace mozilla;
using namespace mozilla::image;
@@ -58,6 +59,11 @@ nsBMPEncoder::InitFromData(const uint8_t* aData,
return NS_ERROR_INVALID_ARG;
}
+ CheckedInt32 check = CheckedInt32(aWidth) * 4;
+ if (MOZ_UNLIKELY(!check.isValid())) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
// Stride is the padded width of each row, so it better be longer
if ((aInputFormat == INPUT_FORMAT_RGB &&
aStride < aWidth * 3) ||
@@ -86,19 +92,19 @@ nsBMPEncoder::InitFromData(const uint8_t* aData,
// Just a helper method to make it explicit in calculations that we are dealing
// with bytes and not bits
-static inline uint32_t
-BytesPerPixel(uint32_t aBPP)
+static inline uint16_t
+BytesPerPixel(uint16_t aBPP)
{
return aBPP / 8;
}
// Calculates the number of padding bytes that are needed per row of image data
static inline uint32_t
-PaddingBytes(uint32_t aBPP, uint32_t aWidth)
+PaddingBytes(uint16_t aBPP, uint32_t aWidth)
{
uint32_t rowSize = aWidth * BytesPerPixel(aBPP);
uint8_t paddingSize = 0;
- if(rowSize % 4) {
+ if (rowSize % 4) {
paddingSize = (4 - (rowSize % 4));
}
return paddingSize;
@@ -125,14 +131,21 @@ nsBMPEncoder::StartImageEncode(uint32_t aWidth,
// parse and check any provided output options
Version version;
- uint32_t bpp;
+ uint16_t bpp;
nsresult rv = ParseOptions(aOutputOptions, version, bpp);
if (NS_FAILED(rv)) {
return rv;
}
+ MOZ_ASSERT(bpp <= 32);
- InitFileHeader(version, bpp, aWidth, aHeight);
- InitInfoHeader(version, bpp, aWidth, aHeight);
+ rv = InitFileHeader(version, bpp, aWidth, aHeight);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ rv = InitInfoHeader(version, bpp, aWidth, aHeight);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
mImageBufferSize = mBMPFileHeader.filesize;
mImageBufferStart = static_cast(malloc(mImageBufferSize));
@@ -187,12 +200,26 @@ nsBMPEncoder::AddImageFrame(const uint8_t* aData,
return NS_ERROR_INVALID_ARG;
}
- auto row = MakeUniqueFallible(mBMPInfoHeader.width *
- BytesPerPixel(mBMPInfoHeader.bpp));
+ if (mBMPInfoHeader.width < 0) {
+ return NS_ERROR_ILLEGAL_VALUE;
+ }
+
+ CheckedUint32 size =
+ CheckedUint32(mBMPInfoHeader.width) * CheckedUint32(BytesPerPixel(mBMPInfoHeader.bpp));
+ if (MOZ_UNLIKELY(!size.isValid())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ auto row = MakeUniqueFallible(size.value());
if (!row) {
return NS_ERROR_OUT_OF_MEMORY;
}
+ CheckedUint32 check = CheckedUint32(mBMPInfoHeader.height) * aStride;
+ if (MOZ_UNLIKELY(!check.isValid())) {
+ return NS_ERROR_FAILURE;
+ }
+
// write each row: if we add more input formats, we may want to
// generalize the conversions
if (aInputFormat == INPUT_FORMAT_HOSTARGB) {
@@ -256,7 +283,7 @@ nsBMPEncoder::EndImageEncode()
// See InitFromData for a description of the parse options
nsresult
nsBMPEncoder::ParseOptions(const nsAString& aOptions, Version& aVersionOut,
- uint32_t& aBppOut)
+ uint16_t& aBppOut)
{
aVersionOut = VERSION_3;
aBppOut = 24;
@@ -424,7 +451,7 @@ nsBMPEncoder::ConvertHostARGBRow(const uint8_t* aSrc,
const UniquePtr& aDest,
uint32_t aPixelWidth)
{
- int bytes = BytesPerPixel(mBMPInfoHeader.bpp);
+ uint16_t bytes = BytesPerPixel(mBMPInfoHeader.bpp);
if (mBMPInfoHeader.bpp == 32) {
for (uint32_t x = 0; x < aPixelWidth; x++) {
@@ -473,8 +500,8 @@ nsBMPEncoder::NotifyListener()
}
// Initializes the BMP file header mBMPFileHeader to the passed in values
-void
-nsBMPEncoder::InitFileHeader(Version aVersion, uint32_t aBPP, uint32_t aWidth,
+nsresult
+nsBMPEncoder::InitFileHeader(Version aVersion, uint16_t aBPP, uint32_t aWidth,
uint32_t aHeight)
{
memset(&mBMPFileHeader, 0, sizeof(mBMPFileHeader));
@@ -491,13 +518,25 @@ nsBMPEncoder::InitFileHeader(Version aVersion, uint32_t aBPP, uint32_t aWidth,
if (aBPP <= 8) {
uint32_t numColors = 1 << aBPP;
mBMPFileHeader.dataoffset += 4 * numColors;
- mBMPFileHeader.filesize = mBMPFileHeader.dataoffset + aWidth * aHeight;
+ CheckedUint32 filesize =
+ CheckedUint32(mBMPFileHeader.dataoffset) + CheckedUint32(aWidth) * aHeight;
+ if (MOZ_UNLIKELY(!filesize.isValid())) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ mBMPFileHeader.filesize = filesize.value();
} else {
- mBMPFileHeader.filesize = mBMPFileHeader.dataoffset +
- (aWidth * BytesPerPixel(aBPP) + PaddingBytes(aBPP, aWidth)) * aHeight;
+ CheckedUint32 filesize =
+ CheckedUint32(mBMPFileHeader.dataoffset) +
+ (CheckedUint32(aWidth) * BytesPerPixel(aBPP) + PaddingBytes(aBPP, aWidth)) * aHeight;
+ if (MOZ_UNLIKELY(!filesize.isValid())) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ mBMPFileHeader.filesize = filesize.value();
}
mBMPFileHeader.reserved = 0;
+
+ return NS_OK;
}
#define ENCODE(pImageBufferCurr, value) \
@@ -505,8 +544,8 @@ nsBMPEncoder::InitFileHeader(Version aVersion, uint32_t aBPP, uint32_t aWidth,
*pImageBufferCurr += sizeof value;
// Initializes the bitmap info header mBMPInfoHeader to the passed in values
-void
-nsBMPEncoder::InitInfoHeader(Version aVersion, uint32_t aBPP, uint32_t aWidth,
+nsresult
+nsBMPEncoder::InitInfoHeader(Version aVersion, uint16_t aBPP, uint32_t aWidth,
uint32_t aHeight)
{
memset(&mBMPInfoHeader, 0, sizeof(mBMPInfoHeader));
@@ -516,18 +555,39 @@ nsBMPEncoder::InitInfoHeader(Version aVersion, uint32_t aBPP, uint32_t aWidth,
MOZ_ASSERT(aVersion == VERSION_5);
mBMPInfoHeader.bihsize = InfoHeaderLength::WIN_V5;
}
- mBMPInfoHeader.width = aWidth;
- mBMPInfoHeader.height = aHeight;
+
+ CheckedInt32 width(aWidth);
+ CheckedInt32 height(aHeight);
+ if (MOZ_UNLIKELY(!width.isValid() || !height.isValid())) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ mBMPInfoHeader.width = width.value();
+ mBMPInfoHeader.height = height.value();
+
mBMPInfoHeader.planes = 1;
mBMPInfoHeader.bpp = aBPP;
mBMPInfoHeader.compression = 0;
mBMPInfoHeader.colors = 0;
mBMPInfoHeader.important_colors = 0;
+
+ CheckedUint32 check = CheckedUint32(aWidth) * BytesPerPixel(aBPP);
+ if (MOZ_UNLIKELY(!check.isValid())) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
if (aBPP <= 8) {
- mBMPInfoHeader.image_size = aWidth * aHeight;
+ CheckedUint32 imagesize = CheckedUint32(aWidth) * aHeight;
+ if (MOZ_UNLIKELY(!imagesize.isValid())) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ mBMPInfoHeader.image_size = imagesize.value();
} else {
- mBMPInfoHeader.image_size =
- (aWidth * BytesPerPixel(aBPP) + PaddingBytes(aBPP, aWidth)) * aHeight;
+ CheckedUint32 imagesize =
+ (CheckedUint32(aWidth) * BytesPerPixel(aBPP) + PaddingBytes(aBPP, aWidth)) * CheckedUint32(aHeight);
+ if (MOZ_UNLIKELY(!imagesize.isValid())) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ mBMPInfoHeader.image_size = imagesize.value();
}
mBMPInfoHeader.xppm = 0;
mBMPInfoHeader.yppm = 0;
@@ -554,6 +614,8 @@ nsBMPEncoder::InitInfoHeader(Version aVersion, uint32_t aBPP, uint32_t aWidth,
mBMPInfoHeader.profile_size = 0;
mBMPInfoHeader.reserved = 0;
}
+
+ return NS_OK;
}
// Encodes the BMP file header mBMPFileHeader
diff --git a/image/encoders/bmp/nsBMPEncoder.h b/image/encoders/bmp/nsBMPEncoder.h
index c531fc28db8b..b90af4d19744 100644
--- a/image/encoders/bmp/nsBMPEncoder.h
+++ b/image/encoders/bmp/nsBMPEncoder.h
@@ -104,7 +104,7 @@ protected:
// See InitData in the cpp for valid parse options
nsresult ParseOptions(const nsAString& aOptions, Version& aVersionOut,
- uint32_t& aBppOut);
+ uint16_t& aBppOut);
// Obtains data with no alpha in machine-independent byte order
void ConvertHostARGBRow(const uint8_t* aSrc,
const mozilla::UniquePtr& aDest,
@@ -113,11 +113,11 @@ protected:
void NotifyListener();
// Initializes the bitmap file header member mBMPFileHeader
- void InitFileHeader(Version aVersion, uint32_t aBPP, uint32_t aWidth,
- uint32_t aHeight);
+ nsresult InitFileHeader(Version aVersion, uint16_t aBPP, uint32_t aWidth,
+ uint32_t aHeight);
// Initializes the bitmap info header member mBMPInfoHeader
- void InitInfoHeader(Version aVersion, uint32_t aBPP, uint32_t aWidth,
- uint32_t aHeight);
+ nsresult InitInfoHeader(Version aVersion, uint16_t aBPP, uint32_t aWidth,
+ uint32_t aHeight);
// Encodes the bitmap file header member mBMPFileHeader
void EncodeFileHeader();
diff --git a/image/encoders/ico/nsICOEncoder.cpp b/image/encoders/ico/nsICOEncoder.cpp
index b61e99808804..c64914a6094c 100644
--- a/image/encoders/ico/nsICOEncoder.cpp
+++ b/image/encoders/ico/nsICOEncoder.cpp
@@ -228,10 +228,11 @@ nsICOEncoder::StartImageEncode(uint32_t aWidth,
}
// parse and check any provided output options
- uint32_t bpp = 24;
+ uint16_t bpp = 24;
bool usePNG = true;
nsresult rv = ParseOptions(aOutputOptions, bpp, usePNG);
NS_ENSURE_SUCCESS(rv, rv);
+ MOZ_ASSERT(bpp <= 32);
mUsePNG = usePNG;
@@ -265,7 +266,7 @@ nsICOEncoder::EndImageEncode()
// Parses the encoder options and sets the bits per pixel to use and PNG or BMP
// See InitFromData for a description of the parse options
nsresult
-nsICOEncoder::ParseOptions(const nsAString& aOptions, uint32_t& aBppOut,
+nsICOEncoder::ParseOptions(const nsAString& aOptions, uint16_t& aBppOut,
bool& aUsePNGOut)
{
// If no parsing options just use the default of 24BPP and PNG yes
@@ -469,7 +470,7 @@ nsICOEncoder::InitFileHeader()
// Initializes the icon directory info header mICODirEntry
void
-nsICOEncoder::InitInfoHeader(uint32_t aBPP, uint8_t aWidth, uint8_t aHeight)
+nsICOEncoder::InitInfoHeader(uint16_t aBPP, uint8_t aWidth, uint8_t aHeight)
{
memset(&mICODirEntry, 0, sizeof(mICODirEntry));
mICODirEntry.mBitCount = aBPP;
diff --git a/image/encoders/ico/nsICOEncoder.h b/image/encoders/ico/nsICOEncoder.h
index 37efe2f750c9..a8a9a504974c 100644
--- a/image/encoders/ico/nsICOEncoder.h
+++ b/image/encoders/ico/nsICOEncoder.h
@@ -50,14 +50,14 @@ public:
protected:
~nsICOEncoder();
- nsresult ParseOptions(const nsAString& aOptions, uint32_t& aBppOut,
+ nsresult ParseOptions(const nsAString& aOptions, uint16_t& aBppOut,
bool& aUsePNGOut);
void NotifyListener();
// Initializes the icon file header mICOFileHeader
void InitFileHeader();
// Initializes the icon directory info header mICODirEntry
- void InitInfoHeader(uint32_t aBPP, uint8_t aWidth, uint8_t aHeight);
+ void InitInfoHeader(uint16_t aBPP, uint8_t aWidth, uint8_t aHeight);
// Encodes the icon file header mICOFileHeader
void EncodeFileHeader();
// Encodes the icon directory info header mICODirEntry
diff --git a/js/src/jit/arm/Lowering-arm.cpp b/js/src/jit/arm/Lowering-arm.cpp
index b69d9e5617a5..9808cda9e8a2 100644
--- a/js/src/jit/arm/Lowering-arm.cpp
+++ b/js/src/jit/arm/Lowering-arm.cpp
@@ -902,6 +902,8 @@ LIRGeneratorARM::visitAsmJSCompareExchangeHeap(MAsmJSCompareExchangeHeap* ins)
MOZ_ASSERT(base->type() == MIRType::Int32);
if (byteSize(ins->access().type()) != 4 && !HasLDSTREXBHD()) {
+ gen->setPerformsCall();
+
LAsmJSCompareExchangeCallout* lir =
new(alloc()) LAsmJSCompareExchangeCallout(useFixedAtStart(base, IntArgReg2),
useFixedAtStart(ins->oldValue(), IntArgReg3),
@@ -929,6 +931,8 @@ LIRGeneratorARM::visitAsmJSAtomicExchangeHeap(MAsmJSAtomicExchangeHeap* ins)
MOZ_ASSERT(ins->access().offset() == 0);
if (byteSize(ins->access().type()) < 4 && !HasLDSTREXBHD()) {
+ gen->setPerformsCall();
+
// Call out on ARMv6.
defineReturn(new(alloc()) LAsmJSAtomicExchangeCallout(useFixedAtStart(ins->base(), IntArgReg2),
useFixedAtStart(ins->value(), IntArgReg3),
@@ -953,6 +957,8 @@ LIRGeneratorARM::visitAsmJSAtomicBinopHeap(MAsmJSAtomicBinopHeap* ins)
MOZ_ASSERT(base->type() == MIRType::Int32);
if (byteSize(ins->access().type()) != 4 && !HasLDSTREXBHD()) {
+ gen->setPerformsCall();
+
LAsmJSAtomicBinopCallout* lir =
new(alloc()) LAsmJSAtomicBinopCallout(useFixedAtStart(base, IntArgReg2),
useFixedAtStart(ins->value(), IntArgReg3),
diff --git a/mfbt/Casting.h b/mfbt/Casting.h
index a7d0fb50d688..adf2c90456b4 100644
--- a/mfbt/Casting.h
+++ b/mfbt/Casting.h
@@ -238,6 +238,19 @@ AssertedCast(const From aFrom)
return static_cast(aFrom);
}
+/**
+ * Cast a value of integral type |From| to a value of integral type |To|,
+ * release asserting that the cast will be a safe cast per C++ (that is, that
+ * |to| is in the range of values permitted for the type |From|).
+ */
+template
+inline To
+ReleaseAssertedCast(const From aFrom)
+{
+ MOZ_RELEASE_ASSERT((detail::IsInBounds(aFrom)));
+ return static_cast(aFrom);
+}
+
} // namespace mozilla
#endif /* mozilla_Casting_h */
diff --git a/mfbt/Range.h b/mfbt/Range.h
index 47d91bb0ccab..753fe07f897e 100644
--- a/mfbt/Range.h
+++ b/mfbt/Range.h
@@ -9,6 +9,7 @@
#include "mozilla/RangedPtr.h"
#include "mozilla/TypeTraits.h"
+#include "mozilla/Span.h"
#include
@@ -44,6 +45,19 @@ public:
mEnd(aOther.mEnd)
{}
+ MOZ_IMPLICIT Range(Span aSpan)
+ : Range(aSpan.Elements(), aSpan.Length())
+ {
+ }
+
+ template::value,
+ int>::Type>
+ MOZ_IMPLICIT Range(const Span& aSpan)
+ : Range(aSpan.Elements(), aSpan.Length())
+ {
+ }
+
RangedPtr begin() const { return mStart; }
RangedPtr end() const { return mEnd; }
size_t length() const { return mEnd - mStart; }
@@ -51,8 +65,26 @@ public:
T& operator[](size_t aOffset) const { return mStart[aOffset]; }
explicit operator bool() const { return mStart != nullptr; }
+
+ operator Span() { return Span(mStart.get(), length()); }
+
+ operator Span() const { return Span(mStart.get(), length()); }
};
+template
+Span
+MakeSpan(Range& aRange)
+{
+ return aRange;
+}
+
+template
+Span
+MakeSpan(const Range& aRange)
+{
+ return aRange;
+}
+
} // namespace mozilla
#endif /* mozilla_Range_h */
diff --git a/mfbt/Span.h b/mfbt/Span.h
new file mode 100644
index 000000000000..5acaafcbd73c
--- /dev/null
+++ b/mfbt/Span.h
@@ -0,0 +1,1041 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Adapted from https://github.com/Microsoft/GSL/blob/3819df6e378ffccf0e29465afe99c3b324c2aa70/include/gsl/span
+// and https://github.com/Microsoft/GSL/blob/3819df6e378ffccf0e29465afe99c3b324c2aa70/include/gsl/gsl_util
+
+#ifndef mozilla_Span_h
+#define mozilla_Span_h
+
+#include "mozilla/Array.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Casting.h"
+#include "mozilla/IntegerTypeTraits.h"
+#include "mozilla/Move.h"
+#include "mozilla/TypeTraits.h"
+#include "mozilla/UniquePtr.h"
+
+#include
+#include
+#include
+#include
+
+// Classifications for reasons why constexpr was removed in C++14 to C++11
+// conversion. Once we upgrade compilers, we can try defining each of these
+// to constexpr to restore a category of constexprs at a time.
+#define MOZ_SPAN_ASSERTION_CONSTEXPR
+#define MOZ_SPAN_GCC_CONSTEXPR
+#define MOZ_SPAN_EXPLICITLY_DEFAULTED_CONSTEXPR
+#define MOZ_SPAN_CONSTEXPR_NOT_JUST_RETURN
+#define MOZ_SPAN_NON_CONST_CONSTEXPR
+
+#ifdef _MSC_VER
+#pragma warning(push)
+
+// turn off some warnings that are noisy about our MOZ_RELEASE_ASSERT statements
+#pragma warning(disable : 4127) // conditional expression is constant
+
+// blanket turn off warnings from CppCoreCheck for now
+// so people aren't annoyed by them when running the tool.
+// more targeted suppressions will be added in a future update to the GSL
+#pragma warning(disable : 26481 26482 26483 26485 26490 26491 26492 26493 26495)
+
+#if _MSC_VER < 1910
+#pragma push_macro("constexpr")
+#define constexpr /*constexpr*/
+
+#endif // _MSC_VER < 1910
+#endif // _MSC_VER
+
+namespace mozilla {
+
+// Stuff from gsl_util
+
+// narrow_cast(): a searchable way to do narrowing casts of values
+template
+inline constexpr T
+narrow_cast(U&& u)
+{
+ return static_cast(mozilla::Forward(u));
+}
+
+// end gsl_util
+
+// [views.constants], constants
+// This was -1 in gsl::span, but using size_t for sizes instead of ptrdiff_t
+// and reserving a magic value that realistically doesn't occur in
+// compile-time-constant Span sizes makes things a lot less messy in terms of
+// comparison between signed and unsigned.
+constexpr const size_t dynamic_extent = mozilla::MaxValue::value;
+
+template
+class Span;
+
+// implementation details
+namespace span_details {
+
+// C++14 types that we don't have because we build as C++11.
+template
+using remove_cv_t = typename mozilla::RemoveCV::Type;
+template
+using remove_const_t = typename mozilla::RemoveConst::Type;
+template
+using conditional_t = typename mozilla::Conditional::Type;
+template
+using add_pointer_t = typename mozilla::AddPointer::Type;
+template
+using enable_if_t = typename mozilla::EnableIf::Type;
+
+template
+struct is_span_oracle : mozilla::FalseType
+{
+};
+
+template
+struct is_span_oracle> : mozilla::TrueType
+{
+};
+
+template
+struct is_span : public is_span_oracle>
+{
+};
+
+template
+struct is_std_array_oracle : mozilla::FalseType
+{
+};
+
+template
+struct is_std_array_oracle> : mozilla::TrueType
+{
+};
+
+template
+struct is_std_array : public is_std_array_oracle>
+{
+};
+
+template
+struct is_allowed_extent_conversion
+ : public mozilla::IntegralConstant
+{
+};
+
+template
+struct is_allowed_element_type_conversion
+ : public mozilla::IntegralConstant::value>
+{
+};
+
+template
+class span_iterator
+{
+ using element_type_ = typename Span::element_type;
+
+public:
+ using iterator_category = std::random_access_iterator_tag;
+ using value_type = remove_const_t;
+ using difference_type = typename Span::index_type;
+
+ using reference = conditional_t&;
+ using pointer = add_pointer_t;
+
+ constexpr span_iterator() : span_iterator(nullptr, 0) {}
+
+ MOZ_SPAN_ASSERTION_CONSTEXPR span_iterator(const Span* span,
+ typename Span::index_type index)
+ : span_(span)
+ , index_(index)
+ {
+ MOZ_RELEASE_ASSERT(span == nullptr ||
+ (index_ >= 0 && index <= span_->Length()));
+ }
+
+ friend class span_iterator;
+ constexpr MOZ_IMPLICIT span_iterator(const span_iterator& other)
+ : span_iterator(other.span_, other.index_)
+ {
+ }
+
+ MOZ_SPAN_EXPLICITLY_DEFAULTED_CONSTEXPR span_iterator&
+ operator=(const span_iterator&) = default;
+
+ MOZ_SPAN_GCC_CONSTEXPR reference operator*() const
+ {
+ MOZ_RELEASE_ASSERT(span_);
+ return (*span_)[index_];
+ }
+
+ MOZ_SPAN_GCC_CONSTEXPR pointer operator->() const
+ {
+ MOZ_RELEASE_ASSERT(span_);
+ return &((*span_)[index_]);
+ }
+
+ MOZ_SPAN_NON_CONST_CONSTEXPR span_iterator& operator++()
+ {
+ MOZ_RELEASE_ASSERT(span_ && index_ >= 0 && index_ < span_->Length());
+ ++index_;
+ return *this;
+ }
+
+ MOZ_SPAN_NON_CONST_CONSTEXPR span_iterator operator++(int)
+ {
+ auto ret = *this;
+ ++(*this);
+ return ret;
+ }
+
+ MOZ_SPAN_NON_CONST_CONSTEXPR span_iterator& operator--()
+ {
+ MOZ_RELEASE_ASSERT(span_ && index_ > 0 && index_ <= span_->Length());
+ --index_;
+ return *this;
+ }
+
+ MOZ_SPAN_NON_CONST_CONSTEXPR span_iterator operator--(int)
+ {
+ auto ret = *this;
+ --(*this);
+ return ret;
+ }
+
+ MOZ_SPAN_CONSTEXPR_NOT_JUST_RETURN span_iterator
+ operator+(difference_type n) const
+ {
+ auto ret = *this;
+ return ret += n;
+ }
+
+ MOZ_SPAN_GCC_CONSTEXPR span_iterator& operator+=(difference_type n)
+ {
+ MOZ_RELEASE_ASSERT(span_ && (index_ + n) >= 0 &&
+ (index_ + n) <= span_->Length());
+ index_ += n;
+ return *this;
+ }
+
+ MOZ_SPAN_CONSTEXPR_NOT_JUST_RETURN span_iterator
+ operator-(difference_type n) const
+ {
+ auto ret = *this;
+ return ret -= n;
+ }
+
+ MOZ_SPAN_NON_CONST_CONSTEXPR span_iterator& operator-=(difference_type n)
+
+ {
+ return *this += -n;
+ }
+
+ MOZ_SPAN_GCC_CONSTEXPR difference_type
+ operator-(const span_iterator& rhs) const
+ {
+ MOZ_RELEASE_ASSERT(span_ == rhs.span_);
+ return index_ - rhs.index_;
+ }
+
+ constexpr reference operator[](difference_type n) const
+ {
+ return *(*this + n);
+ }
+
+ constexpr friend bool operator==(const span_iterator& lhs,
+ const span_iterator& rhs)
+ {
+ return lhs.span_ == rhs.span_ && lhs.index_ == rhs.index_;
+ }
+
+ constexpr friend bool operator!=(const span_iterator& lhs,
+ const span_iterator& rhs)
+ {
+ return !(lhs == rhs);
+ }
+
+ MOZ_SPAN_GCC_CONSTEXPR friend bool operator<(const span_iterator& lhs,
+ const span_iterator& rhs)
+ {
+ MOZ_RELEASE_ASSERT(lhs.span_ == rhs.span_);
+ return lhs.index_ < rhs.index_;
+ }
+
+ constexpr friend bool operator<=(const span_iterator& lhs,
+ const span_iterator& rhs)
+ {
+ return !(rhs < lhs);
+ }
+
+ constexpr friend bool operator>(const span_iterator& lhs,
+ const span_iterator& rhs)
+ {
+ return rhs < lhs;
+ }
+
+ constexpr friend bool operator>=(const span_iterator& lhs,
+ const span_iterator& rhs)
+ {
+ return !(rhs > lhs);
+ }
+
+ void swap(span_iterator& rhs)
+ {
+ std::swap(index_, rhs.index_);
+ std::swap(span_, rhs.span_);
+ }
+
+protected:
+ const Span* span_;
+ size_t index_;
+};
+
+template
+inline constexpr span_iterator
+operator+(typename span_iterator::difference_type n,
+ const span_iterator& rhs)
+{
+ return rhs + n;
+}
+
+template
+class extent_type
+{
+public:
+ using index_type = size_t;
+
+ static_assert(Ext >= 0, "A fixed-size Span must be >= 0 in size.");
+
+ constexpr extent_type() {}
+
+ template
+ MOZ_SPAN_ASSERTION_CONSTEXPR MOZ_IMPLICIT extent_type(extent_type ext)
+ {
+ static_assert(
+ Other == Ext || Other == dynamic_extent,
+ "Mismatch between fixed-size extent and size of initializing data.");
+ MOZ_RELEASE_ASSERT(ext.size() == Ext);
+ }
+
+ MOZ_SPAN_ASSERTION_CONSTEXPR MOZ_IMPLICIT extent_type(index_type length)
+ {
+ MOZ_RELEASE_ASSERT(length == Ext);
+ }
+
+ constexpr index_type size() const { return Ext; }
+};
+
+template<>
+class extent_type
+{
+public:
+ using index_type = size_t;
+
+ template
+ explicit constexpr extent_type(extent_type ext)
+ : size_(ext.size())
+ {
+ }
+
+ explicit constexpr extent_type(index_type length)
+ : size_(length)
+ {
+ }
+
+ constexpr index_type size() const { return size_; }
+
+private:
+ index_type size_;
+};
+} // namespace span_details
+
+/**
+ * Span - slices for C++
+ *
+ * Span implements Rust's slice concept for C++. It's called "Span" instead of
+ * "Slice" to follow the naming used in C++ Core Guidelines.
+ *
+ * A Span wraps a pointer and a length that identify a non-owning view to a
+ * contiguous block of memory of objects of the same type. Various types,
+ * including (pre-decay) C arrays, XPCOM strings, nsTArray, mozilla::Array,
+ * mozilla::Range and contiguous standard-library containers, auto-convert
+ * into Spans when attempting to pass them as arguments to methods that take
+ * Spans. MakeSpan() functions can be used for explicit conversion in other
+ * contexts. (Span itself autoconverts into mozilla::Range.)
+ *
+ * Like Rust's slices, Span provides safety against out-of-bounds access by
+ * performing run-time bound checks. However, unlike Rust's slices, Span
+ * cannot provide safety against use-after-free.
+ *
+ * (Note: Span is like Rust's slice only conceptually. Due to the lack of
+ * ABI guarantees, you should still decompose spans/slices to raw pointer
+ * and length parts when crossing the FFI.)
+ *
+ * In addition to having constructors and MakeSpan() functions that take
+ * various well-known types, a Span for an arbitrary type can be constructed
+ * (via constructor or MakeSpan()) from a pointer and a length or a pointer
+ * and another pointer pointing just past the last element.
+ *
+ * A Span can be obtained for const char* pointing to a
+ * zero-terminated C string using the MakeCStringSpan() function. A
+ * corresponding implicit constructor does not exist in order to avoid
+ * accidental construction in cases where const char* does not point to a
+ * zero-terminated C string.
+ *
+ * Span has methods that follow the Mozilla naming style and methods that
+ * don't. The methods that follow the Mozilla naming style are meant to be
+ * used directly from Mozilla code. The methods that don't are meant for
+ * integration with C++11 range-based loops and with meta-programming that
+ * expects the same methods that are found on the standard-library
+ * containers. For example, to decompose a Span into its parts in Mozilla
+ * code, use Elements() and Length() (as with nsTArray) instead of data()
+ * and size() (as with std::vector).
+ *
+ * The pointer and length wrapped by a Span cannot be changed after a Span has
+ * been created. When new values are required, simply create a new Span. Span
+ * has a method called Subspan() that works analogously to the Substring()
+ * method of XPCOM strings taking a start index and an optional length. As a
+ * Mozilla extension (relative to Microsoft's gsl::span that mozilla::Span is
+ * based on), Span has methods From(start), To(end) and FromTo(start, end)
+ * that correspond to Rust's &slice[start..], &slice[..end] and
+ * &slice[start..end], respectively. (That is, the end index is the index of
+ * the first element not to be included in the new subspan.)
+ *
+ * When indicating a Span that's only read from, const goes inside the type
+ * parameter. Don't put const in front of Span. That is:
+ * size_t ReadsFromOneSpanAndWritesToAnother(Span aReadFrom,
+ * Span aWrittenTo);
+ *
+ * Any Span can be viewed as Span using the function
+ * AsBytes(). Any Span can be viewed as Span using the function
+ * AsWritableBytes().
+ */
+template
+class Span
+{
+public:
+ // constants and types
+ using element_type = ElementType;
+ using index_type = size_t;
+ using pointer = element_type*;
+ using reference = element_type&;
+
+ using iterator =
+ span_details::span_iterator, false>;
+ using const_iterator =
+ span_details::span_iterator, true>;
+ using reverse_iterator = std::reverse_iterator;
+ using const_reverse_iterator = std::reverse_iterator;
+
+ constexpr static const index_type extent = Extent;
+
+ // [Span.cons], Span constructors, copy, assignment, and destructor
+ // "Dependent" is needed to make "span_details::enable_if_t<(Dependent || Extent == 0 || Extent == mozilla::MaxValue::value)>" SFINAE,
+ // since "span_details::enable_if_t<(Extent == 0 || Extent == mozilla::MaxValue::value)>" is ill-formed when Extent is neither of the extreme values.
+ /**
+ * Constructor with no args.
+ */
+ template<
+ bool Dependent = false,
+ class = span_details::enable_if_t<
+ (Dependent || Extent == 0 || Extent == mozilla::MaxValue::value)>>
+ constexpr Span()
+ : storage_(nullptr, span_details::extent_type<0>())
+ {
+ }
+
+ /**
+ * Constructor for nullptr.
+ */
+ constexpr MOZ_IMPLICIT Span(std::nullptr_t) : Span() {}
+
+ /**
+ * Constructor for pointer and length.
+ */
+ constexpr Span(pointer aPtr, index_type aLength)
+ : storage_(aPtr, aLength)
+ {
+ }
+
+ /**
+ * Constructor for start pointer and pointer past end.
+ */
+ constexpr Span(pointer aStartPtr, pointer aEndPtr)
+ : storage_(aStartPtr, std::distance(aStartPtr, aEndPtr))
+ {
+ }
+
+ /**
+ * Constructor for C array.
+ */
+ template
+ constexpr MOZ_IMPLICIT Span(element_type (&aArr)[N])
+ : storage_(&aArr[0], span_details::extent_type())
+ {
+ }
+
+ /**
+ * Constructor for std::array.
+ */
+ template>
+ constexpr MOZ_IMPLICIT Span(std::array& aArr)
+ : storage_(&aArr[0], span_details::extent_type())
+ {
+ }
+
+ /**
+ * Constructor for const std::array.
+ */
+ template
+ constexpr MOZ_IMPLICIT Span(
+ const std::array, N>& aArr)
+ : storage_(&aArr[0], span_details::extent_type())
+ {
+ }
+
+ /**
+ * Constructor for mozilla::Array.
+ */
+ template>
+ constexpr MOZ_IMPLICIT Span(mozilla::Array& aArr)
+ : storage_(&aArr[0], span_details::extent_type())
+ {
+ }
+
+ /**
+ * Constructor for const mozilla::Array.
+ */
+ template
+ constexpr MOZ_IMPLICIT Span(
+ const mozilla::Array, N>& aArr)
+ : storage_(&aArr[0], span_details::extent_type())
+ {
+ }
+
+ /**
+ * Constructor for mozilla::UniquePtr holding an array and length.
+ */
+ template>
+ constexpr Span(const mozilla::UniquePtr& aPtr,
+ index_type aLength)
+ : storage_(aPtr.get(), aLength)
+ {
+ }
+
+ // NB: the SFINAE here uses .data() as a incomplete/imperfect proxy for the requirement
+ // on Container to be a contiguous sequence container.
+ /**
+ * Constructor for standard-library containers.
+ */
+ template<
+ class Container,
+ class = span_details::enable_if_t<
+ !span_details::is_span::value &&
+ !span_details::is_std_array::value &&
+ mozilla::IsConvertible::value &&
+ mozilla::IsConvertible().data())>::value>>
+ constexpr MOZ_IMPLICIT Span(Container& cont)
+ : Span(cont.data(), ReleaseAssertedCast(cont.size()))
+ {
+ }
+
+ /**
+ * Constructor for standard-library containers (const version).
+ */
+ template<
+ class Container,
+ class = span_details::enable_if_t<
+ mozilla::IsConst::value &&
+ !span_details::is_span::value &&
+ mozilla::IsConvertible::value &&
+ mozilla::IsConvertible().data())>::value>>
+ constexpr MOZ_IMPLICIT Span(const Container& cont)
+ : Span(cont.data(), ReleaseAssertedCast(cont.size()))
+ {
+ }
+
+ /**
+ * Constructor from other Span.
+ */
+ constexpr Span(const Span& other) = default;
+
+ /**
+ * Constructor from other Span.
+ */
+ constexpr Span(Span&& other) = default;
+
+ /**
+ * Constructor from other Span with conversion of element type.
+ */
+ template<
+ class OtherElementType,
+ size_t OtherExtent,
+ class = span_details::enable_if_t<
+ span_details::is_allowed_extent_conversion::value &&
+ span_details::is_allowed_element_type_conversion::value>>
+ constexpr MOZ_IMPLICIT Span(const Span& other)
+ : storage_(other.data(),
+ span_details::extent_type(other.size()))
+ {
+ }
+
+ /**
+ * Constructor from other Span with conversion of element type.
+ */
+ template<
+ class OtherElementType,
+ size_t OtherExtent,
+ class = span_details::enable_if_t<
+ span_details::is_allowed_extent_conversion::value &&
+ span_details::is_allowed_element_type_conversion::value>>
+ constexpr MOZ_IMPLICIT Span(Span&& other)
+ : storage_(other.data(),
+ span_details::extent_type(other.size()))
+ {
+ }
+
+ ~Span() = default;
+ MOZ_SPAN_EXPLICITLY_DEFAULTED_CONSTEXPR Span& operator=(const Span& other)
+ = default;
+
+ MOZ_SPAN_EXPLICITLY_DEFAULTED_CONSTEXPR Span& operator=(Span&& other)
+ = default;
+
+ // [Span.sub], Span subviews
+ /**
+ * Subspan with first N elements with compile-time N.
+ */
+ template
+ MOZ_SPAN_GCC_CONSTEXPR Span First() const
+ {
+ MOZ_RELEASE_ASSERT(Count <= size());
+ return { data(), Count };
+ }
+
+ /**
+ * Subspan with last N elements with compile-time N.
+ */
+ template
+ MOZ_SPAN_GCC_CONSTEXPR Span Last() const
+ {
+ MOZ_RELEASE_ASSERT(Count <= size());
+ return { data() + (size() - Count), Count };
+ }
+
+ /**
+ * Subspan with compile-time start index and length.
+ */
+ template
+ MOZ_SPAN_GCC_CONSTEXPR Span Subspan() const
+ {
+ MOZ_RELEASE_ASSERT(Offset <= size() &&
+ (Count == dynamic_extent || (Offset + Count <= size())));
+ return { data() + Offset,
+ Count == dynamic_extent ? size() - Offset : Count };
+ }
+
+ /**
+ * Subspan with first N elements with run-time N.
+ */
+ MOZ_SPAN_GCC_CONSTEXPR Span First(
+ index_type aCount) const
+ {
+ MOZ_RELEASE_ASSERT(aCount <= size());
+ return { data(), aCount };
+ }
+
+ /**
+ * Subspan with last N elements with run-time N.
+ */
+ MOZ_SPAN_GCC_CONSTEXPR Span Last(
+ index_type aCount) const
+ {
+ MOZ_RELEASE_ASSERT(aCount <= size());
+ return { data() + (size() - aCount), aCount };
+ }
+
+ /**
+ * Subspan with run-time start index and length.
+ */
+ MOZ_SPAN_GCC_CONSTEXPR Span Subspan(
+ index_type aStart,
+ index_type aLength = dynamic_extent) const
+ {
+ MOZ_RELEASE_ASSERT(aStart <= size() &&
+ (aLength == dynamic_extent ||
+ (aStart + aLength <= size())));
+ return { data() + aStart,
+ aLength == dynamic_extent ? size() - aStart : aLength };
+ }
+
+ /**
+ * Subspan with run-time start index. (Rust's &foo[start..])
+ */
+ MOZ_SPAN_GCC_CONSTEXPR Span From(
+ index_type aStart) const
+ {
+ return Subspan(aStart);
+ }
+
+ /**
+ * Subspan with run-time exclusive end index. (Rust's &foo[..end])
+ */
+ MOZ_SPAN_GCC_CONSTEXPR Span To(
+ index_type aEnd) const
+ {
+ return Subspan(0, aEnd);
+ }
+
+ /**
+ * Subspan with run-time start index and exclusive end index.
+ * (Rust's &foo[start..end])
+ */
+ MOZ_SPAN_GCC_CONSTEXPR Span FromTo(
+ index_type aStart,
+ index_type aEnd) const
+ {
+ MOZ_RELEASE_ASSERT(aStart <= aEnd);
+ return Subspan(aStart, aEnd - aStart);
+ }
+
+ // [Span.obs], Span observers
+ /**
+ * Number of elements in the span.
+ */
+ constexpr index_type Length() const { return size(); }
+
+ /**
+ * Number of elements in the span (standard-libray duck typing version).
+ */
+ constexpr index_type size() const { return storage_.size(); }
+
+ /**
+ * Size of the span in bytes.
+ */
+ constexpr index_type LengthBytes() const { return size_bytes(); }
+
+ /**
+ * Size of the span in bytes (standard-library naming style version).
+ */
+ constexpr index_type size_bytes() const
+ {
+ return size() * narrow_cast(sizeof(element_type));
+ }
+
+ /**
+ * Checks if the the length of the span is zero.
+ */
+ constexpr bool IsEmpty() const { return empty(); }
+
+ /**
+ * Checks if the the length of the span is zero (standard-libray duck
+ * typing version).
+ */
+ constexpr bool empty() const { return size() == 0; }
+
+ // [Span.elem], Span element access
+ MOZ_SPAN_GCC_CONSTEXPR reference operator[](index_type idx) const
+ {
+ MOZ_RELEASE_ASSERT(idx < storage_.size());
+ return data()[idx];
+ }
+
+ /**
+ * Access element of span by index (standard-library duck typing version).
+ */
+ constexpr reference at(index_type idx) const { return this->operator[](idx); }
+
+ constexpr reference operator()(index_type idx) const
+ {
+ return this->operator[](idx);
+ }
+
+ /**
+ * Pointer to the first element of the span.
+ */
+ constexpr pointer Elements() const { return data(); }
+
+ /**
+ * Pointer to the first element of the span (standard-libray duck typing version).
+ */
+ constexpr pointer data() const { return storage_.data(); }
+
+ // [Span.iter], Span iterator support
+ iterator begin() const { return { this, 0 }; }
+ iterator end() const { return { this, Length() }; }
+
+ const_iterator cbegin() const { return { this, 0 }; }
+ const_iterator cend() const { return { this, Length() }; }
+
+ reverse_iterator rbegin() const
+ {
+ return reverse_iterator{ end() };
+ }
+ reverse_iterator rend() const
+ {
+ return reverse_iterator{ begin() };
+ }
+
+ const_reverse_iterator crbegin() const
+ {
+ return const_reverse_iterator{ cend() };
+ }
+ const_reverse_iterator crend() const
+ {
+ return const_reverse_iterator{ cbegin() };
+ }
+
+private:
+ // this implementation detail class lets us take advantage of the
+ // empty base class optimization to pay for only storage of a single
+ // pointer in the case of fixed-size Spans
+ template
+ class storage_type : public ExtentType
+ {
+ public:
+ template
+ MOZ_SPAN_ASSERTION_CONSTEXPR storage_type(pointer elements,
+ OtherExtentType ext)
+ : ExtentType(ext)
+ , data_(elements)
+ {
+ MOZ_RELEASE_ASSERT(
+ (!elements && ExtentType::size() == 0) ||
+ (elements && ExtentType::size() != mozilla::MaxValue::value));
+ }
+
+ constexpr pointer data() const { return data_; }
+
+ private:
+ pointer data_;
+ };
+
+ storage_type> storage_;
+};
+
+// [Span.comparison], Span comparison operators
+template
+inline constexpr bool
+operator==(const Span& l,
+ const Span& r)
+{
+ return (l.size() == r.size()) && std::equal(l.begin(), l.end(), r.begin());
+}
+
+template
+inline constexpr bool
+operator!=(const Span& l,
+ const Span& r)
+{
+ return !(l == r);
+}
+
+template
+inline constexpr bool
+operator<(const Span& l,
+ const Span& r)
+{
+ return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template
+inline constexpr bool
+operator<=(const Span& l,
+ const Span& r)
+{
+ return !(l > r);
+}
+
+template
+inline constexpr bool
+operator>(const Span& l,
+ const Span& r)
+{
+ return r < l;
+}
+
+template
+inline constexpr bool
+operator>=(const Span& l,
+ const Span& r)
+{
+ return !(l < r);
+}
+
+namespace span_details {
+// if we only supported compilers with good constexpr support then
+// this pair of classes could collapse down to a constexpr function
+
+// we should use a narrow_cast<> to go to size_t, but older compilers may not see it as
+// constexpr
+// and so will fail compilation of the template
+template
+struct calculate_byte_size
+ : mozilla::IntegralConstant(sizeof(ElementType) *
+ static_cast(Extent))>
+{
+};
+
+template
+struct calculate_byte_size
+ : mozilla::IntegralConstant
+{
+};
+}
+
+// [Span.objectrep], views of object representation
+/**
+ * View span as Span.
+ */
+template
+Span::value>
+AsBytes(Span s)
+{
+ return { reinterpret_cast(s.data()), s.size_bytes() };
+}
+
+/**
+ * View span as Span.
+ */
+template::value>>
+Span::value>
+AsWritableBytes(Span s)
+{
+ return { reinterpret_cast(s.data()), s.size_bytes() };
+}
+
+//
+// MakeSpan() - Utility functions for creating Spans
+//
+/**
+ * Create span from pointer and length.
+ */
+template
+Span
+MakeSpan(ElementType* aPtr, typename Span::index_type aLength)
+{
+ return Span(aPtr, aLength);
+}
+
+/**
+ * Create span from start pointer and pointer past end.
+ */
+template
+Span
+MakeSpan(ElementType* aStartPtr, ElementType* aEndPtr)
+{
+ return Span(aStartPtr, aEndPtr);
+}
+
+/**
+ * Create span from C array.
+ */
+template
+Span MakeSpan(ElementType (&aArr)[N])
+{
+ return Span(aArr);
+}
+
+/**
+ * Create span from mozilla::Array.
+ */
+template
+Span
+MakeSpan(mozilla::Array& aArr)
+{
+ return aArr;
+}
+
+/**
+ * Create span from const mozilla::Array.
+ */
+template
+Span
+MakeSpan(const mozilla::Array& arr)
+{
+ return arr;
+}
+
+/**
+ * Create span from standard-library container.
+ */
+template
+Span
+MakeSpan(Container& cont)
+{
+ return Span(cont);
+}
+
+/**
+ * Create span from standard-library container (const version).
+ */
+template
+Span
+MakeSpan(const Container& cont)
+{
+ return Span(cont);
+}
+
+/**
+ * Create span from smart pointer and length.
+ */
+template
+Span
+MakeSpan(Ptr& aPtr, size_t aLength)
+{
+ return Span(aPtr, aLength);
+}
+
+/**
+ * Create span from C string.
+ */
+inline Span
+MakeCStringSpan(const char* aStr)
+{
+ return Span(aStr, std::strlen(aStr));
+}
+
+} // namespace mozilla
+
+#ifdef _MSC_VER
+#if _MSC_VER < 1910
+#undef constexpr
+#pragma pop_macro("constexpr")
+
+#endif // _MSC_VER < 1910
+
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#undef MOZ_SPAN_ASSERTION_CONSTEXPR
+#undef MOZ_SPAN_GCC_CONSTEXPR
+#undef MOZ_SPAN_EXPLICITLY_DEFAULTED_CONSTEXPR
+#undef MOZ_SPAN_CONSTEXPR_NOT_JUST_RETURN
+#undef MOZ_SPAN_NON_CONST_CONSTEXPR
+
+#endif // mozilla_Span_h
diff --git a/mfbt/moz.build b/mfbt/moz.build
index f7bee9161558..1a69edf14a0c 100644
--- a/mfbt/moz.build
+++ b/mfbt/moz.build
@@ -82,6 +82,7 @@ EXPORTS.mozilla = [
'SegmentedVector.h',
'SHA1.h',
'SizePrintfMacros.h',
+ 'Span.h',
'SplayTree.h',
'Sprintf.h',
'StaticAnalysisFunctions.h',
diff --git a/mfbt/tests/gtest/TestSpan.cpp b/mfbt/tests/gtest/TestSpan.cpp
new file mode 100644
index 000000000000..f3aa000a438e
--- /dev/null
+++ b/mfbt/tests/gtest/TestSpan.cpp
@@ -0,0 +1,2079 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// Adapted from https://github.com/Microsoft/GSL/blob/3819df6e378ffccf0e29465afe99c3b324c2aa70/tests/Span_tests.cpp
+
+#include "gtest/gtest.h"
+
+#include "mozilla/Span.h"
+
+#include "nsString.h"
+#include "nsTArray.h"
+#include "mozilla/Range.h"
+#include "mozilla/TypeTraits.h"
+
+#define SPAN_TEST(name) TEST(SpanTest, name)
+#define CHECK_THROW(a, b)
+
+using namespace std;
+using namespace mozilla;
+
+static_assert(IsConvertible, Span>::value,
+ "Range should convert into const");
+static_assert(IsConvertible, Span>::value,
+ "const Range should convert into const");
+static_assert(!IsConvertible, Span>::value,
+ "Range should not drop const in conversion");
+static_assert(IsConvertible, Range>::value,
+ "Span should convert into const");
+static_assert(IsConvertible, Range>::value,
+ "const Span should convert into const");
+static_assert(!IsConvertible, Range>::value,
+ "Span should not drop const in conversion");
+static_assert(IsConvertible, Span>::value,
+ "const Span should convert into const");
+static_assert(IsConvertible, Span>::value,
+ "Span should convert into const");
+static_assert(!IsConvertible, Span>::value,
+ "Span should not drop const in conversion");
+static_assert(IsConvertible, Span>::value,
+ "const nsTArray should convert into const");
+static_assert(IsConvertible, Span>::value,
+ "nsTArray should convert into const");
+static_assert(!IsConvertible, Span>::value,
+ "nsTArray should not drop const in conversion");
+static_assert(IsConvertible, Span>::value,
+ "nsTArray should convert into const");
+static_assert(!IsConvertible, Span>::value,
+ "nsTArray should not drop const in conversion");
+
+namespace {
+struct BaseClass
+{
+};
+struct DerivedClass : BaseClass
+{
+};
+}
+
+void
+AssertSpanOfThreeInts(Span s)
+{
+ ASSERT_EQ(s.size(), 3U);
+ ASSERT_EQ(s[0], 1);
+ ASSERT_EQ(s[1], 2);
+ ASSERT_EQ(s[2], 3);
+}
+
+void
+AssertSpanOfThreeChars(Span s)
+{
+ ASSERT_EQ(s.size(), 3U);
+ ASSERT_EQ(s[0], 'a');
+ ASSERT_EQ(s[1], 'b');
+ ASSERT_EQ(s[2], 'c');
+}
+
+void
+AssertSpanOfThreeChar16s(Span s)
+{
+ ASSERT_EQ(s.size(), 3U);
+ ASSERT_EQ(s[0], 'a');
+ ASSERT_EQ(s[1], 'b');
+ ASSERT_EQ(s[2], 'c');
+}
+
+void
+AssertSpanOfThreeCharsViaString(const nsACString& aStr)
+{
+ AssertSpanOfThreeChars(aStr);
+}
+
+void
+AssertSpanOfThreeChar16sViaString(const nsAString& aStr)
+{
+ AssertSpanOfThreeChar16s(aStr);
+}
+
+SPAN_TEST(default_constructor)
+{
+ {
+ Span s;
+ ASSERT_EQ(s.Length(), 0U);
+ ASSERT_EQ(s.data(), nullptr);
+
+ Span cs;
+ ASSERT_EQ(cs.Length(), 0U);
+ ASSERT_EQ(cs.data(), nullptr);
+ }
+
+ {
+ Span s;
+ ASSERT_EQ(s.Length(), 0U);
+ ASSERT_EQ(s.data(), nullptr);
+
+ Span cs;
+ ASSERT_EQ(cs.Length(), 0U);
+ ASSERT_EQ(cs.data(), nullptr);
+ }
+
+ {
+#ifdef CONFIRM_COMPILATION_ERRORS
+ Span s;
+ ASSERT_EQ(s.Length(), 1U);
+ ASSERT_EQ(s.data(), nullptr); // explains why it can't compile
+#endif
+ }
+
+ {
+ Span