--- a/dom/base/DocumentFragment.h
+++ b/dom/base/DocumentFragment.h
@@ -5,16 +5,17 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_dom_DocumentFragment_h__
#define mozilla_dom_DocumentFragment_h__
#include "mozilla/Attributes.h"
#include "mozilla/dom/FragmentOrElement.h"
#include "nsIDOMDocumentFragment.h"
+#include "nsAttrInfo.h"
class nsIAtom;
class nsAString;
class nsIDocument;
class nsIContent;
namespace mozilla {
namespace dom {
@@ -74,25 +75,29 @@ public:
return SetAttr(aNameSpaceID, aName, nullptr, aValue, aNotify);
}
virtual nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aName,
nsIAtom* aPrefix, const nsAString& aValue,
bool aNotify) override
{
return NS_OK;
}
- virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
+ virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
bool aNotify) override
{
return NS_OK;
}
virtual const nsAttrName* GetAttrNameAt(uint32_t aIndex) const override
{
return nullptr;
}
+ virtual nsAttrInfo GetAttrInfoAt(uint32_t aIndex) const override
+ {
+ return nsAttrInfo(nullptr, nullptr);
+ }
virtual uint32_t GetAttrCount() const override
{
return 0;
}
virtual bool IsNodeOfType(uint32_t aFlags) const override;
virtual nsIDOMNode* AsDOMNode() override { return this; }
--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -2531,32 +2531,40 @@ Element::SetMappedAttribute(nsIDocument*
EventListenerManager*
Element::GetEventListenerManagerForAttr(nsIAtom* aAttrName,
bool* aDefer)
{
*aDefer = true;
return GetOrCreateListenerManager();
}
-Element::nsAttrInfo
+nsAttrInfo
Element::GetAttrInfo(int32_t aNamespaceID, nsIAtom* aName) const
{
NS_ASSERTION(nullptr != aName, "must have attribute name");
NS_ASSERTION(aNamespaceID != kNameSpaceID_Unknown,
"must have a real namespace ID!");
int32_t index = mAttrsAndChildren.IndexOfAttr(aName, aNamespaceID);
- if (index >= 0) {
- return nsAttrInfo(mAttrsAndChildren.AttrNameAt(index),
- mAttrsAndChildren.AttrAt(index));
+ if (index < 0) {
+ return nsAttrInfo(nullptr, nullptr);
}
- return nsAttrInfo(nullptr, nullptr);
+ return mAttrsAndChildren.AttrInfoAt(index);
}
+nsAttrInfo
+Element::GetAttrInfoAt(uint32_t aIndex) const
+{
+ if (aIndex >= mAttrsAndChildren.AttrCount()) {
+ return nsAttrInfo(nullptr, nullptr);
+ }
+
+ return mAttrsAndChildren.AttrInfoAt(aIndex);
+}
bool
Element::GetAttr(int32_t aNameSpaceID, nsIAtom* aName,
nsAString& aResult) const
{
DOMString str;
bool haveAttr = GetAttr(aNameSpaceID, aName, str);
str.ToString(aResult);
--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -504,16 +504,17 @@ public:
nsCaseTreatment aCaseSensitive) const;
virtual int32_t FindAttrValueIn(int32_t aNameSpaceID,
nsIAtom* aName,
AttrValuesArray* aValues,
nsCaseTreatment aCaseSensitive) const override;
virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
bool aNotify) override;
virtual const nsAttrName* GetAttrNameAt(uint32_t aIndex) const override;
+ virtual nsAttrInfo GetAttrInfoAt(uint32_t aIndex) const override;
virtual uint32_t GetAttrCount() const override;
virtual bool IsNodeOfType(uint32_t aFlags) const override;
#ifdef DEBUG
virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override
{
List(out, aIndent, EmptyCString());
}
@@ -933,30 +934,16 @@ public:
* @param aType the kind of flush to do, typically Flush_Frames or
* Flush_Layout
* @return the primary frame
*/
nsIFrame* GetPrimaryFrame(mozFlushType aType);
// Work around silly C++ name hiding stuff
nsIFrame* GetPrimaryFrame() const { return nsIContent::GetPrimaryFrame(); }
- /**
- * Struct that stores info on an attribute. The name and value must
- * either both be null or both be non-null.
- */
- struct nsAttrInfo {
- nsAttrInfo(const nsAttrName* aName, const nsAttrValue* aValue) :
- mName(aName), mValue(aValue) {}
- nsAttrInfo(const nsAttrInfo& aOther) :
- mName(aOther.mName), mValue(aOther.mValue) {}
-
- const nsAttrName* mName;
- const nsAttrValue* mValue;
- };
-
const nsAttrValue* GetParsedAttr(nsIAtom* aAttr) const
{
return mAttrsAndChildren.GetAttr(aAttr);
}
const nsAttrValue* GetParsedAttr(nsIAtom* aAttr, int32_t aNameSpaceID) const
{
return mAttrsAndChildren.GetAttr(aAttr, aNameSpaceID);
--- a/dom/base/moz.build
+++ b/dom/base/moz.build
@@ -43,16 +43,17 @@ EXPORTS += [
'AutocompleteFieldList.h',
'Crypto.h',
'HTMLSplitOnSpacesTokenizer.h',
'IframeSandboxKeywordList.h',
'mozAutoDocUpdate.h',
'mozFlushType.h',
'nsAtomListUtils.h',
'nsAttrAndChildArray.h',
+ 'nsAttrInfo.h',
'nsAttrName.h',
'nsAttrValue.h',
'nsAttrValueInlines.h',
'nsCaseTreatment.h',
'nsChildContentList.h',
'nsContentCID.h',
'nsContentCreatorFunctions.h',
'nsContentList.h',
--- a/dom/base/nsAttrAndChildArray.cpp
+++ b/dom/base/nsAttrAndChildArray.cpp
@@ -74,25 +74,25 @@ int32_t
GetIndexFromCache(const nsAttrAndChildArray* aArray)
{
uint32_t ix = CACHE_GET_INDEX(aArray);
return indexCache[ix].array == aArray ? indexCache[ix].index : -1;
}
/**
- * Due to a compiler bug in VisualAge C++ for AIX, we need to return the
- * address of the first index into mBuffer here, instead of simply returning
+ * Due to a compiler bug in VisualAge C++ for AIX, we need to return the
+ * address of the first index into mBuffer here, instead of simply returning
* mBuffer itself.
*
* See Bug 231104 for more information.
*/
#define ATTRS(_impl) \
reinterpret_cast<InternalAttr*>(&((_impl)->mBuffer[0]))
-
+
#define NS_IMPL_EXTRA_SIZE \
((sizeof(Impl) - sizeof(mImpl->mBuffer)) / sizeof(void*))
nsAttrAndChildArray::nsAttrAndChildArray()
: mImpl(nullptr)
{
}
@@ -109,29 +109,29 @@ nsAttrAndChildArray::~nsAttrAndChildArra
}
nsIContent*
nsAttrAndChildArray::GetSafeChildAt(uint32_t aPos) const
{
if (aPos < ChildCount()) {
return ChildAt(aPos);
}
-
+
return nullptr;
}
nsIContent * const *
nsAttrAndChildArray::GetChildArray(uint32_t* aChildCount) const
{
*aChildCount = ChildCount();
-
+
if (!*aChildCount) {
return nullptr;
}
-
+
return reinterpret_cast<nsIContent**>(mImpl->mBuffer + AttrSlotsSize());
}
nsresult
nsAttrAndChildArray::InsertChildAt(nsIContent* aChild, uint32_t aPos)
{
NS_ASSERTION(aChild, "nullchild");
NS_ASSERTION(aPos <= ChildCount(), "out-of-bounds");
@@ -179,17 +179,17 @@ nsAttrAndChildArray::InsertChildAt(nsICo
void** pos = mImpl->mBuffer + offset + aPos;
if (childCount != aPos) {
memmove(pos + 1, pos, (childCount - aPos) * sizeof(nsIContent*));
}
SetChildAtPos(pos, aChild, aPos, childCount);
SetChildCount(childCount + 1);
-
+
return NS_OK;
}
void
nsAttrAndChildArray::RemoveChildAt(uint32_t aPos)
{
// Just store the return value of TakeChildAt in an nsCOMPtr to
// trigger a release.
@@ -479,16 +479,31 @@ nsAttrAndChildArray::RemoveAttrAt(uint32
RefPtr<nsMappedAttributes> mapped =
GetModifiableMapped(nullptr, nullptr, false);
mapped->RemoveAttrAt(aPos - nonmapped, aValue);
return MakeMappedUnique(mapped);
}
+nsAttrInfo
+nsAttrAndChildArray::AttrInfoAt(uint32_t aPos) const
+{
+ NS_ASSERTION(aPos < AttrCount(),
+ "out-of-bounds access in nsAttrAndChildArray");
+
+ uint32_t nonmapped = NonMappedAttrCount();
+ if (aPos < nonmapped) {
+ return nsAttrInfo(&ATTRS(mImpl)[aPos].mName, &ATTRS(mImpl)[aPos].mValue);
+ }
+
+ return nsAttrInfo(mImpl->mMappedAttrs->NameAt(aPos - nonmapped),
+ mImpl->mMappedAttrs->AttrAt(aPos - nonmapped));
+}
+
const nsAttrName*
nsAttrAndChildArray::AttrNameAt(uint32_t aPos) const
{
NS_ASSERTION(aPos < AttrCount(),
"out-of-bounds access in nsAttrAndChildArray");
uint32_t nonmapped = NonMappedAttrCount();
if (aPos < nonmapped) {
--- a/dom/base/nsAttrAndChildArray.h
+++ b/dom/base/nsAttrAndChildArray.h
@@ -11,16 +11,17 @@
#ifndef nsAttrAndChildArray_h___
#define nsAttrAndChildArray_h___
#include "mozilla/Attributes.h"
#include "mozilla/MemoryReporting.h"
#include "nscore.h"
+#include "nsAttrInfo.h"
#include "nsAttrName.h"
#include "nsAttrValue.h"
#include "nsCaseTreatment.h"
class nsINode;
class nsIContent;
class nsMappedAttributes;
class nsHTMLStyleSheet;
@@ -94,16 +95,19 @@ public:
// Remove the attr at position aPos. The value of the attr is placed in
// aValue; any value that was already in aValue is destroyed.
nsresult RemoveAttrAt(uint32_t aPos, nsAttrValue& aValue);
// Returns attribute name at given position, *not* out-of-bounds safe
const nsAttrName* AttrNameAt(uint32_t aPos) const;
+ // Returns the attribute info at a given position, *not* out-of-bounds safe
+ nsAttrInfo AttrInfoAt(uint32_t aPos) const;
+
// Returns attribute name at given position or null if aPos is out-of-bounds
const nsAttrName* GetSafeAttrNameAt(uint32_t aPos) const;
const nsAttrName* GetExistingAttrNameFromQName(const nsAString& aName) const;
int32_t IndexOfAttr(nsIAtom* aLocalName, int32_t aNamespaceID = kNameSpaceID_None) const;
nsresult SetAndTakeMappedAttr(nsIAtom* aLocalName, nsAttrValue& aValue,
nsMappedAttributeElement* aContent,
@@ -159,17 +163,17 @@ private:
bool AttrSlotIsTaken(uint32_t aSlot) const
{
NS_PRECONDITION(aSlot < AttrSlotCount(), "out-of-bounds");
return mImpl->mBuffer[aSlot * ATTRSIZE];
}
void SetChildCount(uint32_t aCount)
{
- mImpl->mAttrAndChildCount =
+ mImpl->mAttrAndChildCount =
(mImpl->mAttrAndChildCount & ATTRCHILD_ARRAY_ATTR_SLOTS_COUNT_MASK) |
(aCount << ATTRCHILD_ARRAY_ATTR_SLOTS_BITS);
}
void SetAttrSlotCount(uint32_t aCount)
{
mImpl->mAttrAndChildCount =
(mImpl->mAttrAndChildCount & ~ATTRCHILD_ARRAY_ATTR_SLOTS_COUNT_MASK) |
new file mode 100644
--- /dev/null
+++ b/dom/base/nsAttrInfo.h
@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsAttrInfo_h__
+#define nsAttrInfo_h__
+
+#include "mozilla/Assertions.h"
+
+class nsAttrName;
+class nsAttrValue;
+
+/**
+ * Struct that stores info on an attribute. The name and value must
+ * either both be null or both be non-null.
+ */
+struct nsAttrInfo
+{
+ nsAttrInfo()
+ : mName(nullptr)
+ , mValue(nullptr)
+ {
+ }
+
+ nsAttrInfo(const nsAttrName* aName, const nsAttrValue* aValue)
+ : mName(aName)
+ , mValue(aValue)
+ {
+ MOZ_ASSERT_IF(aName, aValue);
+ }
+
+ nsAttrInfo(const nsAttrInfo& aOther)
+ : mName(aOther.mName)
+ , mValue(aOther.mValue)
+ {
+ }
+
+ const nsAttrName* mName;
+ const nsAttrValue* mValue;
+};
+
+#endif
--- a/dom/base/nsAttrValue.h
+++ b/dom/base/nsAttrValue.h
@@ -438,17 +438,17 @@ private:
// exist already.
MiscContainer* EnsureEmptyMiscContainer();
bool EnsureEmptyAtomArray();
already_AddRefed<nsStringBuffer>
GetStringBuffer(const nsAString& aValue) const;
// Given an enum table and a particular entry in that table, return
// the actual integer value we should store.
int32_t EnumTableEntryToValue(const EnumTable* aEnumTable,
- const EnumTable* aTableEntry);
+ const EnumTable* aTableEntry);
static nsTArray<const EnumTable*>* sEnumTableArray;
uintptr_t mBits;
};
inline const nsAttrValue&
nsAttrValue::operator=(const nsAttrValue& aOther)
--- a/dom/base/nsGenericDOMDataNode.cpp
+++ b/dom/base/nsGenericDOMDataNode.cpp
@@ -642,16 +642,22 @@ nsGenericDOMDataNode::UnsetAttr(int32_t
}
const nsAttrName*
nsGenericDOMDataNode::GetAttrNameAt(uint32_t aIndex) const
{
return nullptr;
}
+nsAttrInfo
+nsGenericDOMDataNode::GetAttrInfoAt(uint32_t aIndex) const
+{
+ return nsAttrInfo(nullptr, nullptr);
+}
+
uint32_t
nsGenericDOMDataNode::GetAttrCount() const
{
return 0;
}
uint32_t
nsGenericDOMDataNode::GetChildCount() const
--- a/dom/base/nsGenericDOMDataNode.h
+++ b/dom/base/nsGenericDOMDataNode.h
@@ -118,16 +118,17 @@ public:
return SetAttr(aNameSpaceID, aName, nullptr, aValue, aNotify);
}
virtual nsresult SetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
nsIAtom* aPrefix, const nsAString& aValue,
bool aNotify) override;
virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
bool aNotify) override;
virtual const nsAttrName* GetAttrNameAt(uint32_t aIndex) const override;
+ virtual nsAttrInfo GetAttrInfoAt(uint32_t aIndex) const override;
virtual uint32_t GetAttrCount() const override;
virtual const nsTextFragment *GetText() override;
virtual uint32_t TextLength() const override;
virtual nsresult SetText(const char16_t* aBuffer, uint32_t aLength,
bool aNotify) override;
// Need to implement this here too to avoid hiding.
nsresult SetText(const nsAString& aStr, bool aNotify)
{
@@ -320,14 +321,14 @@ public:
virtual bool IsPurple() override
{
return mRefCnt.IsPurple();
}
virtual void RemovePurple() override
{
mRefCnt.RemovePurple();
}
-
+
private:
already_AddRefed<nsIAtom> GetCurrentValueAtom();
};
#endif /* nsGenericDOMDataNode_h___ */
--- a/dom/base/nsIContent.h
+++ b/dom/base/nsIContent.h
@@ -2,16 +2,17 @@
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef nsIContent_h___
#define nsIContent_h___
#include "mozilla/Attributes.h"
+#include "nsAttrInfo.h"
#include "nsCaseTreatment.h" // for enum, cannot be forward-declared
#include "nsINode.h"
// Forward declarations
class nsAString;
class nsIAtom;
class nsIURI;
class nsRuleWalker;
@@ -30,17 +31,17 @@ struct CustomElementData;
namespace widget {
struct IMEState;
} // namespace widget
} // namespace mozilla
enum nsLinkState {
eLinkState_Unvisited = 1,
eLinkState_Visited = 2,
- eLinkState_NotLink = 3
+ eLinkState_NotLink = 3
};
// IID for the nsIContent interface
#define NS_ICONTENT_IID \
{ 0x8e1bab9d, 0x8815, 0x4d2c, \
{ 0xa2, 0x4d, 0x7a, 0xba, 0x52, 0x39, 0xdc, 0x22 } }
/**
@@ -97,17 +98,17 @@ public:
nsIContent* aBindingParent,
bool aCompileEventHandlers) = 0;
/**
* Unbind this content node from a tree. This will set its current document
* and binding parent to null. In the typical case of a node being removed
* from a parent, this will be called after it has been removed from the
* parent's child list and after the nsIDocumentObserver notifications for
- * the removal have been dispatched.
+ * the removal have been dispatched.
* @param aDeep Whether to recursively unbind the entire subtree rooted at
* this node. The only time false should be passed is when the
* parent node of the content is being destroyed.
* @param aNullParent Whether to null out the parent pointer as well. This
* is usually desirable. This argument should only be false while
* recursively calling UnbindFromTree when a subtree is detached.
* @note This method is safe to call on nodes that are not bound to a tree.
*/
@@ -388,44 +389,44 @@ public:
* @param aName The name atom of the attribute. Must not be null.
* @param aValue The value to compare to.
* @param aCaseSensitive Whether to do a case-sensitive compare on the value.
*/
bool AttrValueIs(int32_t aNameSpaceID,
nsIAtom* aName,
const nsAString& aValue,
nsCaseTreatment aCaseSensitive) const;
-
+
/**
* Test whether this content node's given attribute has the given value. If
* the attribute is not set at all, this will return false.
*
* @param aNameSpaceID The namespace ID of the attribute. Must not
* be kNameSpaceID_Unknown.
* @param aName The name atom of the attribute. Must not be null.
* @param aValue The value to compare to. Must not be null.
* @param aCaseSensitive Whether to do a case-sensitive compare on the value.
*/
bool AttrValueIs(int32_t aNameSpaceID,
nsIAtom* aName,
nsIAtom* aValue,
nsCaseTreatment aCaseSensitive) const;
-
+
enum {
ATTR_MISSING = -1,
ATTR_VALUE_NO_MATCH = -2
};
/**
* Check whether this content node's given attribute has one of a given
* list of values. If there is a match, we return the index in the list
* of the first matching value. If there was no attribute at all, then
* we return ATTR_MISSING. If there was an attribute but it didn't
* match, we return ATTR_VALUE_NO_MATCH. A non-negative result always
* indicates a match.
- *
+ *
* @param aNameSpaceID The namespace ID of the attribute. Must not
* be kNameSpaceID_Unknown.
* @param aName The name atom of the attribute. Must not be null.
* @param aValues a nullptr-terminated array of pointers to atom values to test
* against.
* @param aCaseSensitive Whether to do a case-sensitive compare on the values.
* @return ATTR_MISSING, ATTR_VALUE_NO_MATCH or the non-negative index
* indicating the first value of aValues that matched
@@ -442,34 +443,39 @@ public:
/**
* Remove an attribute so that it is no longer explicitly specified.
*
* @param aNameSpaceID the namespace id of the attribute
* @param aAttr the name of the attribute to unset
* @param aNotify specifies whether or not the document should be
* notified of the attribute change
*/
- virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttr,
+ virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttr,
bool aNotify) = 0;
/**
* Get the namespace / name / prefix of a given attribute.
- *
+ *
* @param aIndex the index of the attribute name
* @returns The name at the given index, or null if the index is
* out-of-bounds.
* @note The document returned by NodeInfo()->GetDocument() (if one is
* present) is *not* necessarily the owner document of the element.
* @note The pointer returned by this function is only valid until the
* next call of either GetAttrNameAt or SetAttr on the element.
*/
virtual const nsAttrName* GetAttrNameAt(uint32_t aIndex) const = 0;
/**
+ * Gets the attribute info (name and value) for this content at a given index.
+ */
+ virtual nsAttrInfo GetAttrInfoAt(uint32_t aIndex) const = 0;
+
+ /**
* Get the number of all specified attributes.
*
* @return the number of attributes
*/
virtual uint32_t GetAttrCount() const = 0;
/**
* Get direct access (but read only) to the text in the text content.
@@ -479,23 +485,23 @@ public:
virtual const nsTextFragment *GetText() = 0;
/**
* Get the length of the text content.
* NOTE: This should not be called on elements.
*/
virtual uint32_t TextLength() const = 0;
- /**
- * Determines if an event attribute name (such as onclick) is valid for
- * a given element type.
- * @note calls nsContentUtils::IsEventAttributeName with right flag
- * @note overridden by subclasses as needed
- * @param aName the event name to look up
- */
+ /**
+ * Determines if an event attribute name (such as onclick) is valid for
+ * a given element type.
+ * @note calls nsContentUtils::IsEventAttributeName with right flag
+ * @note overridden by subclasses as needed
+ * @param aName the event name to look up
+ */
virtual bool IsEventAttributeName(nsIAtom* aName)
{
return false;
}
/**
* Set the text to the given value. If aNotify is true then
* the document is notified of the content change.
@@ -546,23 +552,23 @@ public:
* Append the text content to aResult.
* NOTE: This asserts and returns for elements
*/
MOZ_MUST_USE
virtual bool AppendTextTo(nsAString& aResult, const mozilla::fallible_t&) = 0;
/**
* Check if this content is focusable and in the current tab order.
- * Note: most callers should use nsIFrame::IsFocusable() instead as it
+ * Note: most callers should use nsIFrame::IsFocusable() instead as it
* checks visibility and other layout factors as well.
* Tabbable is indicated by a nonnegative tabindex & is a subset of focusable.
- * For example, only the selected radio button in a group is in the
+ * For example, only the selected radio button in a group is in the
* tab order, unless the radio group has no selection in which case
- * all of the visible, non-disabled radio buttons in the group are
- * in the tab order. On the other hand, all of the visible, non-disabled
+ * all of the visible, non-disabled radio buttons in the group are
+ * in the tab order. On the other hand, all of the visible, non-disabled
* radio buttons are always focusable via clicking or script.
* Also, depending on either the accessibility.tabfocus pref or
* a system setting (nowadays: Full keyboard access, mac only)
* some widgets may be focusable but removed from the tab order.
* @param [inout, optional] aTabIndex the computed tab index
* In: default tabindex for element (-1 nonfocusable, == 0 focusable)
* Out: computed tabindex
* @param [optional] aTabIndex the computed tab index
@@ -773,17 +779,17 @@ public:
* element and then call setAttribute() directly, at which point
* DoneCreatingElement() has already been called and is out of the picture).
*/
virtual void DoneCreatingElement()
{
}
/**
- * This method is called when the parser begins creating the element's
+ * This method is called when the parser begins creating the element's
* children, if any are present.
*
* This is only called for XTF elements currently.
*/
virtual void BeginAddingChildren()
{
}
--- a/dom/base/nsMappedAttributes.h
+++ b/dom/base/nsMappedAttributes.h
@@ -87,17 +87,17 @@ private:
struct InternalAttr
{
nsAttrName mName;
nsAttrValue mValue;
};
/**
- * Due to a compiler bug in VisualAge C++ for AIX, we need to return the
+ * Due to a compiler bug in VisualAge C++ for AIX, we need to return the
* address of the first index into mAttrs here, instead of simply
* returning mAttrs itself.
*
* See Bug 231104 for more information.
*/
const InternalAttr* Attrs() const
{
return reinterpret_cast<const InternalAttr*>(&(mAttrs[0]));