mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 561221 - nsDocumentEncoder should not use nsIDOM* interfaces internally, r=sicking

This commit is contained in:
Olli Pettay 2010-04-30 14:15:09 +03:00
Родитель dd1503788c
Коммит b515516d74
3 изменённых файлов: 115 добавлений и 149 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4
content/base/public/nsContentUtils.h
Просмотреть файл

@ -232,8 +232,8 @@ public:
* This method fills the |aArray| with all ancestor nodes of |aNode| * This method fills the |aArray| with all ancestor nodes of |aNode|
* including |aNode| at the zero index. * including |aNode| at the zero index.
*/ */
static nsresult GetAncestors(nsIDOMNode* aNode, static nsresult GetAncestors(nsINode* aNode,
nsTArray<nsIDOMNode*>* aArray); nsTArray<nsINode*>& aArray);
/* /*
* This method fills |aAncestorNodes| with all ancestor nodes of |aNode| * This method fills |aAncestorNodes| with all ancestor nodes of |aNode|

19
content/base/src/nsContentUtils.cpp
Просмотреть файл

@ -1460,20 +1460,13 @@ nsContentUtils::ContentIsCrossDocDescendantOf(nsINode* aPossibleDescendant,
// static // static
nsresult nsresult
nsContentUtils::GetAncestors(nsIDOMNode* aNode, nsContentUtils::GetAncestors(nsINode* aNode,
nsTArray<nsIDOMNode*>* aArray) nsTArray<nsINode*>& aArray)
{ {
NS_ENSURE_ARG_POINTER(aNode); while (aNode) {
aArray.AppendElement(aNode);
nsCOMPtr<nsIDOMNode> node(aNode); aNode = aNode->GetNodeParent();
nsCOMPtr<nsIDOMNode> ancestor; }
do {
aArray->AppendElement(node.get());
node->GetParentNode(getter_AddRefs(ancestor));
node.swap(ancestor);
} while (node);
return NS_OK; return NS_OK;
} }

241
content/base/src/nsDocumentEncoder.cpp
Просмотреть файл

@ -62,6 +62,7 @@
#include "nsIDOMProcessingInstruction.h" #include "nsIDOMProcessingInstruction.h"
#include "nsIDOMDocumentType.h" #include "nsIDOMDocumentType.h"
#include "nsIDOMNodeList.h" #include "nsIDOMNodeList.h"
#include "nsIRange.h"
#include "nsIDOMRange.h" #include "nsIDOMRange.h"
#include "nsIDOMDocument.h" #include "nsIDOMDocument.h"
#include "nsICharsetConverterManager.h" #include "nsICharsetConverterManager.h"
@ -98,38 +99,38 @@ public:
protected: protected:
void Initialize(); void Initialize();
nsresult SerializeNodeStart(nsIDOMNode* aNode, PRInt32 aStartOffset, nsresult SerializeNodeStart(nsINode* aNode, PRInt32 aStartOffset,
PRInt32 aEndOffset, nsAString& aStr, PRInt32 aEndOffset, nsAString& aStr,
nsIDOMNode* aOriginalNode = nsnull); nsINode* aOriginalNode = nsnull);
nsresult SerializeToStringRecursive(nsIDOMNode* aNode, nsresult SerializeToStringRecursive(nsINode* aNode,
nsAString& aStr, nsAString& aStr,
PRBool aDontSerializeRoot); PRBool aDontSerializeRoot);
nsresult SerializeNodeEnd(nsIDOMNode* aNode, nsAString& aStr); nsresult SerializeNodeEnd(nsINode* aNode, nsAString& aStr);
nsresult SerializeRangeToString(nsIDOMRange *aRange, nsresult SerializeRangeToString(nsIRange *aRange,
nsAString& aOutputString); nsAString& aOutputString);
nsresult SerializeRangeNodes(nsIDOMRange* aRange, nsresult SerializeRangeNodes(nsIRange* aRange,
nsIDOMNode* aNode, nsINode* aNode,
nsAString& aString, nsAString& aString,
PRInt32 aDepth); PRInt32 aDepth);
nsresult SerializeRangeContextStart(const nsTArray<nsIDOMNode*>& aAncestorArray, nsresult SerializeRangeContextStart(const nsTArray<nsINode*>& aAncestorArray,
nsAString& aString); nsAString& aString);
nsresult SerializeRangeContextEnd(const nsTArray<nsIDOMNode*>& aAncestorArray, nsresult SerializeRangeContextEnd(const nsTArray<nsINode*>& aAncestorArray,
nsAString& aString); nsAString& aString);
nsresult FlushText(nsAString& aString, PRBool aForce); nsresult FlushText(nsAString& aString, PRBool aForce);
static PRBool IsTag(nsIDOMNode* aNode, nsIAtom* aAtom); static PRBool IsTag(nsIContent* aContent, nsIAtom* aAtom);
virtual PRBool IncludeInContext(nsIDOMNode *aNode); virtual PRBool IncludeInContext(nsINode *aNode);
nsCOMPtr<nsIDocument> mDocument; nsCOMPtr<nsIDocument> mDocument;
nsCOMPtr<nsISelection> mSelection; nsCOMPtr<nsISelection> mSelection;
nsCOMPtr<nsIDOMRange> mRange; nsCOMPtr<nsIRange> mRange;
nsCOMPtr<nsIDOMNode> mNode; nsCOMPtr<nsINode> mNode;
nsCOMPtr<nsIOutputStream> mStream; nsCOMPtr<nsIOutputStream> mStream;
nsCOMPtr<nsIContentSerializer> mSerializer; nsCOMPtr<nsIContentSerializer> mSerializer;
nsCOMPtr<nsIUnicodeEncoder> mUnicodeEncoder; nsCOMPtr<nsIUnicodeEncoder> mUnicodeEncoder;
nsCOMPtr<nsIDOMNode> mCommonParent; nsCOMPtr<nsINode> mCommonParent;
nsCOMPtr<nsIDocumentEncoderNodeFixup> mNodeFixup; nsCOMPtr<nsIDocumentEncoderNodeFixup> mNodeFixup;
nsCOMPtr<nsICharsetConverterManager> mCharsetConverterManager; nsCOMPtr<nsICharsetConverterManager> mCharsetConverterManager;
@ -141,7 +142,7 @@ protected:
PRUint32 mEndDepth; PRUint32 mEndDepth;
PRInt32 mStartRootIndex; PRInt32 mStartRootIndex;
PRInt32 mEndRootIndex; PRInt32 mEndRootIndex;
nsAutoTArray<nsIDOMNode*, 8> mCommonAncestors; nsAutoTArray<nsINode*, 8> mCommonAncestors;
nsAutoTArray<nsIContent*, 8> mStartNodes; nsAutoTArray<nsIContent*, 8> mStartNodes;
nsAutoTArray<PRInt32, 8> mStartOffsets; nsAutoTArray<PRInt32, 8> mStartOffsets;
nsAutoTArray<nsIContent*, 8> mEndNodes; nsAutoTArray<nsIContent*, 8> mEndNodes;
@ -220,7 +221,7 @@ nsDocumentEncoder::SetSelection(nsISelection* aSelection)
NS_IMETHODIMP NS_IMETHODIMP
nsDocumentEncoder::SetRange(nsIDOMRange* aRange) nsDocumentEncoder::SetRange(nsIDOMRange* aRange)
{ {
mRange = aRange; mRange = do_QueryInterface(aRange);
return NS_OK; return NS_OK;
} }
@ -228,7 +229,7 @@ NS_IMETHODIMP
nsDocumentEncoder::SetNode(nsIDOMNode* aNode) nsDocumentEncoder::SetNode(nsIDOMNode* aNode)
{ {
mNodeIsContainer = PR_FALSE; mNodeIsContainer = PR_FALSE;
mNode = aNode; mNode = do_QueryInterface(aNode);
return NS_OK; return NS_OK;
} }
@ -236,7 +237,7 @@ NS_IMETHODIMP
nsDocumentEncoder::SetContainerNode(nsIDOMNode *aContainer) nsDocumentEncoder::SetContainerNode(nsIDOMNode *aContainer)
{ {
mNodeIsContainer = PR_TRUE; mNodeIsContainer = PR_TRUE;
mNode = aContainer; mNode = do_QueryInterface(aContainer);
return NS_OK; return NS_OK;
} }
@ -256,28 +257,33 @@ nsDocumentEncoder::GetMimeType(nsAString& aMimeType)
PRBool PRBool
nsDocumentEncoder::IncludeInContext(nsIDOMNode *aNode) nsDocumentEncoder::IncludeInContext(nsINode *aNode)
{ {
return PR_FALSE; return PR_FALSE;
} }
nsresult nsresult
nsDocumentEncoder::SerializeNodeStart(nsIDOMNode* aNode, nsDocumentEncoder::SerializeNodeStart(nsINode* aNode,
PRInt32 aStartOffset, PRInt32 aStartOffset,
PRInt32 aEndOffset, PRInt32 aEndOffset,
nsAString& aStr, nsAString& aStr,
nsIDOMNode* aOriginalNode) nsINode* aOriginalNode)
{ {
PRUint16 type; PRUint16 type;
nsCOMPtr<nsIDOMNode> node; nsINode* node = nsnull;
nsCOMPtr<nsINode> fixedNodeKungfuDeathGrip;
// Caller didn't do fixup, so we'll do it ourselves // Caller didn't do fixup, so we'll do it ourselves
if (!aOriginalNode) { if (!aOriginalNode) {
aOriginalNode = aNode; aOriginalNode = aNode;
if (mNodeFixup) { if (mNodeFixup) {
PRBool dummy; PRBool dummy;
mNodeFixup->FixupNode(aNode, &dummy, getter_AddRefs(node)); nsCOMPtr<nsIDOMNode> domNodeIn = do_QueryInterface(aNode);
nsCOMPtr<nsIDOMNode> domNodeOut;
mNodeFixup->FixupNode(domNodeIn, &dummy, getter_AddRefs(domNodeOut));
fixedNodeKungfuDeathGrip = do_QueryInterface(domNodeOut);
node = fixedNodeKungfuDeathGrip;
} }
} }
@ -286,6 +292,7 @@ nsDocumentEncoder::SerializeNodeStart(nsIDOMNode* aNode,
if (!node) if (!node)
node = aNode; node = aNode;
//XXX Remove QIing to nsIDOM* when fixing bug 562321.
node->GetNodeType(&type); node->GetNodeType(&type);
switch (type) { switch (type) {
case nsIDOMNode::ELEMENT_NODE: case nsIDOMNode::ELEMENT_NODE:
@ -327,48 +334,47 @@ nsDocumentEncoder::SerializeNodeStart(nsIDOMNode* aNode,
break; break;
} }
} }
return NS_OK; return NS_OK;
} }
nsresult nsresult
nsDocumentEncoder::SerializeNodeEnd(nsIDOMNode* aNode, nsDocumentEncoder::SerializeNodeEnd(nsINode* aNode,
nsAString& aStr) nsAString& aStr)
{ {
PRUint16 type; //XXX Remove QIing to nsIDOM* when fixing bug 562321.
if (aNode->IsNodeOfType(nsINode::eELEMENT)) {
aNode->GetNodeType(&type); nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
switch (type) { mSerializer->AppendElementEnd(element, aStr);
case nsIDOMNode::ELEMENT_NODE:
{
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
mSerializer->AppendElementEnd(element, aStr);
break;
}
} }
return NS_OK; return NS_OK;
} }
nsresult nsresult
nsDocumentEncoder::SerializeToStringRecursive(nsIDOMNode* aNode, nsDocumentEncoder::SerializeToStringRecursive(nsINode* aNode,
nsAString& aStr, nsAString& aStr,
PRBool aDontSerializeRoot) PRBool aDontSerializeRoot)
{ {
nsresult rv = NS_OK; nsresult rv = NS_OK;
PRBool serializeClonedChildren = PR_FALSE; PRBool serializeClonedChildren = PR_FALSE;
nsCOMPtr<nsIDOMNode> maybeFixedNode; nsINode* maybeFixedNode = nsnull;
if (mNodeFixup) // Keep the node from FixupNode alive.
mNodeFixup->FixupNode(aNode, &serializeClonedChildren, getter_AddRefs(maybeFixedNode)); nsCOMPtr<nsINode> fixedNodeKungfuDeathGrip;
if (mNodeFixup) {
nsCOMPtr<nsIDOMNode> domNodeIn = do_QueryInterface(aNode);
nsCOMPtr<nsIDOMNode> domNodeOut;
mNodeFixup->FixupNode(domNodeIn, &serializeClonedChildren, getter_AddRefs(domNodeOut));
fixedNodeKungfuDeathGrip = do_QueryInterface(domNodeOut);
maybeFixedNode = fixedNodeKungfuDeathGrip;
}
if (!maybeFixedNode) if (!maybeFixedNode)
maybeFixedNode = aNode; maybeFixedNode = aNode;
if (mIsCopying) { if (mIsCopying) {
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode); if (aNode->IsNodeOfType(nsINode::eCONTENT)) {
if (content){ nsIFrame* frame = static_cast<nsIContent*>(aNode)->GetPrimaryFrame();
nsIFrame* frame = content->GetPrimaryFrame();
if (frame) { if (frame) {
PRBool isSelectable; PRBool isSelectable;
frame->IsSelectable(&isSelectable, nsnull); frame->IsSelectable(&isSelectable, nsnull);
@ -384,32 +390,11 @@ nsDocumentEncoder::SerializeToStringRecursive(nsIDOMNode* aNode,
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
nsIDOMNode *node; nsINode* node = serializeClonedChildren ? maybeFixedNode : aNode;
if (serializeClonedChildren)
node = maybeFixedNode;
else
node = aNode;
PRBool hasChildren = PR_FALSE; for (nsINode::ChildIterator iter(node); !iter.IsDone(); iter.Next()) {
node->HasChildNodes(&hasChildren); rv = SerializeToStringRecursive(iter, aStr, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
if (hasChildren) {
nsCOMPtr<nsIDOMNodeList> childNodes;
rv = node->GetChildNodes(getter_AddRefs(childNodes));
NS_ENSURE_TRUE(childNodes, NS_SUCCEEDED(rv) ? NS_ERROR_FAILURE : rv);
PRInt32 index, count;
childNodes->GetLength((PRUint32*)&count);
for (index = 0; index < count; index++) {
nsCOMPtr<nsIDOMNode> child;
rv = childNodes->Item(index, getter_AddRefs(child));
NS_ENSURE_SUCCESS(rv, rv);
rv = SerializeToStringRecursive(child, aStr, PR_FALSE);
NS_ENSURE_SUCCESS(rv, rv);
}
} }
if (!aDontSerializeRoot) { if (!aDontSerializeRoot) {
@ -421,10 +406,9 @@ nsDocumentEncoder::SerializeToStringRecursive(nsIDOMNode* aNode,
} }
PRBool PRBool
nsDocumentEncoder::IsTag(nsIDOMNode* aNode, nsIAtom* aAtom) nsDocumentEncoder::IsTag(nsIContent* aContent, nsIAtom* aAtom)
{ {
nsCOMPtr<nsIContent> content = do_QueryInterface(aNode); return aContent && aContent->Tag() == aAtom;
return content && content->Tag() == aAtom;
} }
static nsresult static nsresult
@ -635,15 +619,9 @@ static nsresult GetNextNode(nsIDOMNode* aNode, nsTArray<PRInt32>& aIndexArray,
} }
#endif #endif
static PRBool IsTextNode(nsIDOMNode *aNode) static PRBool IsTextNode(nsINode *aNode)
{ {
if (!aNode) return PR_FALSE; return aNode && aNode->IsNodeOfType(nsINode::eTEXT);
PRUint16 nodeType;
aNode->GetNodeType(&nodeType);
if (nodeType == nsIDOMNode::TEXT_NODE ||
nodeType == nsIDOMNode::CDATA_SECTION_NODE)
return PR_TRUE;
return PR_FALSE;
} }
static nsresult GetLengthOfDOMNode(nsIDOMNode *aNode, PRUint32 &aCount) static nsresult GetLengthOfDOMNode(nsIDOMNode *aNode, PRUint32 &aCount)
@ -673,8 +651,8 @@ static nsresult GetLengthOfDOMNode(nsIDOMNode *aNode, PRUint32 &aCount)
} }
nsresult nsresult
nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange, nsDocumentEncoder::SerializeRangeNodes(nsIRange* aRange,
nsIDOMNode* aNode, nsINode* aNode,
nsAString& aString, nsAString& aString,
PRInt32 aDepth) PRInt32 aDepth)
{ {
@ -704,19 +682,18 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
{ {
// due to implementation it is impossible for text node to be both start and end of // due to implementation it is impossible for text node to be both start and end of
// range. We would have handled that case without getting here. // range. We would have handled that case without getting here.
//XXXsmaug What does this all mean?
if (IsTextNode(aNode)) if (IsTextNode(aNode))
{ {
if (startNode == content) if (startNode == content)
{ {
PRInt32 startOffset; PRInt32 startOffset = aRange->StartOffset();
aRange->GetStartOffset(&startOffset);
rv = SerializeNodeStart(aNode, startOffset, -1, aString); rv = SerializeNodeStart(aNode, startOffset, -1, aString);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
else else
{ {
PRInt32 endOffset; PRInt32 endOffset = aRange->EndOffset();
aRange->GetEndOffset(&endOffset);
rv = SerializeNodeStart(aNode, 0, endOffset, aString); rv = SerializeNodeStart(aNode, 0, endOffset, aString);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
@ -741,7 +718,7 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
// do some calculations that will tell us which children of this // do some calculations that will tell us which children of this
// node are in the range. // node are in the range.
nsCOMPtr<nsIDOMNode> childAsNode; nsIContent* childAsNode = nsnull;
PRInt32 startOffset = 0, endOffset = -1; PRInt32 startOffset = 0, endOffset = -1;
if (startNode == content && mStartRootIndex >= aDepth) if (startNode == content && mStartRootIndex >= aDepth)
startOffset = mStartOffsets[mStartRootIndex - aDepth]; startOffset = mStartOffsets[mStartRootIndex - aDepth];
@ -761,9 +738,7 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
// intermediate points on the list use the endOffset of the // intermediate points on the list use the endOffset of the
// location of the ancestor, rather than just past it. So we need // location of the ancestor, rather than just past it. So we need
// to add one here in order to include it in the children we serialize. // to add one here in order to include it in the children we serialize.
nsCOMPtr<nsIDOMNode> endParent; if (aNode != aRange->GetEndParent())
aRange->GetEndContainer(getter_AddRefs(endParent));
if (aNode != endParent)
{ {
endOffset++; endOffset++;
} }
@ -771,7 +746,7 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
// serialize the children of this node that are in the range // serialize the children of this node that are in the range
for (j=startOffset; j<endOffset; j++) for (j=startOffset; j<endOffset; j++)
{ {
childAsNode = do_QueryInterface(content->GetChildAt(j)); childAsNode = content->GetChildAt(j);
if ((j==startOffset) || (j==endOffset-1)) if ((j==startOffset) || (j==endOffset-1))
rv = SerializeRangeNodes(aRange, childAsNode, aString, aDepth+1); rv = SerializeRangeNodes(aRange, childAsNode, aString, aDepth+1);
@ -793,14 +768,14 @@ nsDocumentEncoder::SerializeRangeNodes(nsIDOMRange* aRange,
} }
nsresult nsresult
nsDocumentEncoder::SerializeRangeContextStart(const nsTArray<nsIDOMNode*>& aAncestorArray, nsDocumentEncoder::SerializeRangeContextStart(const nsTArray<nsINode*>& aAncestorArray,
nsAString& aString) nsAString& aString)
{ {
PRInt32 i = aAncestorArray.Length(); PRInt32 i = aAncestorArray.Length();
nsresult rv = NS_OK; nsresult rv = NS_OK;
while (i > 0) { while (i > 0) {
nsIDOMNode *node = aAncestorArray.ElementAt(--i); nsINode *node = aAncestorArray.ElementAt(--i);
if (!node) if (!node)
break; break;
@ -817,7 +792,7 @@ nsDocumentEncoder::SerializeRangeContextStart(const nsTArray<nsIDOMNode*>& aAnce
} }
nsresult nsresult
nsDocumentEncoder::SerializeRangeContextEnd(const nsTArray<nsIDOMNode*>& aAncestorArray, nsDocumentEncoder::SerializeRangeContextEnd(const nsTArray<nsINode*>& aAncestorArray,
nsAString& aString) nsAString& aString)
{ {
PRInt32 i = 0; PRInt32 i = 0;
@ -825,7 +800,7 @@ nsDocumentEncoder::SerializeRangeContextEnd(const nsTArray<nsIDOMNode*>& aAncest
nsresult rv = NS_OK; nsresult rv = NS_OK;
while (i < count) { while (i < count) {
nsIDOMNode *node = aAncestorArray.ElementAt(i++); nsINode *node = aAncestorArray.ElementAt(i++);
if (!node) if (!node)
break; break;
@ -842,34 +817,24 @@ nsDocumentEncoder::SerializeRangeContextEnd(const nsTArray<nsIDOMNode*>& aAncest
} }
nsresult nsresult
nsDocumentEncoder::SerializeRangeToString(nsIDOMRange *aRange, nsDocumentEncoder::SerializeRangeToString(nsIRange *aRange,
nsAString& aOutputString) nsAString& aOutputString)
{ {
if (!aRange) if (!aRange || aRange->Collapsed())
return NS_OK; return NS_OK;
PRBool collapsed; mCommonParent = aRange->GetCommonAncestor();
aRange->GetCollapsed(&collapsed);
if (collapsed)
return NS_OK;
nsCOMPtr<nsIDOMNode> startParent, endParent;
PRInt32 startOffset, endOffset;
aRange->GetCommonAncestorContainer(getter_AddRefs(mCommonParent));
if (!mCommonParent) if (!mCommonParent)
return NS_OK; return NS_OK;
aRange->GetStartContainer(getter_AddRefs(startParent)); nsINode* startParent = aRange->GetStartParent();
NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE); NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
aRange->GetStartOffset(&startOffset); PRInt32 startOffset = aRange->StartOffset();
aRange->GetEndContainer(getter_AddRefs(endParent)); nsINode* endParent = aRange->GetEndParent();
NS_ENSURE_TRUE(endParent, NS_ERROR_FAILURE); NS_ENSURE_TRUE(endParent, NS_ERROR_FAILURE);
aRange->GetEndOffset(&endOffset); PRInt32 endOffset = aRange->EndOffset();
mCommonAncestors.Clear(); mCommonAncestors.Clear();
mStartNodes.Clear(); mStartNodes.Clear();
@ -877,10 +842,12 @@ nsDocumentEncoder::SerializeRangeToString(nsIDOMRange *aRange,
mEndNodes.Clear(); mEndNodes.Clear();
mEndOffsets.Clear(); mEndOffsets.Clear();
nsContentUtils::GetAncestors(mCommonParent, &mCommonAncestors); nsContentUtils::GetAncestors(mCommonParent, mCommonAncestors);
nsContentUtils::GetAncestorsAndOffsets(startParent, startOffset, nsCOMPtr<nsIDOMNode> sp = do_QueryInterface(startParent);
nsContentUtils::GetAncestorsAndOffsets(sp, startOffset,
&mStartNodes, &mStartOffsets); &mStartNodes, &mStartOffsets);
nsContentUtils::GetAncestorsAndOffsets(endParent, endOffset, nsCOMPtr<nsIDOMNode> ep = do_QueryInterface(endParent);
nsContentUtils::GetAncestorsAndOffsets(ep, endOffset,
&mEndNodes, &mEndOffsets); &mEndNodes, &mEndOffsets);
nsCOMPtr<nsIContent> commonContent = do_QueryInterface(mCommonParent); nsCOMPtr<nsIContent> commonContent = do_QueryInterface(mCommonParent);
@ -953,23 +920,27 @@ nsDocumentEncoder::EncodeToString(nsAString& aOutputString)
NS_ENSURE_TRUE(node, NS_ERROR_FAILURE); NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
if (node != prevNode) { if (node != prevNode) {
if (prevNode) { if (prevNode) {
rv = SerializeNodeEnd(prevNode, aOutputString); nsCOMPtr<nsINode> p = do_QueryInterface(prevNode);
rv = SerializeNodeEnd(p, aOutputString);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
prevNode = nsnull; prevNode = nsnull;
} }
nsCOMPtr<nsIContent> content = do_QueryInterface(node); nsCOMPtr<nsIContent> content = do_QueryInterface(node);
if (content && content->Tag() == nsGkAtoms::tr) { if (content && content->Tag() == nsGkAtoms::tr) {
rv = SerializeNodeStart(node, 0, -1, aOutputString); nsCOMPtr<nsINode> n = do_QueryInterface(node);
rv = SerializeNodeStart(n, 0, -1, aOutputString);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
prevNode = node; prevNode = node;
} }
} }
rv = SerializeRangeToString(range, aOutputString); nsCOMPtr<nsIRange> r = do_QueryInterface(range);
rv = SerializeRangeToString(r, aOutputString);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
if (prevNode) { if (prevNode) {
rv = SerializeNodeEnd(prevNode, aOutputString); nsCOMPtr<nsINode> p = do_QueryInterface(prevNode);
rv = SerializeNodeEnd(p, aOutputString);
NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_SUCCESS(rv, rv);
} }
@ -986,9 +957,7 @@ nsDocumentEncoder::EncodeToString(nsAString& aOutputString)
rv = mSerializer->AppendDocumentStart(domdoc, aOutputString); rv = mSerializer->AppendDocumentStart(domdoc, aOutputString);
if (NS_SUCCEEDED(rv)) { if (NS_SUCCEEDED(rv)) {
nsCOMPtr<nsIDOMNode> doc(do_QueryInterface(mDocument)); rv = SerializeToStringRecursive(mDocument, aOutputString, PR_FALSE);
rv = SerializeToStringRecursive(doc, aOutputString, PR_FALSE);
} }
} }
@ -1099,7 +1068,7 @@ protected:
PRBool IsFirstNode(nsIDOMNode *aNode); PRBool IsFirstNode(nsIDOMNode *aNode);
PRBool IsLastNode(nsIDOMNode *aNode); PRBool IsLastNode(nsIDOMNode *aNode);
PRBool IsEmptyTextContent(nsIDOMNode* aNode); PRBool IsEmptyTextContent(nsIDOMNode* aNode);
virtual PRBool IncludeInContext(nsIDOMNode *aNode); virtual PRBool IncludeInContext(nsINode *aNode);
PRBool mIsTextWidget; PRBool mIsTextWidget;
}; };
@ -1274,7 +1243,7 @@ nsHTMLCopyEncoder::EncodeToStringWithContext(nsAString& aContextString,
// leaf of ancestors might be text node. If so discard it. // leaf of ancestors might be text node. If so discard it.
PRInt32 count = mCommonAncestors.Length(); PRInt32 count = mCommonAncestors.Length();
PRInt32 i; PRInt32 i;
nsCOMPtr<nsIDOMNode> node; nsCOMPtr<nsINode> node;
if (count > 0) if (count > 0)
node = mCommonAncestors.ElementAt(0); node = mCommonAncestors.ElementAt(0);
@ -1315,7 +1284,7 @@ nsHTMLCopyEncoder::EncodeToStringWithContext(nsAString& aContextString,
PRBool PRBool
nsHTMLCopyEncoder::IncludeInContext(nsIDOMNode *aNode) nsHTMLCopyEncoder::IncludeInContext(nsINode *aNode)
{ {
nsCOMPtr<nsIContent> content(do_QueryInterface(aNode)); nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));
@ -1471,7 +1440,8 @@ nsHTMLCopyEncoder::GetPromotedPoint(Endpoint aWhere, nsIDOMNode *aNode, PRInt32
if (aWhere == kStart) if (aWhere == kStart)
{ {
// some special casing for text nodes // some special casing for text nodes
if (IsTextNode(aNode)) nsCOMPtr<nsINode> t = do_QueryInterface(aNode);
if (IsTextNode(t))
{ {
// if not at beginning of text node, we are done // if not at beginning of text node, we are done
if (offset > 0) if (offset > 0)
@ -1551,7 +1521,8 @@ nsHTMLCopyEncoder::GetPromotedPoint(Endpoint aWhere, nsIDOMNode *aNode, PRInt32
if (aWhere == kEnd) if (aWhere == kEnd)
{ {
// some special casing for text nodes // some special casing for text nodes
if (IsTextNode(aNode)) nsCOMPtr<nsINode> n = do_QueryInterface(aNode);
if (IsTextNode(n))
{ {
// if not at end of text node, we are done // if not at end of text node, we are done
PRUint32 len; PRUint32 len;
@ -1653,7 +1624,8 @@ nsHTMLCopyEncoder::GetChildAt(nsIDOMNode *aParent, PRInt32 aOffset)
PRBool PRBool
nsHTMLCopyEncoder::IsMozBR(nsIDOMNode* aNode) nsHTMLCopyEncoder::IsMozBR(nsIDOMNode* aNode)
{ {
if (IsTag(aNode, nsGkAtoms::br)) nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
if (IsTag(content, nsGkAtoms::br))
{ {
nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(aNode); nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(aNode);
if (elem) if (elem)
@ -1696,14 +1668,15 @@ nsHTMLCopyEncoder::GetNodeLocation(nsIDOMNode *inChild,
PRBool PRBool
nsHTMLCopyEncoder::IsRoot(nsIDOMNode* aNode) nsHTMLCopyEncoder::IsRoot(nsIDOMNode* aNode)
{ {
if (aNode) nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
if (content)
{ {
if (mIsTextWidget) if (mIsTextWidget)
return (IsTag(aNode, nsGkAtoms::div)); return (IsTag(content, nsGkAtoms::div));
else
return (IsTag(aNode, nsGkAtoms::body) || return (IsTag(content, nsGkAtoms::body) ||
IsTag(aNode, nsGkAtoms::td) || IsTag(content, nsGkAtoms::td) ||
IsTag(aNode, nsGkAtoms::th)); IsTag(content, nsGkAtoms::th));
} }
return PR_FALSE; return PR_FALSE;
} }