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

content/base/public/nsContentUtils.h

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

content/base/src/nsContentUtils.cpp

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

content/base/src/nsDocumentEncoder.cpp

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