--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -2604,17 +2604,18 @@ Element::SetAttr(int32_t aNamespaceID, n
// out to id-observers
nsIDocument* document = GetComposedDoc();
mozAutoDocUpdate updateBatch(document, UPDATE_CONTENT_MODEL, aNotify);
nsresult rv = BeforeSetAttr(aNamespaceID, aName, &value, aNotify);
NS_ENSURE_SUCCESS(rv, rv);
if (!preparsedAttrValue &&
- !ParseAttribute(aNamespaceID, aName, aValue, attrValue)) {
+ !ParseAttribute(aNamespaceID, aName, aValue, aSubjectPrincipal,
+ attrValue)) {
attrValue.SetTo(aValue);
}
PreIdMaybeChange(aNamespaceID, aName, &value);
return SetAttrAndNotify(aNamespaceID, aName, aPrefix,
oldValueSet ? &oldValue : nullptr,
attrValue, aSubjectPrincipal, modType,
@@ -2821,16 +2822,17 @@ Element::SetAttrAndNotify(int32_t aNames
return NS_OK;
}
bool
Element::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aAttribute == nsGkAtoms::lang) {
aResult.ParseAtom(aValue);
return true;
}
if (aNamespaceID == kNameSpaceID_None) {
--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -1538,22 +1538,25 @@ protected:
/**
* Convert an attribute string value to attribute type based on the type of
* attribute. Called by SetAttr(). Note that at the moment we only do this
* for attributes in the null namespace (kNameSpaceID_None).
*
* @param aNamespaceID the namespace of the attribute to convert
* @param aAttribute the attribute to convert
* @param aValue the string value to convert
+ * @param aMaybeScriptedPrincipal the principal of the script setting the
+ * attribute, if one can be determined, or null otherwise
* @param aResult the nsAttrValue [OUT]
* @return true if the parsing was successful, false otherwise
*/
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult);
/**
* Try to set the attribute as a mapped attribute, if applicable. This will
* only be called for attributes that are in the null namespace and only on
* attributes that returned true when passed to IsAttributeMapped. The
* caller will not try to set the attr in any other way if this method
* returns true (the value of aRetval does not matter for that purpose).
--- a/dom/base/nsStyledElement.cpp
+++ b/dom/base/nsStyledElement.cpp
@@ -34,25 +34,26 @@ NS_IMPL_QUERY_INTERFACE_CYCLE_COLLECTION
//----------------------------------------------------------------------
// nsIContent methods
bool
nsStyledElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aAttribute == nsGkAtoms::style && aNamespaceID == kNameSpaceID_None) {
ParseStyleAttribute(aValue, aResult, false);
return true;
}
return nsStyledElementBase::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
nsresult
nsStyledElement::BeforeSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValueOrString* aValue, bool aNotify)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::style) {
--- a/dom/base/nsStyledElement.h
+++ b/dom/base/nsStyledElement.h
@@ -63,17 +63,19 @@ protected:
* @param aValue the value to parse
* @param aResult the resulting HTMLValue [OUT]
*/
void ParseStyleAttribute(const nsAString& aValue,
nsAttrValue& aResult,
bool aForceInDataDoc);
virtual bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
- const nsAString& aValue, nsAttrValue& aResult) override;
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult) override;
friend class mozilla::dom::Element;
/**
* Create the style struct from the style attr. Used when an element is
* first put into a document. Only has an effect if the old value is a
* string. If aForceInDataDoc is true, will reparse even if we're in a data
* document. If aForceIfAlreadyParsed is set, this will always reparse even
--- a/dom/html/HTMLBRElement.cpp
+++ b/dom/html/HTMLBRElement.cpp
@@ -35,24 +35,25 @@ static const nsAttrValue::EnumTable kCle
{ "both", StyleClear::Both },
{ nullptr, 0 }
};
bool
HTMLBRElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aAttribute == nsGkAtoms::clear && aNamespaceID == kNameSpaceID_None) {
return aResult.ParseEnumValue(aValue, kClearTable, false);
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLBRElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(Display))) {
if (!aData->PropertyIsSet(eCSSProperty_clear)) {
--- a/dom/html/HTMLBRElement.h
+++ b/dom/html/HTMLBRElement.h
@@ -17,16 +17,17 @@ namespace dom {
class HTMLBRElement final : public nsGenericHTMLElement
{
public:
explicit HTMLBRElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
bool Clear()
{
--- a/dom/html/HTMLBodyElement.cpp
+++ b/dom/html/HTMLBodyElement.cpp
@@ -41,16 +41,17 @@ HTMLBodyElement::WrapNode(JSContext *aCx
NS_IMPL_ISUPPORTS_INHERITED0(HTMLBodyElement, nsGenericHTMLElement)
NS_IMPL_ELEMENT_CLONE(HTMLBodyElement)
bool
HTMLBodyElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::bgcolor ||
aAttribute == nsGkAtoms::text ||
aAttribute == nsGkAtoms::link ||
aAttribute == nsGkAtoms::alink ||
aAttribute == nsGkAtoms::vlink) {
@@ -65,17 +66,17 @@ HTMLBodyElement::ParseAttribute(int32_t
return aResult.ParseIntWithBounds(aValue, 0);
}
}
return nsGenericHTMLElement::ParseBackgroundAttribute(aNamespaceID,
aAttribute, aValue,
aResult) ||
nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLBodyElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->mSIDs & NS_STYLE_INHERIT_BIT(Margin)) {
--- a/dom/html/HTMLBodyElement.h
+++ b/dom/html/HTMLBodyElement.h
@@ -121,16 +121,17 @@ public:
void SetBackground(const nsAString& aBackground, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::background, aBackground, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual already_AddRefed<TextEditor> GetAssociatedEditor() override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
virtual bool IsEventAttributeNameInternal(nsAtom* aName) override;
--- a/dom/html/HTMLButtonElement.cpp
+++ b/dom/html/HTMLButtonElement.cpp
@@ -150,16 +150,17 @@ HTMLButtonElement::IsHTMLFocusable(bool
return false;
}
bool
HTMLButtonElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, kButtonTypeTable, false,
kButtonDefaultType);
}
@@ -167,17 +168,17 @@ HTMLButtonElement::ParseAttribute(int32_
return aResult.ParseEnumValue(aValue, kFormMethodTable, false);
}
if (aAttribute == nsGkAtoms::formenctype) {
return aResult.ParseEnumValue(aValue, kFormEnctypeTable, false);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
bool
HTMLButtonElement::IsDisabledForEvents(EventMessage aMessage)
{
nsIFormControlFrame* formControlFrame = GetFormControlFrame(false);
nsIFrame* formFrame = do_QueryFrame(formControlFrame);
return IsElementDisabledForEvents(aMessage, formFrame);
--- a/dom/html/HTMLButtonElement.h
+++ b/dom/html/HTMLButtonElement.h
@@ -84,16 +84,17 @@ public:
virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValue* aValue,
const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
// nsGenericHTMLElement
virtual bool IsHTMLFocusable(bool aWithMouse,
bool* aIsFocusable,
int32_t* aTabIndex) override;
// WebIDL
--- a/dom/html/HTMLCanvasElement.cpp
+++ b/dom/html/HTMLCanvasElement.cpp
@@ -637,25 +637,26 @@ HTMLCanvasElement::GetAttributeChangeHin
}
return retval;
}
bool
HTMLCanvasElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None &&
(aAttribute == nsGkAtoms::width || aAttribute == nsGkAtoms::height)) {
return aResult.ParseNonNegativeIntValue(aValue);
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLCanvasElement::ToDataURL(JSContext* aCx, const nsAString& aType,
JS::Handle<JS::Value> aParams,
nsAString& aDataURL,
--- a/dom/html/HTMLCanvasElement.h
+++ b/dom/html/HTMLCanvasElement.h
@@ -285,16 +285,17 @@ public:
* FrameCaptureListeners having requested frame capture.
*/
void SetFrameCapture(already_AddRefed<gfx::SourceSurface> aSurface,
const TimeStamp& aTime);
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute, int32_t aModType) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
nsresult CopyInnerTo(mozilla::dom::Element* aDest,
bool aPreallocateChildren);
--- a/dom/html/HTMLDivElement.cpp
+++ b/dom/html/HTMLDivElement.cpp
@@ -26,16 +26,17 @@ HTMLDivElement::WrapNode(JSContext *aCx,
{
return dom::HTMLDivElementBinding::Wrap(aCx, this, aGivenProto);
}
bool
HTMLDivElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (mNodeInfo->Equals(nsGkAtoms::marquee)) {
if ((aAttribute == nsGkAtoms::width) ||
(aAttribute == nsGkAtoms::height)) {
return aResult.ParseSpecialIntValue(aValue);
}
@@ -50,17 +51,17 @@ HTMLDivElement::ParseAttribute(int32_t a
if (mNodeInfo->Equals(nsGkAtoms::div) &&
aAttribute == nsGkAtoms::align) {
return ParseDivAlignValue(aValue, aResult);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLDivElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
nsGenericHTMLElement::MapDivAlignAttributeInto(aAttributes, aData);
nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aData);
--- a/dom/html/HTMLDivElement.h
+++ b/dom/html/HTMLDivElement.h
@@ -27,16 +27,17 @@ public:
void SetAlign(const nsAString& aAlign, mozilla::ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::align, aAlign, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
protected:
virtual ~HTMLDivElement();
--- a/dom/html/HTMLEmbedElement.cpp
+++ b/dom/html/HTMLEmbedElement.cpp
@@ -216,29 +216,30 @@ HTMLEmbedElement::TabIndexDefault()
{
return -1;
}
bool
HTMLEmbedElement::ParseAttribute(int32_t aNamespaceID,
nsAtom *aAttribute,
const nsAString &aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue &aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::align) {
return ParseAlignValue(aValue, aResult);
}
if (ParseImageAttribute(aAttribute, aValue, aResult)) {
return true;
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
static void
MapAttributesIntoRuleBase(const nsMappedAttributes *aAttributes,
GenericSpecifiedValues* aData)
{
nsGenericHTMLElement::MapImageBorderAttributeInto(aAttributes, aData);
nsGenericHTMLElement::MapImageMarginAttributeInto(aAttributes, aData);
--- a/dom/html/HTMLEmbedElement.h
+++ b/dom/html/HTMLEmbedElement.h
@@ -43,16 +43,17 @@ public:
bool aNullParent = true) override;
virtual bool IsHTMLFocusable(bool aWithMouse, bool *aIsFocusable, int32_t *aTabIndex) override;
virtual IMEState GetDesiredIMEState() override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom *aAttribute,
const nsAString &aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue &aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom *aAttribute) const override;
virtual EventStates IntrinsicState() const override;
virtual void DestroyContent() override;
// nsObjectLoadingContent
virtual uint32_t GetCapabilities() const override;
--- a/dom/html/HTMLFontElement.cpp
+++ b/dom/html/HTMLFontElement.cpp
@@ -28,16 +28,17 @@ HTMLFontElement::WrapNode(JSContext *aCx
}
NS_IMPL_ELEMENT_CLONE(HTMLFontElement)
bool
HTMLFontElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::size) {
int32_t size = nsContentUtils::ParseLegacyFontSize(aValue);
if (size) {
aResult.SetTo(size, &aValue);
return true;
@@ -45,17 +46,17 @@ HTMLFontElement::ParseAttribute(int32_t
return false;
}
if (aAttribute == nsGkAtoms::color) {
return aResult.ParseColor(aValue);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLFontElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(Font))) {
// face: string list
--- a/dom/html/HTMLFontElement.h
+++ b/dom/html/HTMLFontElement.h
@@ -43,16 +43,17 @@ public:
void SetSize(const nsAString& aSize, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::size, aSize, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
protected:
virtual ~HTMLFontElement();
--- a/dom/html/HTMLFormElement.cpp
+++ b/dom/html/HTMLFormElement.cpp
@@ -282,32 +282,33 @@ HTMLFormElement::CheckValidity(bool* ret
*retVal = CheckValidity();
return NS_OK;
}
bool
HTMLFormElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::method) {
return aResult.ParseEnumValue(aValue, kFormMethodTable, false);
}
if (aAttribute == nsGkAtoms::enctype) {
return aResult.ParseEnumValue(aValue, kFormEnctypeTable, false);
}
if (aAttribute == nsGkAtoms::autocomplete) {
return aResult.ParseEnumValue(aValue, kFormAutocompleteTable, false);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
nsresult
HTMLFormElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers)
{
nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent,
--- a/dom/html/HTMLFormElement.h
+++ b/dom/html/HTMLFormElement.h
@@ -89,16 +89,17 @@ public:
// EventTarget
virtual void AsyncEventRunning(AsyncEventDispatcher* aEvent) override;
// nsIContent
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult GetEventTargetParent(
EventChainPreVisitor& aVisitor) override;
virtual nsresult WillHandleEvent(
EventChainPostVisitor& aVisitor) override;
virtual nsresult PostHandleEvent(
EventChainPostVisitor& aVisitor) override;
--- a/dom/html/HTMLFrameElement.cpp
+++ b/dom/html/HTMLFrameElement.cpp
@@ -28,16 +28,17 @@ HTMLFrameElement::~HTMLFrameElement()
NS_IMPL_ISUPPORTS_INHERITED0(HTMLFrameElement, nsGenericHTMLFrameElement)
NS_IMPL_ELEMENT_CLONE(HTMLFrameElement)
bool
HTMLFrameElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::bordercolor) {
return aResult.ParseColor(aValue);
}
if (aAttribute == nsGkAtoms::frameborder) {
return ParseFrameborderValue(aValue, aResult);
@@ -49,17 +50,17 @@ HTMLFrameElement::ParseAttribute(int32_t
return aResult.ParseSpecialIntValue(aValue);
}
if (aAttribute == nsGkAtoms::scrolling) {
return ParseScrollingValue(aValue, aResult);
}
}
return nsGenericHTMLFrameElement::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue, aMaybeScriptedPrincipal, aResult);
}
JSObject*
HTMLFrameElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return HTMLFrameElementBinding::Wrap(aCx, this, aGivenProto);
}
--- a/dom/html/HTMLFrameElement.h
+++ b/dom/html/HTMLFrameElement.h
@@ -26,16 +26,17 @@ public:
NS_DECL_ISUPPORTS_INHERITED
NS_IMPL_FROMCONTENT_HTML_WITH_TAG(HTMLFrameElement, frame)
// nsIContent
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// WebIDL API
void GetFrameBorder(DOMString& aFrameBorder) const
{
GetHTMLAttr(nsGkAtoms::frameborder, aFrameBorder);
--- a/dom/html/HTMLFrameSetElement.cpp
+++ b/dom/html/HTMLFrameSetElement.cpp
@@ -132,32 +132,33 @@ HTMLFrameSetElement::GetColSpec(int32_t
return NS_OK;
}
bool
HTMLFrameSetElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::bordercolor) {
return aResult.ParseColor(aValue);
}
if (aAttribute == nsGkAtoms::frameborder) {
return nsGenericHTMLElement::ParseFrameborderValue(aValue, aResult);
}
if (aAttribute == nsGkAtoms::border) {
return aResult.ParseIntWithBounds(aValue, 0, 100);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
nsChangeHint
HTMLFrameSetElement::GetAttributeChangeHint(const nsAtom* aAttribute,
int32_t aModType) const
{
nsChangeHint retval =
nsGenericHTMLElement::GetAttributeChangeHint(aAttribute, aModType);
--- a/dom/html/HTMLFrameSetElement.h
+++ b/dom/html/HTMLFrameSetElement.h
@@ -111,16 +111,17 @@ public:
implementation. DO NOT DELETE IT.
*/
nsresult GetColSpec(int32_t *aNumValues, const nsFramesetSpec** aSpecs);
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
int32_t aModType) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
protected:
--- a/dom/html/HTMLHRElement.cpp
+++ b/dom/html/HTMLHRElement.cpp
@@ -25,16 +25,17 @@ NS_IMPL_ISUPPORTS_INHERITED0(HTMLHREleme
NS_IMPL_ELEMENT_CLONE(HTMLHRElement)
bool
HTMLHRElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
static const nsAttrValue::EnumTable kAlignTable[] = {
{ "left", NS_STYLE_TEXT_ALIGN_LEFT },
{ "right", NS_STYLE_TEXT_ALIGN_RIGHT },
{ "center", NS_STYLE_TEXT_ALIGN_CENTER },
{ nullptr, 0 }
};
@@ -50,17 +51,17 @@ HTMLHRElement::ParseAttribute(int32_t aN
return aResult.ParseEnumValue(aValue, kAlignTable, false);
}
if (aAttribute == nsGkAtoms::color) {
return aResult.ParseColor(aValue);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLHRElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
bool noshade = false;
--- a/dom/html/HTMLHRElement.h
+++ b/dom/html/HTMLHRElement.h
@@ -22,16 +22,17 @@ public:
explicit HTMLHRElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
// nsISupports
NS_DECL_ISUPPORTS_INHERITED
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// WebIDL API
void GetAlign(nsAString& aValue) const
--- a/dom/html/HTMLHeadingElement.cpp
+++ b/dom/html/HTMLHeadingElement.cpp
@@ -29,24 +29,25 @@ HTMLHeadingElement::WrapNode(JSContext *
{
return HTMLHeadingElementBinding::Wrap(aCx, this, aGivenProto);
}
bool
HTMLHeadingElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aAttribute == nsGkAtoms::align && aNamespaceID == kNameSpaceID_None) {
return ParseDivAlignValue(aValue, aResult);
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLHeadingElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
nsGenericHTMLElement::MapDivAlignAttributeInto(aAttributes, aData);
nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aData);
--- a/dom/html/HTMLHeadingElement.h
+++ b/dom/html/HTMLHeadingElement.h
@@ -19,16 +19,17 @@ public:
explicit HTMLHeadingElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: nsGenericHTMLElement(aNodeInfo)
{
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
void SetAlign(const nsAString& aAlign, ErrorResult& aError)
{
--- a/dom/html/HTMLIFrameElement.cpp
+++ b/dom/html/HTMLIFrameElement.cpp
@@ -40,16 +40,17 @@ HTMLIFrameElement::~HTMLIFrameElement()
NS_IMPL_ISUPPORTS_INHERITED0(HTMLIFrameElement, nsGenericHTMLFrameElement)
NS_IMPL_ELEMENT_CLONE(HTMLIFrameElement)
bool
HTMLIFrameElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::marginwidth) {
return aResult.ParseSpecialIntValue(aValue);
}
if (aAttribute == nsGkAtoms::marginheight) {
return aResult.ParseSpecialIntValue(aValue);
@@ -71,17 +72,19 @@ HTMLIFrameElement::ParseAttribute(int32_
}
if (aAttribute == nsGkAtoms::sandbox) {
aResult.ParseAtomArray(aValue);
return true;
}
}
return nsGenericHTMLFrameElement::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
}
void
HTMLIFrameElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(Border))) {
// frameborder: 0 | 1 (| NO | YES in quirks mode)
--- a/dom/html/HTMLIFrameElement.h
+++ b/dom/html/HTMLIFrameElement.h
@@ -30,16 +30,17 @@ public:
{
return true;
}
// nsIContent
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
uint32_t GetSandboxFlags();
--- a/dom/html/HTMLImageElement.cpp
+++ b/dom/html/HTMLImageElement.cpp
@@ -220,33 +220,34 @@ HTMLImageElement::Y()
{
return GetXY().y;
}
bool
HTMLImageElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::align) {
return ParseAlignValue(aValue, aResult);
}
if (aAttribute == nsGkAtoms::crossorigin) {
ParseCORSValue(aValue, aResult);
return true;
}
if (ParseImageAttribute(aAttribute, aValue, aResult)) {
return true;
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLImageElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
nsGenericHTMLElement::MapImageAlignAttributeInto(aAttributes, aData);
nsGenericHTMLElement::MapImageBorderAttributeInto(aAttributes, aData);
--- a/dom/html/HTMLImageElement.h
+++ b/dom/html/HTMLImageElement.h
@@ -53,16 +53,17 @@ public:
// override from nsImageLoadingContent
CORSMode GetCORSMode() override;
// nsIContent
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
int32_t aModType) const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult GetEventTargetParent(
EventChainPreVisitor& aVisitor) override;
--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -5749,16 +5749,17 @@ HTMLInputElement::IsInputColorEnabled()
return sInputColorEnabled;
}
bool
HTMLInputElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
// We can't make these static_asserts because kInputDefaultType and
// kInputTypeTable aren't constexpr.
MOZ_ASSERT(kInputDefaultType->value == NS_FORM_INPUT_TEXT,
"Someone forgot to update kInputDefaultType when adding a new "
"input type.");
MOZ_ASSERT(kInputTypeTable[ArrayLength(kInputTypeTable) - 1].tag == nullptr,
@@ -5821,17 +5822,17 @@ HTMLInputElement::ParseAttribute(int32_t
// don't know if we're going to have a type="image" attribute yet,
// (or could have it set dynamically in the future). See bug
// 214077.
return true;
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLInputElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::type);
if (value && value->Type() == nsAttrValue::eEnum &&
--- a/dom/html/HTMLInputElement.h
+++ b/dom/html/HTMLInputElement.h
@@ -190,16 +190,17 @@ public:
virtual void FieldSetDisabledChanged(bool aNotify) override;
// nsIContent
virtual bool IsHTMLFocusable(bool aWithMouse, bool *aIsFocusable, int32_t *aTabIndex) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
int32_t aModType) const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult GetEventTargetParent(
EventChainPreVisitor& aVisitor) override;
--- a/dom/html/HTMLLIElement.cpp
+++ b/dom/html/HTMLLIElement.cpp
@@ -44,31 +44,32 @@ static const nsAttrValue::EnumTable kOrd
{ "1", NS_STYLE_LIST_STYLE_DECIMAL },
{ nullptr, 0 }
};
bool
HTMLLIElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, kOrderedListItemTypeTable,
true) ||
aResult.ParseEnumValue(aValue, kUnorderedListItemTypeTable, false);
}
if (aAttribute == nsGkAtoms::value) {
return aResult.ParseIntValue(aValue);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLLIElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(List))) {
if (!aData->PropertyIsSet(eCSSProperty_list_style_type)) {
--- a/dom/html/HTMLLIElement.h
+++ b/dom/html/HTMLLIElement.h
@@ -23,16 +23,17 @@ public:
}
// nsISupports
NS_DECL_ISUPPORTS_INHERITED
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// WebIDL API
void GetType(DOMString& aType)
--- a/dom/html/HTMLLegendElement.cpp
+++ b/dom/html/HTMLLegendElement.cpp
@@ -33,16 +33,17 @@ HTMLLegendElement::GetFieldSet() const
return nullptr;
}
bool
HTMLLegendElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
// this contains center, because IE4 does
static const nsAttrValue::EnumTable kAlignTable[] = {
{ "left", NS_STYLE_TEXT_ALIGN_LEFT },
{ "right", NS_STYLE_TEXT_ALIGN_RIGHT },
{ "center", NS_STYLE_TEXT_ALIGN_CENTER },
{ "bottom", NS_STYLE_VERTICAL_ALIGN_BOTTOM },
@@ -50,17 +51,17 @@ HTMLLegendElement::ParseAttribute(int32_
{ nullptr, 0 }
};
if (aAttribute == nsGkAtoms::align && aNamespaceID == kNameSpaceID_None) {
return aResult.ParseEnumValue(aValue, kAlignTable, false);
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
nsChangeHint
HTMLLegendElement::GetAttributeChangeHint(const nsAtom* aAttribute,
int32_t aModType) const
{
nsChangeHint retval =
nsGenericHTMLElement::GetAttributeChangeHint(aAttribute, aModType);
--- a/dom/html/HTMLLegendElement.h
+++ b/dom/html/HTMLLegendElement.h
@@ -34,16 +34,17 @@ public:
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
virtual void UnbindFromTree(bool aDeep = true,
bool aNullParent = true) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
int32_t aModType) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo* aNodeInfo, nsINode** aResult,
bool aPreallocateChildren) const override;
Element* GetFormElement() const
--- a/dom/html/HTMLLinkElement.cpp
+++ b/dom/html/HTMLLinkElement.cpp
@@ -187,16 +187,17 @@ HTMLLinkElement::UnbindFromTree(bool aDe
UpdateStyleSheetInternal(oldDoc, oldShadowRoot);
}
bool
HTMLLinkElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::crossorigin) {
ParseCORSValue(aValue, aResult);
return true;
}
@@ -212,17 +213,17 @@ HTMLLinkElement::ParseAttribute(int32_t
if (aAttribute == nsGkAtoms::integrity) {
aResult.ParseStringOrAtom(aValue);
return true;
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLLinkElement::CreateAndDispatchEvent(nsIDocument* aDoc,
const nsAString& aEventName)
{
if (!aDoc)
return;
--- a/dom/html/HTMLLinkElement.h
+++ b/dom/html/HTMLLinkElement.h
@@ -64,16 +64,17 @@ public:
bool aNotify) override;
virtual bool IsLink(nsIURI** aURI) const override;
virtual already_AddRefed<nsIURI> GetHrefURI() const override;
// Element
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual void GetLinkTarget(nsAString& aTarget) override;
virtual EventStates IntrinsicState() const override;
void CreateAndDispatchEvent(nsIDocument* aDoc, const nsAString& aEventName);
virtual void OnDNSPrefetchDeferred() override;
virtual void OnDNSPrefetchRequested() override;
--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -4376,16 +4376,17 @@ HTMLMediaElement::OutputMediaStream::~Ou
for (auto pair : mTrackPorts) {
pair.second()->Destroy();
}
}
bool HTMLMediaElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
// Mappings from 'preload' attribute strings to an enumeration.
static const nsAttrValue::EnumTable kPreloadTable[] = {
{ "", HTMLMediaElement::PRELOAD_ATTR_EMPTY },
{ "none", HTMLMediaElement::PRELOAD_ATTR_NONE },
{ "metadata", HTMLMediaElement::PRELOAD_ATTR_METADATA },
{ "auto", HTMLMediaElement::PRELOAD_ATTR_AUTO },
@@ -4401,17 +4402,17 @@ bool HTMLMediaElement::ParseAttribute(in
return true;
}
if (aAttribute == nsGkAtoms::preload) {
return aResult.ParseEnumValue(aValue, kPreloadTable, false);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void HTMLMediaElement::DoneCreatingElement()
{
if (HasAttr(kNameSpaceID_None, nsGkAtoms::muted)) {
mMuted |= MUTED_BY_CONTENT;
}
}
--- a/dom/html/HTMLMediaElement.h
+++ b/dom/html/HTMLMediaElement.h
@@ -142,16 +142,17 @@ public:
// nsISupports
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLMediaElement,
nsGenericHTMLElement)
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
virtual void UnbindFromTree(bool aDeep = true,
bool aNullParent = true) override;
virtual void DoneCreatingElement() override;
--- a/dom/html/HTMLMenuElement.cpp
+++ b/dom/html/HTMLMenuElement.cpp
@@ -123,25 +123,26 @@ HTMLMenuElement::AfterSetAttr(int32_t aN
return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName, aValue,
aOldValue, aSubjectPrincipal, aNotify);
}
bool
HTMLMenuElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, kMenuTypeTable, false,
kMenuDefaultType);
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLMenuElement::BuildSubmenu(const nsAString& aLabel,
nsIContent* aContent,
nsIMenuBuilder* aBuilder)
{
aBuilder->OpenContainer(aLabel);
--- a/dom/html/HTMLMenuElement.h
+++ b/dom/html/HTMLMenuElement.h
@@ -28,16 +28,17 @@ public:
virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValue* aValue,
const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
uint8_t GetType() const { return mType; }
// WebIDL
--- a/dom/html/HTMLMenuItemElement.cpp
+++ b/dom/html/HTMLMenuItemElement.cpp
@@ -315,32 +315,33 @@ HTMLMenuItemElement::BindToTree(nsIDocum
return rv;
}
bool
HTMLMenuItemElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, kMenuItemTypeTable, false,
kMenuItemDefaultType);
}
if (aAttribute == nsGkAtoms::radiogroup) {
aResult.ParseAtom(aValue);
return true;
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLMenuItemElement::DoneCreatingElement()
{
mParserCreating = false;
if (mShouldInitChecked) {
--- a/dom/html/HTMLMenuItemElement.h
+++ b/dom/html/HTMLMenuItemElement.h
@@ -38,16 +38,17 @@ public:
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual void DoneCreatingElement() override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
uint8_t GetType() const { return mType; }
--- a/dom/html/HTMLMeterElement.cpp
+++ b/dom/html/HTMLMeterElement.cpp
@@ -35,29 +35,34 @@ HTMLMeterElement::IntrinsicState() const
EventStates state = nsGenericHTMLElement::IntrinsicState();
state |= GetOptimumState();
return state;
}
bool
-HTMLMeterElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
- const nsAString& aValue, nsAttrValue& aResult)
+HTMLMeterElement::ParseAttribute(int32_t aNamespaceID,
+ nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::value || aAttribute == nsGkAtoms::max ||
aAttribute == nsGkAtoms::min || aAttribute == nsGkAtoms::low ||
aAttribute == nsGkAtoms::high || aAttribute == nsGkAtoms::optimum) {
return aResult.ParseDoubleValue(aValue);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
}
/*
* Value getters :
* const getters used by XPCOM methods and by IntrinsicState
*/
double
--- a/dom/html/HTMLMeterElement.h
+++ b/dom/html/HTMLMeterElement.h
@@ -22,18 +22,20 @@ class HTMLMeterElement final : public ns
public:
explicit HTMLMeterElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
virtual EventStates IntrinsicState() const override;
nsresult Clone(mozilla::dom::NodeInfo* aNodeInfo, nsINode** aResult,
bool aPreallocateChildren) const override;
- bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
- const nsAString& aValue, nsAttrValue& aResult) override;
+ virtual bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult) override;
// WebIDL
/* @return the value */
double Value() const;
void SetValue(double aValue, ErrorResult& aRv)
{
SetDoubleAttr(nsGkAtoms::value, aValue, aRv);
--- a/dom/html/HTMLObjectElement.cpp
+++ b/dom/html/HTMLObjectElement.cpp
@@ -448,29 +448,30 @@ HTMLObjectElement::GetContentWindow(nsIP
return nullptr;
}
bool
HTMLObjectElement::ParseAttribute(int32_t aNamespaceID,
nsAtom *aAttribute,
const nsAString &aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue &aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::align) {
return ParseAlignValue(aValue, aResult);
}
if (ParseImageAttribute(aAttribute, aValue, aResult)) {
return true;
}
}
return nsGenericHTMLFormElement::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue, aMaybeScriptedPrincipal, aResult);
}
void
HTMLObjectElement::MapAttributesIntoRule(const nsMappedAttributes *aAttributes,
GenericSpecifiedValues *aData)
{
nsGenericHTMLFormElement::MapImageAlignAttributeInto(aAttributes, aData);
nsGenericHTMLFormElement::MapImageBorderAttributeInto(aAttributes, aData);
--- a/dom/html/HTMLObjectElement.h
+++ b/dom/html/HTMLObjectElement.h
@@ -65,16 +65,17 @@ public:
virtual bool IsDisabled() const override { return false; }
virtual void DoneAddingChildren(bool aHaveNotified) override;
virtual bool IsDoneAddingChildren() override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom *aAttribute,
const nsAString &aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue &aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom *aAttribute) const override;
virtual EventStates IntrinsicState() const override;
virtual void DestroyContent() override;
// nsObjectLoadingContent
virtual uint32_t GetCapabilities() const override;
--- a/dom/html/HTMLOutputElement.cpp
+++ b/dom/html/HTMLOutputElement.cpp
@@ -65,28 +65,33 @@ HTMLOutputElement::Reset()
NS_IMETHODIMP
HTMLOutputElement::SubmitNamesValues(HTMLFormSubmission* aFormSubmission)
{
// The output element is not submittable.
return NS_OK;
}
bool
-HTMLOutputElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
- const nsAString& aValue, nsAttrValue& aResult)
+HTMLOutputElement::ParseAttribute(int32_t aNamespaceID,
+ nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::_for) {
aResult.ParseAtomArray(aValue);
return true;
}
}
return nsGenericHTMLFormElement::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
}
void
HTMLOutputElement::DoneAddingChildren(bool aHaveNotified)
{
mIsDoneAddingChildren = true;
}
--- a/dom/html/HTMLOutputElement.h
+++ b/dom/html/HTMLOutputElement.h
@@ -34,18 +34,20 @@ public:
NS_IMETHOD Reset() override;
NS_IMETHOD SubmitNamesValues(HTMLFormSubmission* aFormSubmission) override;
virtual bool IsDisabled() const override { return false; }
nsresult Clone(mozilla::dom::NodeInfo* aNodeInfo, nsINode** aResult,
bool aPreallocateChildren) const override;
- bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
- const nsAString& aValue, nsAttrValue& aResult) override;
+ virtual bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult) override;
virtual void DoneAddingChildren(bool aHaveNotified) override;
EventStates IntrinsicState() const override;
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
--- a/dom/html/HTMLParagraphElement.cpp
+++ b/dom/html/HTMLParagraphElement.cpp
@@ -24,24 +24,25 @@ HTMLParagraphElement::~HTMLParagraphElem
NS_IMPL_ISUPPORTS_INHERITED0(HTMLParagraphElement, nsGenericHTMLElement)
NS_IMPL_ELEMENT_CLONE(HTMLParagraphElement)
bool
HTMLParagraphElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aAttribute == nsGkAtoms::align && aNamespaceID == kNameSpaceID_None) {
return ParseDivAlignValue(aValue, aResult);
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLParagraphElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
nsGenericHTMLElement::MapDivAlignAttributeInto(aAttributes, aData);
nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aData);
--- a/dom/html/HTMLParagraphElement.h
+++ b/dom/html/HTMLParagraphElement.h
@@ -23,16 +23,17 @@ public:
}
// nsISupports
NS_DECL_ISUPPORTS_INHERITED
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// WebIDL API
--- a/dom/html/HTMLPreElement.cpp
+++ b/dom/html/HTMLPreElement.cpp
@@ -25,26 +25,27 @@ HTMLPreElement::~HTMLPreElement()
NS_IMPL_ISUPPORTS_INHERITED0(HTMLPreElement, nsGenericHTMLElement)
NS_IMPL_ELEMENT_CLONE(HTMLPreElement)
bool
HTMLPreElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::width) {
return aResult.ParseIntValue(aValue);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLPreElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(Text))) {
if (!aData->PropertyIsSet(eCSSProperty_white_space)) {
--- a/dom/html/HTMLPreElement.h
+++ b/dom/html/HTMLPreElement.h
@@ -23,16 +23,17 @@ public:
}
// nsISupports
NS_DECL_ISUPPORTS_INHERITED
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// WebIDL API
--- a/dom/html/HTMLProgressElement.cpp
+++ b/dom/html/HTMLProgressElement.cpp
@@ -40,27 +40,32 @@ HTMLProgressElement::IntrinsicState() co
if (IsIndeterminate()) {
state |= NS_EVENT_STATE_INDETERMINATE;
}
return state;
}
bool
-HTMLProgressElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
- const nsAString& aValue, nsAttrValue& aResult)
+HTMLProgressElement::ParseAttribute(int32_t aNamespaceID,
+ nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::value || aAttribute == nsGkAtoms::max) {
return aResult.ParseDoubleValue(aValue);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
}
double
HTMLProgressElement::Value() const
{
const nsAttrValue* attrValue = mAttrsAndChildren.GetAttr(nsGkAtoms::value);
if (!attrValue || attrValue->Type() != nsAttrValue::eDoubleValue ||
attrValue->GetDoubleValue() < 0.0) {
--- a/dom/html/HTMLProgressElement.h
+++ b/dom/html/HTMLProgressElement.h
@@ -21,18 +21,20 @@ class HTMLProgressElement final : public
public:
explicit HTMLProgressElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
EventStates IntrinsicState() const override;
nsresult Clone(mozilla::dom::NodeInfo* aNodeInfo, nsINode** aResult,
bool aPreallocateChildren) const override;
- bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
- const nsAString& aValue, nsAttrValue& aResult) override;
+ virtual bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult) override;
// WebIDL
double Value() const;
void SetValue(double aValue, ErrorResult& aRv)
{
SetDoubleAttr(nsGkAtoms::value, aValue, aRv);
}
double Max() const;
--- a/dom/html/HTMLScriptElement.cpp
+++ b/dom/html/HTMLScriptElement.cpp
@@ -69,32 +69,33 @@ HTMLScriptElement::BindToTree(nsIDocumen
return NS_OK;
}
bool
HTMLScriptElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::crossorigin) {
ParseCORSValue(aValue, aResult);
return true;
}
if (aAttribute == nsGkAtoms::integrity) {
aResult.ParseStringOrAtom(aValue);
return true;
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
nsresult
HTMLScriptElement::Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const
{
*aResult = nullptr;
--- a/dom/html/HTMLScriptElement.h
+++ b/dom/html/HTMLScriptElement.h
@@ -45,16 +45,17 @@ public:
// nsIContent
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// Element
virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValue* aValue,
--- a/dom/html/HTMLSelectElement.cpp
+++ b/dom/html/HTMLSelectElement.cpp
@@ -1395,28 +1395,29 @@ HTMLSelectElement::DoneAddingChildren(bo
mDefaultSelectionSet = true;
}
bool
HTMLSelectElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (kNameSpaceID_None == aNamespaceID) {
if (aAttribute == nsGkAtoms::size) {
return aResult.ParsePositiveIntValue(aValue);
} else if (aAttribute == nsGkAtoms::autocomplete) {
aResult.ParseAtomArray(aValue);
return true;
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLSelectElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
nsGenericHTMLFormElementWithState::MapImageAlignAttributeInto(aAttributes, aData);
nsGenericHTMLFormElementWithState::MapCommonAttributesInto(aAttributes, aData);
--- a/dom/html/HTMLSelectElement.h
+++ b/dom/html/HTMLSelectElement.h
@@ -392,16 +392,17 @@ public:
virtual void DoneAddingChildren(bool aHaveNotified) override;
virtual bool IsDoneAddingChildren() override {
return mIsDoneAddingChildren;
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
int32_t aModType) const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo* aNodeInfo, nsINode** aResult,
bool aPreallocateChildren) const override;
--- a/dom/html/HTMLSharedElement.cpp
+++ b/dom/html/HTMLSharedElement.cpp
@@ -86,30 +86,31 @@ HTMLSharedElement::SetHref(const nsAStri
return SetAttrHelper(nsGkAtoms::href, aValue);
}
bool
HTMLSharedElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None &&
mNodeInfo->Equals(nsGkAtoms::dir)) {
if (aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, mozilla::dom::kListTypeTable, false);
}
if (aAttribute == nsGkAtoms::start) {
return aResult.ParseIntWithBounds(aValue, 1);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
static void
DirectoryMapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(List))) {
if (!aData->PropertyIsSet(eCSSProperty_list_style_type)) {
--- a/dom/html/HTMLSharedElement.h
+++ b/dom/html/HTMLSharedElement.h
@@ -41,16 +41,17 @@ public:
// nsIDOMHTMLHtmlElement
NS_DECL_NSIDOMHTMLHTMLELEMENT
// nsIContent
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
virtual void UnbindFromTree(bool aDeep = true,
bool aNullParent = true) override;
--- a/dom/html/HTMLSharedListElement.cpp
+++ b/dom/html/HTMLSharedListElement.cpp
@@ -54,33 +54,34 @@ static const nsAttrValue::EnumTable kOld
{ "i", NS_STYLE_LIST_STYLE_LOWER_ROMAN },
{ nullptr, 0 }
};
bool
HTMLSharedListElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (mNodeInfo->Equals(nsGkAtoms::ol) ||
mNodeInfo->Equals(nsGkAtoms::ul)) {
if (aAttribute == nsGkAtoms::type) {
return aResult.ParseEnumValue(aValue, kListTypeTable, false) ||
aResult.ParseEnumValue(aValue, kOldListTypeTable, true);
}
if (aAttribute == nsGkAtoms::start) {
return aResult.ParseIntValue(aValue);
}
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLSharedListElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(List))) {
if (!aData->PropertyIsSet(eCSSProperty_list_style_type)) {
--- a/dom/html/HTMLSharedListElement.h
+++ b/dom/html/HTMLSharedListElement.h
@@ -23,16 +23,17 @@ public:
}
// nsISupports
NS_DECL_ISUPPORTS_INHERITED
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
bool Reversed() const
{
--- a/dom/html/HTMLTableCaptionElement.cpp
+++ b/dom/html/HTMLTableCaptionElement.cpp
@@ -35,24 +35,25 @@ static const nsAttrValue::EnumTable kCap
{ "bottom", NS_STYLE_CAPTION_SIDE_BOTTOM },
{ nullptr, 0 }
};
bool
HTMLTableCaptionElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aAttribute == nsGkAtoms::align && aNamespaceID == kNameSpaceID_None) {
return aResult.ParseEnumValue(aValue, kCaptionAlignTable, false);
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLTableCaptionElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(TableBorder))) {
if (!aData->PropertyIsSet(eCSSProperty_caption_side)) {
--- a/dom/html/HTMLTableCaptionElement.h
+++ b/dom/html/HTMLTableCaptionElement.h
@@ -28,16 +28,17 @@ public:
void SetAlign(const nsAString& aAlign, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::align, aAlign, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
protected:
--- a/dom/html/HTMLTableCellElement.cpp
+++ b/dom/html/HTMLTableCellElement.cpp
@@ -142,16 +142,17 @@ HTMLTableCellElement::GetScope(DOMString
{
GetEnumAttr(nsGkAtoms::scope, nullptr, aScope);
}
bool
HTMLTableCellElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
/* ignore these attributes, stored simply as strings
abbr, axis, ch, headers
*/
if (aAttribute == nsGkAtoms::charoff) {
/* attributes that resolve to integers with a min of 0 */
@@ -188,17 +189,17 @@ HTMLTableCellElement::ParseAttribute(int
return ParseTableVAlignValue(aValue, aResult);
}
}
return nsGenericHTMLElement::ParseBackgroundAttribute(aNamespaceID,
aAttribute, aValue,
aResult) ||
nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLTableCellElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(Position))) {
// width: value
--- a/dom/html/HTMLTableCellElement.h
+++ b/dom/html/HTMLTableCellElement.h
@@ -134,16 +134,17 @@ public:
void SetBgColor(const nsAString& aBgColor, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::bgcolor, aBgColor, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD WalkContentStyleRules(nsRuleWalker* aRuleWalker) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
// Get mapped attributes of ancestor table, if any
nsMappedAttributes* GetMappedAttributesInheritedFromTable() const;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
--- a/dom/html/HTMLTableColElement.cpp
+++ b/dom/html/HTMLTableColElement.cpp
@@ -30,16 +30,17 @@ HTMLTableColElement::WrapNode(JSContext
}
NS_IMPL_ELEMENT_CLONE(HTMLTableColElement)
bool
HTMLTableColElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
/* ignore these attributes, stored simply as strings ch */
if (aAttribute == nsGkAtoms::charoff) {
return aResult.ParseSpecialIntValue(aValue);
}
if (aAttribute == nsGkAtoms::span) {
@@ -54,17 +55,17 @@ HTMLTableColElement::ParseAttribute(int3
return ParseTableCellHAlignValue(aValue, aResult);
}
if (aAttribute == nsGkAtoms::valign) {
return ParseTableVAlignValue(aValue, aResult);
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLTableColElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(Table))) {
if (!aData->PropertyIsSet(eCSSProperty__x_span)) {
--- a/dom/html/HTMLTableColElement.h
+++ b/dom/html/HTMLTableColElement.h
@@ -69,16 +69,17 @@ public:
void SetWidth(const nsAString& aWidth, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::width, aWidth, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
protected:
--- a/dom/html/HTMLTableElement.cpp
+++ b/dom/html/HTMLTableElement.cpp
@@ -916,16 +916,17 @@ HTMLTableElement::DeleteRow(int32_t aInd
row->RemoveFromParent();
}
bool
HTMLTableElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
/* ignore summary, just a string */
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::cellspacing ||
aAttribute == nsGkAtoms::cellpadding ||
aAttribute == nsGkAtoms::border) {
return aResult.ParseNonNegativeIntValue(aValue);
@@ -957,17 +958,17 @@ HTMLTableElement::ParseAttribute(int32_t
return aResult.ParseIntWithBounds(aValue, 0);
}
}
return nsGenericHTMLElement::ParseBackgroundAttribute(aNamespaceID,
aAttribute, aValue,
aResult) ||
nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLTableElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
--- a/dom/html/HTMLTableElement.h
+++ b/dom/html/HTMLTableElement.h
@@ -180,16 +180,17 @@ public:
void SetCellSpacing(const nsAString& aCellSpacing, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::cellspacing, aCellSpacing, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
--- a/dom/html/HTMLTableRowElement.cpp
+++ b/dom/html/HTMLTableRowElement.cpp
@@ -216,16 +216,17 @@ HTMLTableRowElement::DeleteCell(int32_t
nsINode::RemoveChild(*cell, aError);
}
bool
HTMLTableRowElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
/*
* ignore these attributes, stored simply as strings
*
* ch
*/
@@ -249,17 +250,17 @@ HTMLTableRowElement::ParseAttribute(int3
return ParseTableVAlignValue(aValue, aResult);
}
}
return nsGenericHTMLElement::ParseBackgroundAttribute(aNamespaceID,
aAttribute, aValue,
aResult) ||
nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLTableRowElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
nsGenericHTMLElement::MapHeightAttributeInto(aAttributes, aData);
nsGenericHTMLElement::MapDivAlignAttributeInto(aAttributes, aData);
--- a/dom/html/HTMLTableRowElement.h
+++ b/dom/html/HTMLTableRowElement.h
@@ -76,16 +76,17 @@ public:
void SetBgColor(const nsAString& aBgColor, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::bgcolor, aBgColor, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_NO_UNLINK(HTMLTableRowElement,
--- a/dom/html/HTMLTableSectionElement.cpp
+++ b/dom/html/HTMLTableSectionElement.cpp
@@ -125,16 +125,17 @@ HTMLTableSectionElement::DeleteRow(int32
nsINode::RemoveChild(*row, aError);
}
bool
HTMLTableSectionElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
/* ignore these attributes, stored simply as strings
ch
*/
if (aAttribute == nsGkAtoms::charoff) {
return aResult.ParseIntWithBounds(aValue, 0);
@@ -152,17 +153,17 @@ HTMLTableSectionElement::ParseAttribute(
return ParseTableVAlignValue(aValue, aResult);
}
}
return nsGenericHTMLElement::ParseBackgroundAttribute(aNamespaceID,
aAttribute, aValue,
aResult) ||
nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLTableSectionElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(Position))) {
// height: value
--- a/dom/html/HTMLTableSectionElement.h
+++ b/dom/html/HTMLTableSectionElement.h
@@ -61,16 +61,17 @@ public:
void SetVAlign(const nsAString& aVAlign, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::valign, aVAlign, aError);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_NO_UNLINK(HTMLTableSectionElement,
--- a/dom/html/HTMLTextAreaElement.cpp
+++ b/dom/html/HTMLTextAreaElement.cpp
@@ -419,32 +419,33 @@ HTMLTextAreaElement::SetDefaultValue(con
aError.Throw(rv);
}
}
bool
HTMLTextAreaElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::maxlength ||
aAttribute == nsGkAtoms::minlength) {
return aResult.ParseNonNegativeIntValue(aValue);
} else if (aAttribute == nsGkAtoms::cols) {
aResult.ParseIntWithFallback(aValue, DEFAULT_COLS);
return true;
} else if (aAttribute == nsGkAtoms::rows) {
aResult.ParseIntWithFallback(aValue, DEFAULT_ROWS_TEXTAREA);
return true;
}
}
return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLTextAreaElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
if (aData->ShouldComputeStyleStruct(NS_STYLE_INHERIT_BIT(Text))) {
// wrap=off
--- a/dom/html/HTMLTextAreaElement.h
+++ b/dom/html/HTMLTextAreaElement.h
@@ -120,16 +120,17 @@ public:
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
virtual void UnbindFromTree(bool aDeep = true,
bool aNullParent = true) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
int32_t aModType) const override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsresult GetEventTargetParent(
EventChainPreVisitor& aVisitor) override;
--- a/dom/html/HTMLTrackElement.cpp
+++ b/dom/html/HTMLTrackElement.cpp
@@ -213,28 +213,30 @@ HTMLTrackElement::CreateTextTrack()
mMediaParent->AddTextTrack(mTrack);
}
}
bool
HTMLTrackElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::kind) {
// Case-insensitive lookup, with the first element as the default.
return aResult.ParseEnumValue(aValue, kKindTable, false,
kKindTableInvalidValueDefault);
}
// Otherwise call the generic implementation.
return nsGenericHTMLElement::ParseAttribute(aNamespaceID,
aAttribute,
aValue,
+ aMaybeScriptedPrincipal,
aResult);
}
void
HTMLTrackElement::SetSrc(const nsAString& aSrc, ErrorResult& aError)
{
SetHTMLAttr(nsGkAtoms::src, aSrc, aError);
uint16_t oldReadyState = ReadyState();
--- a/dom/html/HTMLTrackElement.h
+++ b/dom/html/HTMLTrackElement.h
@@ -92,16 +92,17 @@ public:
virtual nsresult Clone(mozilla::dom::NodeInfo* aNodeInfo, nsINode** aResult,
bool aPreallocateChildren) const override;
// Override ParseAttribute() to convert kind strings to enum values.
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
// Override BindToTree() so that we can trigger a load when we become
// the child of a media element.
virtual nsresult BindToTree(nsIDocument* aDocument,
nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
--- a/dom/html/HTMLVideoElement.cpp
+++ b/dom/html/HTMLVideoElement.cpp
@@ -82,24 +82,25 @@ nsresult HTMLVideoElement::GetVideoSize(
}
return NS_OK;
}
bool
HTMLVideoElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aAttribute == nsGkAtoms::width || aAttribute == nsGkAtoms::height) {
return aResult.ParseSpecialIntValue(aValue);
}
return HTMLMediaElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
HTMLVideoElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
GenericSpecifiedValues* aData)
{
nsGenericHTMLElement::MapImageSizeAttributesInto(aAttributes, aData);
nsGenericHTMLElement::MapCommonAttributesInto(aAttributes, aData);
--- a/dom/html/HTMLVideoElement.h
+++ b/dom/html/HTMLVideoElement.h
@@ -33,16 +33,17 @@ public:
NS_IMETHOD_(bool) IsVideo() override {
return true;
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
static void Init();
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
virtual nsresult Clone(NodeInfo *aNodeInfo, nsINode **aResult,
--- a/dom/html/nsGenericHTMLElement.cpp
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -922,16 +922,17 @@ nsGenericHTMLElement::GetBaseTarget(nsAS
}
//----------------------------------------------------------------------
bool
nsGenericHTMLElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aAttribute == nsGkAtoms::dir) {
return aResult.ParseEnumValue(aValue, kDirTable, false);
}
if (aAttribute == nsGkAtoms::tabindex) {
@@ -959,17 +960,18 @@ nsGenericHTMLElement::ParseAttribute(int
if (aAttribute == nsGkAtoms::rel) {
aResult.ParseAtomArray(aValue);
return true;
}
}
return nsGenericHTMLElementBase::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue, aMaybeScriptedPrincipal,
+ aResult);
}
bool
nsGenericHTMLElement::ParseBackgroundAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult)
{
--- a/dom/html/nsGenericHTMLElement.h
+++ b/dom/html/nsGenericHTMLElement.h
@@ -339,16 +339,17 @@ public:
void DoSetEditableFlag(bool aEditable, bool aNotify) {
SetEditableFlag(aEditable);
UpdateState(aNotify);
}
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
bool ParseBackgroundAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
nsAttrValue& aResult);
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
--- a/dom/mathml/nsMathMLElement.cpp
+++ b/dom/mathml/nsMathMLElement.cpp
@@ -140,16 +140,17 @@ nsMathMLElement::UnbindFromTree(bool aDe
nsMathMLElementBase::UnbindFromTree(aDeep, aNullParent);
}
bool
nsMathMLElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
MOZ_ASSERT(IsMathMLElement());
if (aNamespaceID == kNameSpaceID_None) {
if (mNodeInfo->Equals(nsGkAtoms::math) && aAttribute == nsGkAtoms::mode) {
WarnDeprecated(nsGkAtoms::mode->GetUTF16String(),
nsGkAtoms::display->GetUTF16String(), OwnerDoc());
@@ -172,17 +173,19 @@ nsMathMLElement::ParseAttribute(int32_t
if (aAttribute == nsGkAtoms::rowspan) {
aResult.ParseClampedNonNegativeInt(aValue, 1, 0, MAX_ROWSPAN);
return true;
}
}
}
return nsMathMLElementBase::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
}
static Element::MappedAttributeEntry sMtableStyles[] = {
{ &nsGkAtoms::width },
{ nullptr }
};
static Element::MappedAttributeEntry sTokenStyles[] = {
--- a/dom/mathml/nsMathMLElement.h
+++ b/dom/mathml/nsMathMLElement.h
@@ -46,16 +46,17 @@ public:
nsIContent* aBindingParent,
bool aCompileEventHandlers) override;
virtual void UnbindFromTree(bool aDeep = true,
bool aNullParent = true) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
enum {
PARSE_ALLOW_UNITLESS = 0x01, // unitless 0 will be turned into 0px
PARSE_ALLOW_NEGATIVE = 0x02,
--- a/dom/svg/SVGAnimateTransformElement.cpp
+++ b/dom/svg/SVGAnimateTransformElement.cpp
@@ -25,16 +25,17 @@ SVGAnimateTransformElement::SVGAnimateTr
: SVGAnimationElement(aNodeInfo)
{
}
bool
SVGAnimateTransformElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
// 'type' is an <animateTransform>-specific attribute, and we'll handle it
// specially.
if (aNamespaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::type) {
aResult.ParseAtom(aValue);
nsAtom* atom = aResult.GetAtomValue();
if (atom != nsGkAtoms::translate &&
@@ -44,16 +45,17 @@ SVGAnimateTransformElement::ParseAttribu
atom != nsGkAtoms::skewY) {
ReportAttributeParseFailure(OwnerDoc(), aAttribute, aValue);
}
return true;
}
return SVGAnimationElement::ParseAttribute(aNamespaceID,
aAttribute, aValue,
+ aMaybeScriptedPrincipal,
aResult);
}
//----------------------------------------------------------------------
// nsIDOMNode methods
NS_IMPL_ELEMENT_CLONE_WITH_INIT(SVGAnimateTransformElement)
--- a/dom/svg/SVGAnimateTransformElement.h
+++ b/dom/svg/SVGAnimateTransformElement.h
@@ -30,20 +30,21 @@ protected:
virtual JSObject* WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) override;
public:
// nsIDOMNode specializations
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// Element specializations
- bool ParseAttribute(int32_t aNamespaceID,
- nsAtom* aAttribute,
- const nsAString& aValue,
- nsAttrValue& aResult) override;
+ virtual bool ParseAttribute(int32_t aNamespaceID,
+ nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult) override;
// SVGAnimationElement
virtual nsSMILAnimationFunction& AnimationFunction() override;
};
} // namespace dom
} // namespace mozilla
--- a/dom/svg/SVGAnimationElement.cpp
+++ b/dom/svg/SVGAnimationElement.cpp
@@ -239,16 +239,17 @@ SVGAnimationElement::UnbindFromTree(bool
SVGAnimationElementBase::UnbindFromTree(aDeep, aNullParent);
}
bool
SVGAnimationElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None) {
// Deal with target-related attributes here
if (aAttribute == nsGkAtoms::attributeName) {
aResult.ParseAtom(aValue);
AnimationNeedsResample();
return true;
@@ -273,17 +274,19 @@ SVGAnimationElement::ParseAttribute(int3
ReportAttributeParseFailure(OwnerDoc(), aAttribute, aValue);
return false;
}
return true;
}
}
return SVGAnimationElementBase::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
}
nsresult
SVGAnimationElement::AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValue* aValue,
const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify)
--- a/dom/svg/SVGAnimationElement.h
+++ b/dom/svg/SVGAnimationElement.h
@@ -52,16 +52,17 @@ public:
bool aNotify) override;
virtual bool IsNodeOfType(uint32_t aFlags) const override;
// Element specializations
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValue* aValue,
const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify) override;
const nsAttrValue* GetAnimAttr(nsAtom* aName) const;
--- a/dom/svg/SVGMPathElement.cpp
+++ b/dom/svg/SVGMPathElement.cpp
@@ -114,21 +114,24 @@ SVGMPathElement::UnbindFromTree(bool aDe
UnlinkHrefTarget(true);
SVGMPathElementBase::UnbindFromTree(aDeep, aNullParent);
}
bool
SVGMPathElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
bool returnVal =
SVGMPathElementBase::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
if ((aNamespaceID == kNameSpaceID_XLink ||
aNamespaceID == kNameSpaceID_None ) &&
aAttribute == nsGkAtoms::href &&
IsInUncomposedDoc()) {
// Note: If we fail the IsInDoc call, it's ok -- we'll update the target
// on next BindToTree call.
// Note: "href" takes priority over xlink:href. So if "xlink:href" is being
--- a/dom/svg/SVGMPathElement.h
+++ b/dom/svg/SVGMPathElement.h
@@ -50,16 +50,17 @@ public:
virtual void UnbindFromTree(bool aDeep, bool aNullParent) override;
virtual nsresult UnsetAttr(int32_t aNamespaceID, nsAtom* aAttribute,
bool aNotify) override;
// Element specializations
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
// Public helper method: If our xlink:href attribute links to a <path>
// element, this method returns a pointer to that element. Otherwise,
// this returns nullptr.
SVGPathElement* GetReferencedPath();
// WebIDL
--- a/dom/svg/SVGMarkerElement.cpp
+++ b/dom/svg/SVGMarkerElement.cpp
@@ -206,16 +206,17 @@ SVGMarkerElement::IsAttributeMapped(cons
}
//----------------------------------------------------------------------
// nsSVGElement methods
bool
SVGMarkerElement::ParseAttribute(int32_t aNameSpaceID, nsAtom* aName,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::orient) {
if (aValue.EqualsLiteral("auto")) {
mOrientType.SetBaseValue(SVG_MARKER_ORIENT_AUTO);
aResult.SetTo(aValue);
mAngleAttributes[ORIENT].SetBaseValue(0.f, this, false);
return true;
@@ -225,17 +226,19 @@ SVGMarkerElement::ParseAttribute(int32_t
mOrientType.SetBaseValue(SVG_MARKER_ORIENT_AUTO_START_REVERSE);
aResult.SetTo(aValue);
mAngleAttributes[ORIENT].SetBaseValue(0.f, this, false);
return true;
}
mOrientType.SetBaseValue(SVG_MARKER_ORIENT_ANGLE);
}
return SVGMarkerElementBase::ParseAttribute(aNameSpaceID, aName,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
}
nsresult
SVGMarkerElement::UnsetAttr(int32_t aNamespaceID, nsAtom* aName,
bool aNotify)
{
if (aNamespaceID == kNameSpaceID_None) {
if (aName == nsGkAtoms::orient) {
--- a/dom/svg/SVGMarkerElement.h
+++ b/dom/svg/SVGMarkerElement.h
@@ -146,16 +146,17 @@ public:
already_AddRefed<SVGAnimatedAngle> OrientAngle();
void SetOrientToAuto();
void SetOrientToAngle(SVGAngle& angle, ErrorResult& rv);
protected:
virtual bool ParseAttribute(int32_t aNameSpaceID, nsAtom* aName,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
void SetParentCoordCtxProvider(SVGViewportElement *aContext);
virtual LengthAttributesInfo GetLengthInfo() override;
virtual AngleAttributesInfo GetAngleInfo() override;
virtual EnumAttributesInfo GetEnumInfo() override;
virtual nsSVGViewBox *GetViewBox() override;
--- a/dom/svg/SVGScriptElement.cpp
+++ b/dom/svg/SVGScriptElement.cpp
@@ -247,26 +247,29 @@ SVGScriptElement::AfterSetAttr(int32_t a
aValue, aOldValue,
aSubjectPrincipal, aNotify);
}
bool
SVGScriptElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None &&
aAttribute == nsGkAtoms::crossorigin) {
ParseCORSValue(aValue, aResult);
return true;
}
return SVGScriptElementBase::ParseAttribute(aNamespaceID, aAttribute,
- aValue, aResult);
+ aValue,
+ aMaybeScriptedPrincipal,
+ aResult);
}
CORSMode
SVGScriptElement::GetCORSMode() const
{
return AttrValueToCORSMode(GetParsedAttr(nsGkAtoms::crossorigin));
}
--- a/dom/svg/SVGScriptElement.h
+++ b/dom/svg/SVGScriptElement.h
@@ -57,16 +57,17 @@ public:
virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValue* aValue,
const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// WebIDL
void GetType(nsAString & aType);
void SetType(const nsAString & aType, ErrorResult& rv);
--- a/dom/svg/SVGStyleElement.cpp
+++ b/dom/svg/SVGStyleElement.cpp
@@ -130,26 +130,27 @@ SVGStyleElement::UnsetAttr(int32_t aName
return rv;
}
bool
SVGStyleElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
if (aNamespaceID == kNameSpaceID_None &&
aAttribute == nsGkAtoms::crossorigin) {
ParseCORSValue(aValue, aResult);
return true;
}
return SVGStyleElementBase::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
//----------------------------------------------------------------------
// nsIMutationObserver methods
void
SVGStyleElement::CharacterDataChanged(nsIDocument* aDocument,
nsIContent* aContent,
--- a/dom/svg/SVGStyleElement.h
+++ b/dom/svg/SVGStyleElement.h
@@ -49,16 +49,17 @@ public:
nsAtom* aPrefix, const nsAString& aValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify) override;
virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsAtom* aAttribute,
bool aNotify) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult,
bool aPreallocateChildren) const override;
// nsIMutationObserver
NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED
NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
--- a/dom/svg/nsSVGElement.cpp
+++ b/dom/svg/nsSVGElement.cpp
@@ -336,16 +336,17 @@ nsSVGElement::AfterSetAttr(int32_t aName
return nsSVGElementBase::AfterSetAttr(aNamespaceID, aName, aValue, aOldValue,
aSubjectPrincipal, aNotify);
}
bool
nsSVGElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
nsresult rv = NS_OK;
bool foundMatch = false;
bool didSetResult = false;
if (aNamespaceID == kNameSpaceID_None) {
// Check for nsSVGLength2 attribute
@@ -668,17 +669,17 @@ nsSVGElement::ParseAttribute(int32_t aNa
}
if (!didSetResult) {
aResult.SetTo(aValue);
}
return true;
}
return nsSVGElementBase::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult);
+ aMaybeScriptedPrincipal, aResult);
}
void
nsSVGElement::UnsetAttrInternal(int32_t aNamespaceID, nsAtom* aName,
bool aNotify)
{
// XXXbz there's a bunch of redundancy here with AfterSetAttr.
// Maybe consolidate?
--- a/dom/svg/nsSVGElement.h
+++ b/dom/svg/nsSVGElement.h
@@ -350,17 +350,19 @@ protected:
}
#endif // DEBUG
virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsAtom* aName,
const nsAttrValue* aValue,
const nsAttrValue* aOldValue,
nsIPrincipal* aSubjectPrincipal,
bool aNotify) override;
virtual bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
- const nsAString& aValue, nsAttrValue& aResult) override;
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult) override;
static nsresult ReportAttributeParseFailure(nsIDocument* aDocument,
nsAtom* aAttribute,
const nsAString& aValue);
nsAttrValue WillChangeValue(nsAtom* aName);
// aNewValue is set to the old value. This value may be invalid if
// !StoresOwnData.
void DidChangeValue(nsAtom* aName, const nsAttrValue& aEmptyOrOldValue,
--- a/dom/xul/nsXULElement.cpp
+++ b/dom/xul/nsXULElement.cpp
@@ -1156,21 +1156,22 @@ nsXULElement::AfterSetAttr(int32_t aName
return nsStyledElement::AfterSetAttr(aNamespaceID, aName,
aValue, aOldValue, aSubjectPrincipal, aNotify);
}
bool
nsXULElement::ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult)
{
// Parse into a nsAttrValue
if (!nsStyledElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
- aResult)) {
+ aMaybeScriptedPrincipal, aResult)) {
// Fall back to parsing as atom for short values
aResult.ParseStringOrAtom(aValue);
}
return true;
}
void
--- a/dom/xul/nsXULElement.h
+++ b/dom/xul/nsXULElement.h
@@ -755,16 +755,17 @@ protected:
nsIPrincipal* aSubjectPrincipal,
bool aNotify) override;
virtual void UpdateEditableState(bool aNotify) override;
virtual bool ParseAttribute(int32_t aNamespaceID,
nsAtom* aAttribute,
const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
nsAttrValue& aResult) override;
virtual mozilla::EventListenerManager*
GetEventListenerManagerForAttr(nsAtom* aAttrName,
bool* aDefer) override;
/**
* Add a listener for the specified attribute, if appropriate.