зеркало из https://github.com/mozilla/gecko-dev.git
Bug 562688 part 5. Change the document id and named item table APIs to use Element. r=jst
This commit is contained in:
Boris Zbarsky
Родитель
9c2ad4b2aa
Коммит
7baad57df7
|
|
@ -137,7 +137,11 @@ typedef int (*PR_CALLBACK PrefChangedFunc)(const char *, void *);
|
|||
|
||||
namespace mozilla {
|
||||
class IHistory;
|
||||
}
|
||||
|
||||
namespace dom {
|
||||
class Element;
|
||||
} // namespace dom
|
||||
} // namespace mozilla
|
||||
|
||||
extern const char kLoadAsData[];
|
||||
|
||||
|
|
@ -1362,7 +1366,7 @@ public:
|
|||
* If aContent is an HTML element with a DOM level 0 'name', then
|
||||
* return the name. Otherwise return null.
|
||||
*/
|
||||
static nsIAtom* IsNamedItem(nsIContent* aContent);
|
||||
static nsIAtom* IsNamedItem(mozilla::dom::Element* aElement);
|
||||
|
||||
/**
|
||||
* Get the application manifest URI for this document. The manifest URI
|
||||
|
|
|
|||
|
|
@ -5005,13 +5005,13 @@ nsAutoGCRoot::Shutdown()
|
|||
}
|
||||
|
||||
nsIAtom*
|
||||
nsContentUtils::IsNamedItem(nsIContent* aContent)
|
||||
nsContentUtils::IsNamedItem(Element* aElement)
|
||||
{
|
||||
// Only the content types reflected in Level 0 with a NAME
|
||||
// attribute are registered. Images, layers and forms always get
|
||||
// reflected up to the document. Applets and embeds only go
|
||||
// to the closest container (which could be a form).
|
||||
nsGenericHTMLElement* elm = nsGenericHTMLElement::FromContent(aContent);
|
||||
nsGenericHTMLElement* elm = nsGenericHTMLElement::FromContent(aElement);
|
||||
if (!elm) {
|
||||
return nsnull;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -258,17 +258,17 @@ nsIdentifierMapEntry::CreateNameContentList()
|
|||
return NS_OK;
|
||||
}
|
||||
|
||||
nsIContent*
|
||||
nsIdentifierMapEntry::GetIdContent()
|
||||
Element*
|
||||
nsIdentifierMapEntry::GetIdElement()
|
||||
{
|
||||
return static_cast<nsIContent*>(mIdContentList.SafeElementAt(0));
|
||||
return static_cast<Element*>(mIdContentList.SafeElementAt(0));
|
||||
}
|
||||
|
||||
void
|
||||
nsIdentifierMapEntry::AppendAllIdContent(nsCOMArray<nsIContent>* aElements)
|
||||
{
|
||||
for (PRInt32 i = 0; i < mIdContentList.Count(); ++i) {
|
||||
aElements->AppendObject(static_cast<nsIContent*>(mIdContentList[i]));
|
||||
aElements->AppendObject(static_cast<Element*>(mIdContentList[i]));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -301,8 +301,8 @@ nsIdentifierMapEntry::RemoveContentChangeCallback(nsIDocument::IDTargetObserver
|
|||
}
|
||||
|
||||
struct FireChangeArgs {
|
||||
nsIContent* mFrom;
|
||||
nsIContent* mTo;
|
||||
Element* mFrom;
|
||||
Element* mTo;
|
||||
};
|
||||
|
||||
static PLDHashOperator
|
||||
|
|
@ -314,35 +314,35 @@ FireChangeEnumerator(nsIdentifierMapEntry::ChangeCallbackEntry *aEntry, void *aA
|
|||
}
|
||||
|
||||
void
|
||||
nsIdentifierMapEntry::FireChangeCallbacks(nsIContent* aOldContent,
|
||||
nsIContent* aNewContent)
|
||||
nsIdentifierMapEntry::FireChangeCallbacks(Element* aOldElement,
|
||||
Element* aNewElement)
|
||||
{
|
||||
if (!mChangeCallbacks)
|
||||
return;
|
||||
|
||||
FireChangeArgs args = { aOldContent, aNewContent };
|
||||
FireChangeArgs args = { aOldElement, aNewElement };
|
||||
mChangeCallbacks->EnumerateEntries(FireChangeEnumerator, &args);
|
||||
}
|
||||
|
||||
PRBool
|
||||
nsIdentifierMapEntry::AddIdContent(nsIContent* aContent)
|
||||
nsIdentifierMapEntry::AddIdElement(Element* aElement)
|
||||
{
|
||||
NS_PRECONDITION(aContent, "Must have content");
|
||||
NS_PRECONDITION(aElement, "Must have element");
|
||||
NS_PRECONDITION(mIdContentList.IndexOf(nsnull) < 0,
|
||||
"Why is null in our list?");
|
||||
|
||||
#ifdef DEBUG
|
||||
nsIContent* currentContent =
|
||||
static_cast<nsIContent*>(mIdContentList.SafeElementAt(0));
|
||||
Element* currentElement =
|
||||
static_cast<Element*>(mIdContentList.SafeElementAt(0));
|
||||
#endif
|
||||
|
||||
// Common case
|
||||
if (mIdContentList.Count() == 0) {
|
||||
if (!mIdContentList.AppendElement(aContent))
|
||||
if (!mIdContentList.AppendElement(aElement))
|
||||
return PR_FALSE;
|
||||
NS_ADDREF(aContent);
|
||||
NS_ASSERTION(currentContent == nsnull, "How did that happen?");
|
||||
FireChangeCallbacks(nsnull, aContent);
|
||||
NS_ADDREF(aElement);
|
||||
NS_ASSERTION(currentElement == nsnull, "How did that happen?");
|
||||
FireChangeCallbacks(nsnull, aElement);
|
||||
return PR_TRUE;
|
||||
}
|
||||
|
||||
|
|
@ -356,56 +356,57 @@ nsIdentifierMapEntry::AddIdContent(nsIContent* aContent)
|
|||
PRInt32 cur = (start + end) / 2;
|
||||
NS_ASSERTION(cur >= start && cur < end, "What happened here?");
|
||||
|
||||
nsIContent* curContent = static_cast<nsIContent*>(mIdContentList[cur]);
|
||||
if (curContent == aContent) {
|
||||
Element* curElement = static_cast<Element*>(mIdContentList[cur]);
|
||||
if (curElement == aElement) {
|
||||
// Already in the list, so already in the right spot. Get out of here.
|
||||
// XXXbz this only happens because XUL does all sorts of random
|
||||
// UpdateIdTableEntry calls. Hate, hate, hate!
|
||||
return PR_TRUE;
|
||||
}
|
||||
|
||||
if (nsContentUtils::PositionIsBefore(aContent, curContent)) {
|
||||
if (nsContentUtils::PositionIsBefore(aElement, curElement)) {
|
||||
end = cur;
|
||||
} else {
|
||||
start = cur + 1;
|
||||
}
|
||||
} while (start != end);
|
||||
|
||||
if (!mIdContentList.InsertElementAt(aContent, start))
|
||||
if (!mIdContentList.InsertElementAt(aElement, start))
|
||||
return PR_FALSE;
|
||||
NS_ADDREF(aContent);
|
||||
NS_ADDREF(aElement);
|
||||
if (start == 0) {
|
||||
nsIContent* oldContent =
|
||||
static_cast<nsIContent*>(mIdContentList.SafeElementAt(1));
|
||||
NS_ASSERTION(currentContent == oldContent, "How did that happen?");
|
||||
FireChangeCallbacks(oldContent, aContent);
|
||||
Element* oldElement =
|
||||
static_cast<Element*>(mIdContentList.SafeElementAt(1));
|
||||
NS_ASSERTION(currentElement == oldElement, "How did that happen?");
|
||||
FireChangeCallbacks(oldElement, aElement);
|
||||
}
|
||||
return PR_TRUE;
|
||||
}
|
||||
|
||||
PRBool
|
||||
nsIdentifierMapEntry::RemoveIdContent(nsIContent* aContent)
|
||||
nsIdentifierMapEntry::RemoveIdElement(Element* aElement)
|
||||
{
|
||||
// This should only be called while the document is in an update.
|
||||
// Assertions near the call to this method guarantee this.
|
||||
|
||||
// XXXbz should this ever Compact() I guess when all the content is gone
|
||||
// we'll just get cleaned up in the natural order of things...
|
||||
nsIContent* currentContent = static_cast<nsIContent*>(mIdContentList.SafeElementAt(0));
|
||||
if (!mIdContentList.RemoveElement(aContent))
|
||||
Element* currentElement =
|
||||
static_cast<Element*>(mIdContentList.SafeElementAt(0));
|
||||
if (!mIdContentList.RemoveElement(aElement))
|
||||
return PR_FALSE;
|
||||
if (currentContent == aContent) {
|
||||
FireChangeCallbacks(currentContent,
|
||||
static_cast<nsIContent*>(mIdContentList.SafeElementAt(0)));
|
||||
if (currentElement == aElement) {
|
||||
FireChangeCallbacks(currentElement,
|
||||
static_cast<Element*>(mIdContentList.SafeElementAt(0)));
|
||||
}
|
||||
// Make sure the release happens after the check above, since it'll
|
||||
// null out aContent.
|
||||
NS_RELEASE(aContent);
|
||||
NS_RELEASE(aElement);
|
||||
return mIdContentList.Count() == 0 && !mNameContentList && !mChangeCallbacks;
|
||||
}
|
||||
|
||||
void
|
||||
nsIdentifierMapEntry::AddNameContent(nsIContent* aContent)
|
||||
nsIdentifierMapEntry::AddNameElement(Element* aElement)
|
||||
{
|
||||
if (!mNameContentList || mNameContentList == NAME_NOT_VALID)
|
||||
return;
|
||||
|
|
@ -414,16 +415,17 @@ nsIdentifierMapEntry::AddNameContent(nsIContent* aContent)
|
|||
// content notifications when we do document.foo resolution. So
|
||||
// aContent may be in our list already and just now getting notified
|
||||
// for!
|
||||
if (mNameContentList->IndexOf(aContent, PR_FALSE) < 0) {
|
||||
mNameContentList->AppendElement(aContent);
|
||||
// XXXbz with the HTML5 parser we can stop doing this!
|
||||
if (mNameContentList->IndexOf(aElement, PR_FALSE) < 0) {
|
||||
mNameContentList->AppendElement(aElement);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsIdentifierMapEntry::RemoveNameContent(nsIContent* aContent)
|
||||
nsIdentifierMapEntry::RemoveNameElement(Element* aElement)
|
||||
{
|
||||
if (mNameContentList && mNameContentList != NAME_NOT_VALID) {
|
||||
mNameContentList->RemoveElement(aContent);
|
||||
mNameContentList->RemoveElement(aElement);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2329,12 +2331,12 @@ nsDocument::GetLastModified(nsAString& aLastModified)
|
|||
}
|
||||
|
||||
void
|
||||
nsDocument::UpdateNameTableEntry(nsIContent *aContent)
|
||||
nsDocument::UpdateNameTableEntry(Element *aElement)
|
||||
{
|
||||
if (!mIsRegularHTML)
|
||||
return;
|
||||
|
||||
nsIAtom* name = nsContentUtils::IsNamedItem(aContent);
|
||||
nsIAtom* name = nsContentUtils::IsNamedItem(aElement);
|
||||
if (!name)
|
||||
return;
|
||||
|
||||
|
|
@ -2344,16 +2346,16 @@ nsDocument::UpdateNameTableEntry(nsIContent *aContent)
|
|||
return;
|
||||
}
|
||||
|
||||
entry->AddNameContent(aContent);
|
||||
entry->AddNameElement(aElement);
|
||||
}
|
||||
|
||||
void
|
||||
nsDocument::RemoveFromNameTable(nsIContent *aContent)
|
||||
nsDocument::RemoveFromNameTable(Element *aElement)
|
||||
{
|
||||
if (!mIsRegularHTML)
|
||||
return;
|
||||
|
||||
nsIAtom* name = nsContentUtils::IsNamedItem(aContent);
|
||||
nsIAtom* name = nsContentUtils::IsNamedItem(aElement);
|
||||
if (!name)
|
||||
return;
|
||||
|
||||
|
|
@ -2363,27 +2365,27 @@ nsDocument::RemoveFromNameTable(nsIContent *aContent)
|
|||
return;
|
||||
}
|
||||
|
||||
entry->RemoveNameContent(aContent);
|
||||
entry->RemoveNameElement(aElement);
|
||||
}
|
||||
|
||||
void
|
||||
nsDocument::UpdateIdTableEntry(nsIContent *aContent)
|
||||
nsDocument::UpdateIdTableEntry(Element *aElement)
|
||||
{
|
||||
nsIAtom* id = aContent->GetID();
|
||||
nsIAtom* id = aElement->GetID();
|
||||
if (!id)
|
||||
return;
|
||||
|
||||
nsIdentifierMapEntry *entry = mIdentifierMap.PutEntry(id);
|
||||
|
||||
if (entry) { /* True except on OOM */
|
||||
entry->AddIdContent(aContent);
|
||||
entry->AddIdElement(aElement);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
nsDocument::RemoveFromIdTable(nsIContent *aContent)
|
||||
nsDocument::RemoveFromIdTable(Element *aElement)
|
||||
{
|
||||
nsIAtom* id = aContent->GetID();
|
||||
nsIAtom* id = aElement->GetID();
|
||||
if (!id)
|
||||
return;
|
||||
|
||||
|
|
@ -2391,7 +2393,7 @@ nsDocument::RemoveFromIdTable(nsIContent *aContent)
|
|||
if (!entry) /* Should be false unless we had OOM when adding the entry */
|
||||
return;
|
||||
|
||||
if (entry->RemoveIdContent(aContent)) {
|
||||
if (entry->RemoveIdElement(aElement)) {
|
||||
mIdentifierMap.RemoveEntry(id);
|
||||
}
|
||||
}
|
||||
|
|
@ -2399,13 +2401,13 @@ nsDocument::RemoveFromIdTable(nsIContent *aContent)
|
|||
void
|
||||
nsDocument::UnregisterNamedItems(nsIContent *aContent)
|
||||
{
|
||||
if (!aContent->IsNodeOfType(nsINode::eELEMENT)) {
|
||||
if (!aContent->IsElement()) {
|
||||
// non-element nodes are not named items nor can they have children.
|
||||
return;
|
||||
}
|
||||
|
||||
RemoveFromNameTable(aContent);
|
||||
RemoveFromIdTable(aContent);
|
||||
RemoveFromNameTable(aContent->AsElement());
|
||||
RemoveFromIdTable(aContent->AsElement());
|
||||
|
||||
for (nsINode::ChildIterator iter(aContent); !iter.IsDone(); iter.Next()) {
|
||||
UnregisterNamedItems(iter);
|
||||
|
|
@ -2415,13 +2417,13 @@ nsDocument::UnregisterNamedItems(nsIContent *aContent)
|
|||
void
|
||||
nsDocument::RegisterNamedItems(nsIContent *aContent)
|
||||
{
|
||||
if (!aContent->IsNodeOfType(nsINode::eELEMENT)) {
|
||||
if (!aContent->IsElement()) {
|
||||
// non-element nodes are not named items nor can they have children.
|
||||
return;
|
||||
}
|
||||
|
||||
UpdateNameTableEntry(aContent);
|
||||
UpdateIdTableEntry(aContent);
|
||||
UpdateNameTableEntry(aContent->AsElement());
|
||||
UpdateIdTableEntry(aContent->AsElement());
|
||||
|
||||
for (nsINode::ChildIterator iter(aContent); !iter.IsDone(); iter.Next()) {
|
||||
RegisterNamedItems(iter);
|
||||
|
|
@ -2473,15 +2475,15 @@ nsDocument::AttributeWillChange(nsIDocument* aDocument,
|
|||
nsIContent* aContent, PRInt32 aNameSpaceID,
|
||||
nsIAtom* aAttribute, PRInt32 aModType)
|
||||
{
|
||||
NS_ABORT_IF_FALSE(aContent, "Null content!");
|
||||
NS_ABORT_IF_FALSE(aContent && aContent->IsElement(), "Null content!");
|
||||
NS_PRECONDITION(aAttribute, "Must have an attribute that's changing!");
|
||||
|
||||
if (aNameSpaceID != kNameSpaceID_None)
|
||||
return;
|
||||
if (aAttribute == nsGkAtoms::name) {
|
||||
RemoveFromNameTable(aContent);
|
||||
RemoveFromNameTable(aContent->AsElement());
|
||||
} else if (aAttribute == aContent->GetIDAttributeName()) {
|
||||
RemoveFromIdTable(aContent);
|
||||
RemoveFromIdTable(aContent->AsElement());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2492,15 +2494,15 @@ nsDocument::AttributeChanged(nsIDocument* aDocument,
|
|||
{
|
||||
NS_ASSERTION(aDocument == this, "unexpected doc");
|
||||
|
||||
NS_ABORT_IF_FALSE(aContent, "Null content!");
|
||||
NS_ABORT_IF_FALSE(aContent && aContent->IsElement(), "Null content!");
|
||||
NS_PRECONDITION(aAttribute, "Must have an attribute that's changing!");
|
||||
|
||||
if (aNameSpaceID != kNameSpaceID_None)
|
||||
return;
|
||||
if (aAttribute == nsGkAtoms::name) {
|
||||
UpdateNameTableEntry(aContent);
|
||||
UpdateNameTableEntry(aContent->AsElement());
|
||||
} else if (aAttribute == aContent->GetIDAttributeName()) {
|
||||
UpdateIdTableEntry(aContent);
|
||||
UpdateIdTableEntry(aContent->AsElement());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3968,7 +3970,7 @@ nsDocument::GetElementByIdInternal(nsIAtom* aID)
|
|||
nsIdentifierMapEntry *entry = mIdentifierMap.PutEntry(aID);
|
||||
NS_ENSURE_TRUE(entry, nsnull);
|
||||
|
||||
if (entry->GetIdContent())
|
||||
if (entry->GetIdElement())
|
||||
return entry;
|
||||
|
||||
// Now we have to flush. It could be that we know nothing about this ID yet
|
||||
|
|
@ -4006,7 +4008,7 @@ nsDocument::GetElementById(const nsAString& aElementId,
|
|||
nsIdentifierMapEntry *entry = GetElementByIdInternal(idAtom);
|
||||
NS_ENSURE_TRUE(entry, NS_ERROR_OUT_OF_MEMORY);
|
||||
|
||||
nsIContent *e = entry->GetIdContent();
|
||||
Element *e = entry->GetIdElement();
|
||||
if (!e)
|
||||
return NS_OK;
|
||||
|
||||
|
|
@ -4024,7 +4026,7 @@ nsDocument::AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
|
|||
NS_ENSURE_TRUE(entry, nsnull);
|
||||
|
||||
entry->AddContentChangeCallback(aObserver, aData);
|
||||
return entry->GetIdContent();
|
||||
return entry->GetIdElement();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
|||
|
|
@ -164,8 +164,8 @@ public:
|
|||
|
||||
void SetInvalidName();
|
||||
PRBool IsInvalidName();
|
||||
void AddNameContent(nsIContent* aContent);
|
||||
void RemoveNameContent(nsIContent* aContent);
|
||||
void AddNameElement(mozilla::dom::Element* aElement);
|
||||
void RemoveNameElement(mozilla::dom::Element* aElement);
|
||||
PRBool HasNameContentList() {
|
||||
return mNameContentList != nsnull;
|
||||
}
|
||||
|
|
@ -178,7 +178,7 @@ public:
|
|||
* Returns the element if we know the element associated with this
|
||||
* id. Otherwise returns null.
|
||||
*/
|
||||
nsIContent* GetIdContent();
|
||||
mozilla::dom::Element* GetIdElement();
|
||||
/**
|
||||
* Append all the elements with this id to aElements
|
||||
*/
|
||||
|
|
@ -188,12 +188,12 @@ public:
|
|||
* @return true if the content could be added, false if we failed due
|
||||
* to OOM.
|
||||
*/
|
||||
PRBool AddIdContent(nsIContent* aContent);
|
||||
PRBool AddIdElement(mozilla::dom::Element* aElement);
|
||||
/**
|
||||
* This can fire ID change callbacks.
|
||||
* @return true if this map entry should be removed
|
||||
*/
|
||||
PRBool RemoveIdContent(nsIContent* aContent);
|
||||
PRBool RemoveIdElement(mozilla::dom::Element* aElement);
|
||||
|
||||
PRBool HasContentChangeCallback() { return mChangeCallbacks != nsnull; }
|
||||
void AddContentChangeCallback(nsIDocument::IDTargetObserver aCallback, void* aData);
|
||||
|
|
@ -236,12 +236,14 @@ public:
|
|||
};
|
||||
|
||||
private:
|
||||
void FireChangeCallbacks(nsIContent* aOldContent, nsIContent* aNewContent);
|
||||
void FireChangeCallbacks(mozilla::dom::Element* aOldElement,
|
||||
mozilla::dom::Element* aNewElement);
|
||||
|
||||
// empty if there are no nodes with this ID.
|
||||
// The content nodes are stored addrefed.
|
||||
// empty if there are no elementswith this ID.
|
||||
// The elementsnodes are stored addrefed.
|
||||
nsSmallVoidArray mIdContentList;
|
||||
// NAME_NOT_VALID if this id cannot be used as a 'name'
|
||||
// NAME_NOT_VALID if this id cannot be used as a 'name'. Otherwise
|
||||
// stores Elements.
|
||||
nsBaseContentList *mNameContentList;
|
||||
nsRefPtr<nsContentList> mDocAllList;
|
||||
nsAutoPtr<nsTHashtable<ChangeCallbackEntry> > mChangeCallbacks;
|
||||
|
|
@ -946,10 +948,10 @@ protected:
|
|||
friend class nsNodeUtils;
|
||||
void RegisterNamedItems(nsIContent *aContent);
|
||||
void UnregisterNamedItems(nsIContent *aContent);
|
||||
void UpdateNameTableEntry(nsIContent *aContent);
|
||||
void UpdateIdTableEntry(nsIContent *aContent);
|
||||
void RemoveFromNameTable(nsIContent *aContent);
|
||||
void RemoveFromIdTable(nsIContent *aContent);
|
||||
void UpdateNameTableEntry(mozilla::dom::Element *aElement);
|
||||
void UpdateIdTableEntry(mozilla::dom::Element *aElement);
|
||||
void RemoveFromNameTable(mozilla::dom::Element *aElement);
|
||||
void RemoveFromIdTable(mozilla::dom::Element *aElement);
|
||||
|
||||
/**
|
||||
* Check that aId is not empty and log a message to the console
|
||||
|
|
|
|||
|
|
@ -2643,24 +2643,26 @@ FindNamedItems(nsIAtom* aName, nsIContent *aContent,
|
|||
NS_ASSERTION(!aEntry->IsInvalidName(),
|
||||
"Entry that should never have a list passed to FindNamedItems()!");
|
||||
|
||||
if (aContent->IsNodeOfType(nsINode::eTEXT)) {
|
||||
// Text nodes are not named items nor can they have children.
|
||||
if (!aContent->IsElement()) {
|
||||
// non-elements are not named items nor can they have children.
|
||||
return;
|
||||
}
|
||||
|
||||
if (aName == nsContentUtils::IsNamedItem(aContent)) {
|
||||
aEntry->AddNameContent(aContent);
|
||||
Element* element = aContent->AsElement();
|
||||
|
||||
if (aName == nsContentUtils::IsNamedItem(element)) {
|
||||
aEntry->AddNameElement(element);
|
||||
}
|
||||
|
||||
if (!aEntry->GetIdContent() &&
|
||||
if (!aEntry->GetIdElement() &&
|
||||
// Maybe this node has the right id?
|
||||
aName == aContent->GetID()) {
|
||||
aEntry->AddIdContent(aContent);
|
||||
aName == element->GetID()) {
|
||||
aEntry->AddIdElement(element);
|
||||
}
|
||||
|
||||
PRUint32 i, count = aContent->GetChildCount();
|
||||
PRUint32 i, count = element->GetChildCount();
|
||||
for (i = 0; i < count; ++i) {
|
||||
FindNamedItems(aName, aContent->GetChildAt(i), aEntry);
|
||||
FindNamedItems(aName, element->GetChildAt(i), aEntry);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2791,7 +2793,7 @@ nsHTMLDocument::ResolveName(const nsAString& aName,
|
|||
// for aName, so we're guaranteed that if there is an element with
|
||||
// the id aName, it'll be entry's IdContent.
|
||||
|
||||
nsIContent *e = entry->GetIdContent();
|
||||
Element *e = entry->GetIdElement();
|
||||
|
||||
if (e && e->IsHTML()) {
|
||||
nsIAtom *tag = e->Tag();
|
||||
|
|
|
|||
|
|
@ -59,6 +59,9 @@
|
|||
#include "nsNodeInfoManager.h"
|
||||
#include "nsINodeInfo.h"
|
||||
#include "nsIPrincipal.h"
|
||||
#include "Element.h"
|
||||
|
||||
using namespace mozilla::dom;
|
||||
|
||||
nsresult
|
||||
NS_NewXBLContentSink(nsIXMLContentSink** aResult,
|
||||
|
|
@ -891,7 +894,10 @@ nsXBLContentSink::CreateElement(const PRUnichar** aAtts, PRUint32 aAttsCount,
|
|||
|
||||
AddAttributesToXULPrototype(aAtts, aAttsCount, prototype);
|
||||
|
||||
return nsXULElement::Create(prototype, mDocument, PR_FALSE, aResult);
|
||||
Element* result;
|
||||
nsresult rv = nsXULElement::Create(prototype, mDocument, PR_FALSE, &result);
|
||||
*aResult = result;
|
||||
return rv;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -303,7 +303,7 @@ nsresult
|
|||
nsXULElement::Create(nsXULPrototypeElement* aPrototype,
|
||||
nsIDocument* aDocument,
|
||||
PRBool aIsScriptable,
|
||||
nsIContent** aResult)
|
||||
Element** aResult)
|
||||
{
|
||||
// Create an nsXULElement from a prototype
|
||||
NS_PRECONDITION(aPrototype != nsnull, "null ptr");
|
||||
|
|
|
|||
|
|
@ -479,7 +479,7 @@ protected:
|
|||
public:
|
||||
static nsresult
|
||||
Create(nsXULPrototypeElement* aPrototype, nsIDocument* aDocument,
|
||||
PRBool aIsScriptable, nsIContent** aResult);
|
||||
PRBool aIsScriptable, mozilla::dom::Element** aResult);
|
||||
|
||||
// nsISupports
|
||||
NS_DECL_ISUPPORTS_INHERITED
|
||||
|
|
|
|||
|
|
@ -1138,8 +1138,10 @@ nsXULDocument::AddElementForID(nsIContent* aElement)
|
|||
NS_PRECONDITION(aElement != nsnull, "null ptr");
|
||||
if (! aElement)
|
||||
return NS_ERROR_NULL_POINTER;
|
||||
if (!aElement->IsElement())
|
||||
return NS_ERROR_UNEXPECTED;
|
||||
|
||||
UpdateIdTableEntry(aElement);
|
||||
UpdateIdTableEntry(aElement->AsElement());
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
|
@ -1670,9 +1672,9 @@ nsXULDocument::GetElementById(const nsAString& aId,
|
|||
|
||||
nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(atom);
|
||||
if (entry) {
|
||||
nsIContent* content = entry->GetIdContent();
|
||||
if (content)
|
||||
return CallQueryInterface(content, aReturn);
|
||||
Element* element = entry->GetIdElement();
|
||||
if (element)
|
||||
return CallQueryInterface(element, aReturn);
|
||||
}
|
||||
nsRefMapEntry* refEntry = mRefMap.GetEntry(atom);
|
||||
if (refEntry) {
|
||||
|
|
@ -1684,7 +1686,7 @@ nsXULDocument::GetElementById(const nsAString& aId,
|
|||
}
|
||||
|
||||
nsresult
|
||||
nsXULDocument::AddElementToDocumentPre(nsIContent* aElement)
|
||||
nsXULDocument::AddElementToDocumentPre(Element* aElement)
|
||||
{
|
||||
// Do a bunch of work that's necessary when an element gets added
|
||||
// to the XUL Document.
|
||||
|
|
@ -1727,7 +1729,7 @@ nsXULDocument::AddElementToDocumentPre(nsIContent* aElement)
|
|||
}
|
||||
|
||||
nsresult
|
||||
nsXULDocument::AddElementToDocumentPost(nsIContent* aElement)
|
||||
nsXULDocument::AddElementToDocumentPost(Element* aElement)
|
||||
{
|
||||
// We need to pay special attention to the keyset tag to set up a listener
|
||||
if (aElement->NodeInfo()->Equals(nsGkAtoms::keyset, kNameSpaceID_XUL)) {
|
||||
|
|
@ -1766,14 +1768,16 @@ nsXULDocument::AddElementToDocumentPost(nsIContent* aElement)
|
|||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
nsXULDocument::AddSubtreeToDocument(nsIContent* aElement)
|
||||
nsXULDocument::AddSubtreeToDocument(nsIContent* aContent)
|
||||
{
|
||||
NS_ASSERTION(aElement->GetCurrentDoc() == this, "Element not in doc!");
|
||||
NS_ASSERTION(aContent->GetCurrentDoc() == this, "Element not in doc!");
|
||||
// From here on we only care about elements.
|
||||
if (!aElement->IsNodeOfType(nsINode::eELEMENT)) {
|
||||
if (!aContent->IsElement()) {
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
Element* aElement = aContent->AsElement();
|
||||
|
||||
// Do pre-order addition magic
|
||||
nsresult rv = AddElementToDocumentPre(aElement);
|
||||
if (NS_FAILED(rv)) return rv;
|
||||
|
|
@ -1792,13 +1796,15 @@ nsXULDocument::AddSubtreeToDocument(nsIContent* aElement)
|
|||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
nsXULDocument::RemoveSubtreeFromDocument(nsIContent* aElement)
|
||||
nsXULDocument::RemoveSubtreeFromDocument(nsIContent* aContent)
|
||||
{
|
||||
// From here on we only care about elements.
|
||||
if (!aElement->IsNodeOfType(nsINode::eELEMENT)) {
|
||||
if (!aContent->IsElement()) {
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
Element* aElement = aContent->AsElement();
|
||||
|
||||
// Do a bunch of cleanup to remove an element from the XUL
|
||||
// document.
|
||||
nsresult rv;
|
||||
|
|
@ -2451,7 +2457,7 @@ nsXULDocument::PrepareToWalk()
|
|||
|
||||
// Do one-time initialization if we're preparing to walk the
|
||||
// master document's prototype.
|
||||
nsCOMPtr<nsIContent> root;
|
||||
nsCOMPtr<Element> root;
|
||||
|
||||
if (mState == eState_Master) {
|
||||
// Add the root element
|
||||
|
|
@ -2884,7 +2890,7 @@ nsXULDocument::ResumeWalk()
|
|||
// document hookup done when it's successfully
|
||||
// resolved.)
|
||||
if (mState == eState_Master) {
|
||||
AddElementToDocumentPost(element);
|
||||
AddElementToDocumentPost(element->AsElement());
|
||||
|
||||
if (element->NodeInfo()->Equals(nsGkAtoms::style,
|
||||
kNameSpaceID_XHTML) ||
|
||||
|
|
@ -2937,7 +2943,7 @@ nsXULDocument::ResumeWalk()
|
|||
nsXULPrototypeElement* protoele =
|
||||
static_cast<nsXULPrototypeElement*>(childproto);
|
||||
|
||||
nsCOMPtr<nsIContent> child;
|
||||
nsCOMPtr<Element> child;
|
||||
|
||||
if (!processingOverlayHookupNodes) {
|
||||
rv = CreateElementFromPrototype(protoele,
|
||||
|
|
@ -3664,7 +3670,7 @@ nsXULDocument::ExecuteScript(nsXULPrototypeScript *aScript)
|
|||
|
||||
nsresult
|
||||
nsXULDocument::CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
|
||||
nsIContent** aResult)
|
||||
Element** aResult)
|
||||
{
|
||||
// Create a content model element from a prototype element.
|
||||
NS_PRECONDITION(aPrototype != nsnull, "null ptr");
|
||||
|
|
@ -3687,7 +3693,7 @@ nsXULDocument::CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
|
|||
}
|
||||
#endif
|
||||
|
||||
nsCOMPtr<nsIContent> result;
|
||||
nsCOMPtr<Element> result;
|
||||
|
||||
if (aPrototype->mNodeInfo->NamespaceEquals(kNameSpaceID_XUL)) {
|
||||
// If it's a XUL element, it'll be lightweight until somebody
|
||||
|
|
@ -3705,10 +3711,13 @@ nsXULDocument::CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
|
|||
aPrototype->mNodeInfo->GetPrefixAtom(),
|
||||
aPrototype->mNodeInfo->NamespaceID());
|
||||
if (!newNodeInfo) return NS_ERROR_OUT_OF_MEMORY;
|
||||
rv = NS_NewElement(getter_AddRefs(result), newNodeInfo->NamespaceID(),
|
||||
nsCOMPtr<nsIContent> content;
|
||||
rv = NS_NewElement(getter_AddRefs(content), newNodeInfo->NamespaceID(),
|
||||
newNodeInfo, PR_FALSE);
|
||||
if (NS_FAILED(rv)) return rv;
|
||||
|
||||
result = content->AsElement();
|
||||
|
||||
#ifdef MOZ_XTF
|
||||
if (result && newNodeInfo->NamespaceID() > kNameSpaceID_LastBuiltin) {
|
||||
result->BeginAddingChildren();
|
||||
|
|
@ -3726,11 +3735,11 @@ nsXULDocument::CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
|
|||
|
||||
nsresult
|
||||
nsXULDocument::CreateOverlayElement(nsXULPrototypeElement* aPrototype,
|
||||
nsIContent** aResult)
|
||||
Element** aResult)
|
||||
{
|
||||
nsresult rv;
|
||||
|
||||
nsCOMPtr<nsIContent> element;
|
||||
nsCOMPtr<Element> element;
|
||||
rv = CreateElementFromPrototype(aPrototype, getter_AddRefs(element));
|
||||
if (NS_FAILED(rv)) return rv;
|
||||
|
||||
|
|
|
|||
|
|
@ -153,8 +153,8 @@ public:
|
|||
nsCOMArray<nsIContent>& aElements);
|
||||
|
||||
NS_IMETHOD GetScriptGlobalObjectOwner(nsIScriptGlobalObjectOwner** aGlobalOwner);
|
||||
NS_IMETHOD AddSubtreeToDocument(nsIContent* aElement);
|
||||
NS_IMETHOD RemoveSubtreeFromDocument(nsIContent* aElement);
|
||||
NS_IMETHOD AddSubtreeToDocument(nsIContent* aContent);
|
||||
NS_IMETHOD RemoveSubtreeFromDocument(nsIContent* aContent);
|
||||
NS_IMETHOD SetTemplateBuilderFor(nsIContent* aContent,
|
||||
nsIXULTemplateBuilder* aBuilder);
|
||||
NS_IMETHOD GetTemplateBuilderFor(nsIContent* aContent,
|
||||
|
|
@ -235,10 +235,10 @@ protected:
|
|||
nsCOMArray<nsIContent>& aElements);
|
||||
|
||||
nsresult
|
||||
AddElementToDocumentPre(nsIContent* aElement);
|
||||
AddElementToDocumentPre(mozilla::dom::Element* aElement);
|
||||
|
||||
nsresult
|
||||
AddElementToDocumentPost(nsIContent* aElement);
|
||||
AddElementToDocumentPost(mozilla::dom::Element* aElement);
|
||||
|
||||
nsresult
|
||||
ExecuteOnBroadcastHandlerFor(nsIContent* aBroadcaster,
|
||||
|
|
@ -409,13 +409,14 @@ protected:
|
|||
* Note that the resulting content node is not bound to any tree
|
||||
*/
|
||||
nsresult CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
|
||||
nsIContent** aResult);
|
||||
mozilla::dom::Element** aResult);
|
||||
|
||||
/**
|
||||
* Create a hook-up element to which content nodes can be attached for
|
||||
* later resolution.
|
||||
*/
|
||||
nsresult CreateOverlayElement(nsXULPrototypeElement* aPrototype, nsIContent** aResult);
|
||||
nsresult CreateOverlayElement(nsXULPrototypeElement* aPrototype,
|
||||
mozilla::dom::Element** aResult);
|
||||
|
||||
/**
|
||||
* Add attributes from the prototype to the element.
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче