Bug 181137 - part 1: Move nsContentIterator and nsContentSubtreeIterator into mozilla namespace r=smaug
authorMasayuki Nakano <masayuki@d-toybox.com>
Fri, 11 Jan 2019 01:47:15 +0000
changeset 453432 2eaf630d9925af4570a6dda6a2cf8d7cdf604142
parent 453431 908518e471cc31f9ae277ccf1873865df0ef7c7f
child 453433 a29d33c6fca1a10e5fe337c4b223578cf2f51acb
push id35357
push usernerli@mozilla.com
push dateFri, 11 Jan 2019 21:54:07 +0000
treeherdermozilla-central@0ce024c91511 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerssmaug
bugs181137
milestone66.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 181137 - part 1: Move nsContentIterator and nsContentSubtreeIterator into mozilla namespace r=smaug First, we should move nsContentIterator and nsContentSubtreeIterator into mozilla namespace and then, remove "ns" prefix. Additionally, this patch separates the definition of the classes into ContentIterator.h and exposes it as "mozilla/ContentIterator.h". This allows everybody access those concrete classes. Differential Revision: https://phabricator.services.mozilla.com/D15917
dom/base/ContentIterator.cpp
dom/base/ContentIterator.h
dom/base/moz.build
dom/base/nsContentIterator.cpp
dom/base/test/test_bug976673.html
dom/base/test/test_content_iterator_subtree.html
dom/events/ContentEventHandler.cpp
dom/events/IMEContentObserver.cpp
rename from dom/base/nsContentIterator.cpp
rename to dom/base/ContentIterator.cpp
--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/ContentIterator.cpp
@@ -1,30 +1,40 @@
 /* -*- 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/. */
 
+#include "ContentIterator.h"
+
 #include "mozilla/DebugOnly.h"
-#include "nsISupports.h"
-#include "nsIContentIterator.h"
-#include "nsRange.h"
-#include "nsIContent.h"
-#include "nsCOMPtr.h"
-#include "nsTArray.h"
+#include "mozilla/RangeBoundary.h"
+
 #include "nsContentUtils.h"
-#include "nsINode.h"
-#include "nsCycleCollectionParticipant.h"
 #include "nsElementTable.h"
+#include "nsIContent.h"
+#include "nsRange.h"
+
+already_AddRefed<nsIContentIterator> NS_NewContentIterator() {
+  nsCOMPtr<nsIContentIterator> iter = new mozilla::ContentIterator(false);
+  return iter.forget();
+}
 
-using mozilla::DebugOnly;
-using mozilla::RawRangeBoundary;
+already_AddRefed<nsIContentIterator> NS_NewPreContentIterator() {
+  nsCOMPtr<nsIContentIterator> iter = new mozilla::ContentIterator(true);
+  return iter.forget();
+}
 
-// couple of utility static functs
+already_AddRefed<nsIContentIterator> NS_NewContentSubtreeIterator() {
+  nsCOMPtr<nsIContentIterator> iter = new mozilla::ContentSubtreeIterator();
+  return iter.forget();
+}
+
+namespace mozilla {
 
 ///////////////////////////////////////////////////////////////////////////
 // NodeIsInTraversalRange: returns true if content is visited during
 // the traversal of the range in the specified mode.
 //
 static bool NodeIsInTraversalRange(nsINode* aNode, bool aIsPreMode,
                                    const RawRangeBoundary& aStart,
                                    const RawRangeBoundary& aEnd) {
@@ -68,149 +78,43 @@ static bool NodeIsInTraversalRange(nsINo
   }
 
   // Pre mode: start <= node < end.
   RawRangeBoundary beforeNode(parent, aNode->GetPreviousSibling());
   return nsContentUtils::ComparePoints(aStart, beforeNode) <= 0 &&
          nsContentUtils::ComparePoints(aEnd, beforeNode) > 0;
 }
 
-/*
- *  A simple iterator class for traversing the content in "close tag" order
- */
-class nsContentIterator : public nsIContentIterator {
- public:
-  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_CLASS(nsContentIterator)
-
-  explicit nsContentIterator(bool aPre);
-
-  // nsIContentIterator interface methods ------------------------------
-
-  virtual nsresult Init(nsINode* aRoot) override;
-
-  virtual nsresult Init(nsRange* aRange) override;
-
-  virtual nsresult Init(nsINode* aStartContainer, uint32_t aStartOffset,
-                        nsINode* aEndContainer, uint32_t aEndOffset) override;
-
-  virtual nsresult Init(const RawRangeBoundary& aStart,
-                        const RawRangeBoundary& aEnd) override;
-
-  virtual void First() override;
-
-  virtual void Last() override;
-
-  virtual void Next() override;
-
-  virtual void Prev() override;
-
-  virtual nsINode* GetCurrentNode() override;
-
-  virtual bool IsDone() override;
-
-  virtual nsresult PositionAt(nsINode* aCurNode) override;
-
- protected:
-  virtual ~nsContentIterator();
-
-  /**
-   * Callers must guarantee that:
-   * - Neither aStartContainer nor aEndContainer is nullptr.
-   * - aStartOffset and aEndOffset are valid for its container.
-   * - The start point and the end point are in document order.
-   */
-  nsresult InitInternal(const RawRangeBoundary& aStart,
-                        const RawRangeBoundary& aEnd);
-
-  // Recursively get the deepest first/last child of aRoot.  This will return
-  // aRoot itself if it has no children.
-  nsINode* GetDeepFirstChild(nsINode* aRoot);
-  nsIContent* GetDeepFirstChild(nsIContent* aRoot);
-  nsINode* GetDeepLastChild(nsINode* aRoot);
-  nsIContent* GetDeepLastChild(nsIContent* aRoot);
-
-  // Get the next/previous sibling of aNode, or its parent's, or grandparent's,
-  // etc.  Returns null if aNode and all its ancestors have no next/previous
-  // sibling.
-  nsIContent* GetNextSibling(nsINode* aNode);
-  nsIContent* GetPrevSibling(nsINode* aNode);
-
-  nsINode* NextNode(nsINode* aNode);
-  nsINode* PrevNode(nsINode* aNode);
-
-  void MakeEmpty();
-
-  virtual void LastRelease();
-
-  nsCOMPtr<nsINode> mCurNode;
-  nsCOMPtr<nsINode> mFirst;
-  nsCOMPtr<nsINode> mLast;
-  nsCOMPtr<nsINode> mCommonParent;
-
-  bool mIsDone;
-  bool mPre;
-
- private:
-  // no copies or assigns  FIX ME
-  nsContentIterator(const nsContentIterator&);
-  nsContentIterator& operator=(const nsContentIterator&);
-};
-
-/******************************************************
- * repository cruft
- ******************************************************/
-
-already_AddRefed<nsIContentIterator> NS_NewContentIterator() {
-  nsCOMPtr<nsIContentIterator> iter = new nsContentIterator(false);
-  return iter.forget();
-}
-
-already_AddRefed<nsIContentIterator> NS_NewPreContentIterator() {
-  nsCOMPtr<nsIContentIterator> iter = new nsContentIterator(true);
-  return iter.forget();
-}
-
-/******************************************************
- * XPCOM cruft
- ******************************************************/
-
-NS_IMPL_CYCLE_COLLECTING_ADDREF(nsContentIterator)
-NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(nsContentIterator,
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ContentIterator)
+NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(ContentIterator,
                                                    LastRelease())
 
-NS_INTERFACE_MAP_BEGIN(nsContentIterator)
+NS_INTERFACE_MAP_BEGIN(ContentIterator)
   NS_INTERFACE_MAP_ENTRY(nsIContentIterator)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentIterator)
-  NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsContentIterator)
+  NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(ContentIterator)
 NS_INTERFACE_MAP_END
 
-NS_IMPL_CYCLE_COLLECTION(nsContentIterator, mCurNode, mFirst, mLast,
+NS_IMPL_CYCLE_COLLECTION(ContentIterator, mCurNode, mFirst, mLast,
                          mCommonParent)
 
-void nsContentIterator::LastRelease() {
+void ContentIterator::LastRelease() {
   mCurNode = nullptr;
   mFirst = nullptr;
   mLast = nullptr;
   mCommonParent = nullptr;
 }
 
-/******************************************************
- * constructor/destructor
- ******************************************************/
-
-nsContentIterator::nsContentIterator(bool aPre) : mIsDone(false), mPre(aPre) {}
-
-nsContentIterator::~nsContentIterator() {}
+ContentIterator::ContentIterator(bool aPre) : mIsDone(false), mPre(aPre) {}
 
 /******************************************************
  * Init routines
  ******************************************************/
 
-nsresult nsContentIterator::Init(nsINode* aRoot) {
+nsresult ContentIterator::Init(nsINode* aRoot) {
   if (NS_WARN_IF(!aRoot)) {
     return NS_ERROR_NULL_POINTER;
   }
 
   mIsDone = false;
 
   if (mPre) {
     mFirst = aRoot;
@@ -222,58 +126,57 @@ nsresult nsContentIterator::Init(nsINode
     mLast = aRoot;
   }
 
   mCommonParent = aRoot;
   mCurNode = mFirst;
   return NS_OK;
 }
 
-nsresult nsContentIterator::Init(nsRange* aRange) {
+nsresult ContentIterator::Init(nsRange* aRange) {
   mIsDone = false;
 
   if (NS_WARN_IF(!aRange)) {
     return NS_ERROR_INVALID_ARG;
   }
 
   if (NS_WARN_IF(!aRange->IsPositioned())) {
     return NS_ERROR_INVALID_ARG;
   }
 
   return InitInternal(aRange->StartRef().AsRaw(), aRange->EndRef().AsRaw());
 }
 
-nsresult nsContentIterator::Init(nsINode* aStartContainer,
-                                 uint32_t aStartOffset, nsINode* aEndContainer,
-                                 uint32_t aEndOffset) {
+nsresult ContentIterator::Init(nsINode* aStartContainer, uint32_t aStartOffset,
+                               nsINode* aEndContainer, uint32_t aEndOffset) {
   mIsDone = false;
 
   if (NS_WARN_IF(!nsRange::IsValidPoints(aStartContainer, aStartOffset,
                                          aEndContainer, aEndOffset))) {
     return NS_ERROR_INVALID_ARG;
   }
 
   return InitInternal(RawRangeBoundary(aStartContainer, aStartOffset),
                       RawRangeBoundary(aEndContainer, aEndOffset));
 }
 
-nsresult nsContentIterator::Init(const RawRangeBoundary& aStart,
-                                 const RawRangeBoundary& aEnd) {
+nsresult ContentIterator::Init(const RawRangeBoundary& aStart,
+                               const RawRangeBoundary& aEnd) {
   mIsDone = false;
 
   if (NS_WARN_IF(!nsRange::IsValidPoints(aStart.Container(), aStart.Offset(),
                                          aEnd.Container(), aEnd.Offset()))) {
     return NS_ERROR_INVALID_ARG;
   }
 
   return InitInternal(aStart, aEnd);
 }
 
-nsresult nsContentIterator::InitInternal(const RawRangeBoundary& aStart,
-                                         const RawRangeBoundary& aEnd) {
+nsresult ContentIterator::InitInternal(const RawRangeBoundary& aStart,
+                                       const RawRangeBoundary& aEnd) {
   // get common content parent
   mCommonParent =
       nsContentUtils::GetCommonAncestor(aStart.Container(), aEnd.Container());
   if (NS_WARN_IF(!mCommonParent)) {
     return NS_ERROR_FAILURE;
   }
 
   bool startIsData = aStart.Container()->IsCharacterData();
@@ -415,17 +318,17 @@ nsresult nsContentIterator::InitInternal
         mLast = aEnd.Container()->AsContent();
       }
     }
   } else {
     cChild = aEnd.Ref();
 
     if (NS_WARN_IF(!cChild)) {
       // No child at offset!
-      MOZ_ASSERT_UNREACHABLE("nsContentIterator::nsContentIterator");
+      MOZ_ASSERT_UNREACHABLE("ContentIterator::ContentIterator");
       return NS_ERROR_FAILURE;
     }
 
     if (mPre) {
       mLast = GetDeepLastChild(cChild);
       NS_WARNING_ASSERTION(mLast, "GetDeepLastChild returned null");
 
       if (NS_WARN_IF(!NodeIsInTraversalRange(mLast, mPre, aStart, aEnd))) {
@@ -445,71 +348,71 @@ nsresult nsContentIterator::InitInternal
   }
 
   mCurNode = mFirst;
   mIsDone = !mCurNode;
 
   return NS_OK;
 }
 
-void nsContentIterator::MakeEmpty() {
+void ContentIterator::MakeEmpty() {
   mCurNode = nullptr;
   mFirst = nullptr;
   mLast = nullptr;
   mCommonParent = nullptr;
   mIsDone = true;
 }
 
-nsINode* nsContentIterator::GetDeepFirstChild(nsINode* aRoot) {
+nsINode* ContentIterator::GetDeepFirstChild(nsINode* aRoot) {
   if (NS_WARN_IF(!aRoot) || !aRoot->HasChildren()) {
     return aRoot;
   }
 
   return GetDeepFirstChild(aRoot->GetFirstChild());
 }
 
-nsIContent* nsContentIterator::GetDeepFirstChild(nsIContent* aRoot) {
+nsIContent* ContentIterator::GetDeepFirstChild(nsIContent* aRoot) {
   if (NS_WARN_IF(!aRoot)) {
     return nullptr;
   }
 
   nsIContent* node = aRoot;
   nsIContent* child = node->GetFirstChild();
 
   while (child) {
     node = child;
     child = node->GetFirstChild();
   }
 
   return node;
 }
 
-nsINode* nsContentIterator::GetDeepLastChild(nsINode* aRoot) {
+nsINode* ContentIterator::GetDeepLastChild(nsINode* aRoot) {
   if (NS_WARN_IF(!aRoot) || !aRoot->HasChildren()) {
     return aRoot;
   }
 
   return GetDeepLastChild(aRoot->GetLastChild());
 }
 
-nsIContent* nsContentIterator::GetDeepLastChild(nsIContent* aRoot) {
+nsIContent* ContentIterator::GetDeepLastChild(nsIContent* aRoot) {
   if (NS_WARN_IF(!aRoot)) {
     return nullptr;
   }
 
   nsIContent* node = aRoot;
   while (node->HasChildren()) {
     nsIContent* child = node->GetLastChild();
     node = child;
   }
   return node;
 }
 
 // Get the next sibling, or parent's next sibling, or grandpa's next sibling...
-nsIContent* nsContentIterator::GetNextSibling(nsINode* aNode) {
+nsIContent* ContentIterator::GetNextSibling(nsINode* aNode) {
   if (NS_WARN_IF(!aNode)) {
     return nullptr;
   }
 
   if (aNode->GetNextSibling()) {
     return aNode->GetNextSibling();
   }
 
@@ -524,17 +427,17 @@ nsIContent* nsContentIterator::GetNextSi
   if (parent->GetLastChild() && parent->GetLastChild() != aNode) {
     return parent->GetFirstChild();
   }
 
   return GetNextSibling(parent);
 }
 
 // Get the prev sibling, or parent's prev sibling, or grandpa's prev sibling...
-nsIContent* nsContentIterator::GetPrevSibling(nsINode* aNode) {
+nsIContent* ContentIterator::GetPrevSibling(nsINode* aNode) {
   if (NS_WARN_IF(!aNode)) {
     return nullptr;
   }
 
   if (aNode->GetPreviousSibling()) {
     return aNode->GetPreviousSibling();
   }
 
@@ -548,17 +451,17 @@ nsIContent* nsContentIterator::GetPrevSi
   // the last child of our parent.
   if (parent->GetFirstChild() && parent->GetFirstChild() != aNode) {
     return parent->GetLastChild();
   }
 
   return GetPrevSibling(parent);
 }
 
-nsINode* nsContentIterator::NextNode(nsINode* aNode) {
+nsINode* ContentIterator::NextNode(nsINode* aNode) {
   nsINode* node = aNode;
 
   // if we are a Pre-order iterator, use pre-order
   if (mPre) {
     // if it has children then next node is first child
     if (node->HasChildren()) {
       nsIContent* firstChild = node->GetFirstChild();
       MOZ_ASSERT(firstChild);
@@ -582,17 +485,17 @@ nsINode* nsContentIterator::NextNode(nsI
   if (sibling) {
     // next node is sibling's "deep left" child
     return GetDeepFirstChild(sibling);
   }
 
   return parent;
 }
 
-nsINode* nsContentIterator::PrevNode(nsINode* aNode) {
+nsINode* ContentIterator::PrevNode(nsINode* aNode) {
   nsINode* node = aNode;
 
   // if we are a Pre-order iterator, use pre-order
   if (mPre) {
     nsINode* parent = node->GetParentNode();
     if (NS_WARN_IF(!parent)) {
       MOZ_ASSERT(parent, "The node is the root node but not the first node");
       mIsDone = true;
@@ -615,70 +518,70 @@ nsINode* nsContentIterator::PrevNode(nsI
   // else prev sibling is previous
   return GetPrevSibling(node);
 }
 
 /******************************************************
  * ContentIterator routines
  ******************************************************/
 
-void nsContentIterator::First() {
+void ContentIterator::First() {
   if (mFirst) {
     mozilla::DebugOnly<nsresult> rv = PositionAt(mFirst);
     NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to position iterator!");
   }
 
   mIsDone = mFirst == nullptr;
 }
 
-void nsContentIterator::Last() {
+void ContentIterator::Last() {
   // Note that mLast can be nullptr if MakeEmpty() is called in Init() since
   // at that time, Init() returns NS_OK.
   if (!mLast) {
     MOZ_ASSERT(mIsDone);
     return;
   }
 
   mozilla::DebugOnly<nsresult> rv = PositionAt(mLast);
   NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to position iterator!");
 
   mIsDone = mLast == nullptr;
 }
 
-void nsContentIterator::Next() {
+void ContentIterator::Next() {
   if (mIsDone || NS_WARN_IF(!mCurNode)) {
     return;
   }
 
   if (mCurNode == mLast) {
     mIsDone = true;
     return;
   }
 
   mCurNode = NextNode(mCurNode);
 }
 
-void nsContentIterator::Prev() {
+void ContentIterator::Prev() {
   if (NS_WARN_IF(mIsDone) || NS_WARN_IF(!mCurNode)) {
     return;
   }
 
   if (mCurNode == mFirst) {
     mIsDone = true;
     return;
   }
 
   mCurNode = PrevNode(mCurNode);
 }
 
-bool nsContentIterator::IsDone() { return mIsDone; }
+bool ContentIterator::IsDone() { return mIsDone; }
 
 // Keeping arrays of indexes for the stack of nodes makes PositionAt
 // interesting...
-nsresult nsContentIterator::PositionAt(nsINode* aCurNode) {
+nsresult ContentIterator::PositionAt(nsINode* aCurNode) {
   if (NS_WARN_IF(!aCurNode)) {
     return NS_ERROR_NULL_POINTER;
   }
 
   // take an early out if this doesn't actually change the position
   if (mCurNode == aCurNode) {
     mIsDone = false;
     return NS_OK;
@@ -727,149 +630,76 @@ nsresult nsContentIterator::PositionAt(n
     mIsDone = true;
     return NS_ERROR_FAILURE;
   }
 
   mIsDone = false;
   return NS_OK;
 }
 
-nsINode* nsContentIterator::GetCurrentNode() {
+nsINode* ContentIterator::GetCurrentNode() {
   if (mIsDone) {
     return nullptr;
   }
 
   NS_ASSERTION(mCurNode, "Null current node in an iterator that's not done!");
 
   return mCurNode;
 }
 
-/*====================================================================================*/
-/*====================================================================================*/
-
 /******************************************************
- * nsContentSubtreeIterator
+ * ContentSubtreeIterator
  ******************************************************/
 
-/*
- *  A simple iterator class for traversing the content in "top subtree" order
- */
-class nsContentSubtreeIterator : public nsContentIterator {
- public:
-  nsContentSubtreeIterator() : nsContentIterator(false) {}
-
-  NS_DECL_ISUPPORTS_INHERITED
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsContentSubtreeIterator,
-                                           nsContentIterator)
-
-  // nsContentIterator overrides ------------------------------
-
-  virtual nsresult Init(nsINode* aRoot) override;
-
-  virtual nsresult Init(nsRange* aRange) override;
-
-  virtual nsresult Init(nsINode* aStartContainer, uint32_t aStartOffset,
-                        nsINode* aEndContainer, uint32_t aEndOffset) override;
-
-  virtual nsresult Init(const RawRangeBoundary& aStart,
-                        const RawRangeBoundary& aEnd) override;
-
-  virtual void Next() override;
-
-  virtual void Prev() override;
-
-  virtual nsresult PositionAt(nsINode* aCurNode) override;
-
-  // Must override these because we don't do PositionAt
-  virtual void First() override;
+NS_IMPL_ADDREF_INHERITED(ContentSubtreeIterator, ContentIterator)
+NS_IMPL_RELEASE_INHERITED(ContentSubtreeIterator, ContentIterator)
 
-  // Must override these because we don't do PositionAt
-  virtual void Last() override;
-
- protected:
-  virtual ~nsContentSubtreeIterator() {}
-
-  /**
-   * Callers must guarantee that mRange isn't nullptr and is positioned.
-   */
-  nsresult InitWithRange();
-
-  // Returns the highest inclusive ancestor of aNode that's in the range
-  // (possibly aNode itself).  Returns null if aNode is null, or is not itself
-  // in the range.  A node is in the range if (node, 0) comes strictly after
-  // the range endpoint, and (node, node.length) comes strictly before it, so
-  // the range's start and end nodes will never be considered "in" it.
-  nsIContent* GetTopAncestorInRange(nsINode* aNode);
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ContentSubtreeIterator)
+NS_INTERFACE_MAP_END_INHERITING(ContentIterator)
 
-  // no copy's or assigns  FIX ME
-  nsContentSubtreeIterator(const nsContentSubtreeIterator&);
-  nsContentSubtreeIterator& operator=(const nsContentSubtreeIterator&);
-
-  virtual void LastRelease() override;
-
-  RefPtr<nsRange> mRange;
-
-  AutoTArray<nsIContent*, 8> mEndNodes;
-};
-
-NS_IMPL_ADDREF_INHERITED(nsContentSubtreeIterator, nsContentIterator)
-NS_IMPL_RELEASE_INHERITED(nsContentSubtreeIterator, nsContentIterator)
-
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsContentSubtreeIterator)
-NS_INTERFACE_MAP_END_INHERITING(nsContentIterator)
-
-NS_IMPL_CYCLE_COLLECTION_INHERITED(nsContentSubtreeIterator, nsContentIterator,
+NS_IMPL_CYCLE_COLLECTION_INHERITED(ContentSubtreeIterator, ContentIterator,
                                    mRange)
 
-void nsContentSubtreeIterator::LastRelease() {
+void ContentSubtreeIterator::LastRelease() {
   mRange = nullptr;
-  nsContentIterator::LastRelease();
-}
-
-/******************************************************
- * repository cruft
- ******************************************************/
-
-already_AddRefed<nsIContentIterator> NS_NewContentSubtreeIterator() {
-  nsCOMPtr<nsIContentIterator> iter = new nsContentSubtreeIterator();
-  return iter.forget();
+  ContentIterator::LastRelease();
 }
 
 /******************************************************
  * Init routines
  ******************************************************/
 
-nsresult nsContentSubtreeIterator::Init(nsINode* aRoot) {
+nsresult ContentSubtreeIterator::Init(nsINode* aRoot) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
-nsresult nsContentSubtreeIterator::Init(nsRange* aRange) {
+nsresult ContentSubtreeIterator::Init(nsRange* aRange) {
   MOZ_ASSERT(aRange);
 
   mIsDone = false;
 
   if (NS_WARN_IF(!aRange->IsPositioned())) {
     return NS_ERROR_INVALID_ARG;
   }
 
   mRange = aRange;
 
   return InitWithRange();
 }
 
-nsresult nsContentSubtreeIterator::Init(nsINode* aStartContainer,
-                                        uint32_t aStartOffset,
-                                        nsINode* aEndContainer,
-                                        uint32_t aEndOffset) {
+nsresult ContentSubtreeIterator::Init(nsINode* aStartContainer,
+                                      uint32_t aStartOffset,
+                                      nsINode* aEndContainer,
+                                      uint32_t aEndOffset) {
   return Init(RawRangeBoundary(aStartContainer, aStartOffset),
               RawRangeBoundary(aEndContainer, aEndOffset));
 }
 
-nsresult nsContentSubtreeIterator::Init(const RawRangeBoundary& aStart,
-                                        const RawRangeBoundary& aEnd) {
+nsresult ContentSubtreeIterator::Init(const RawRangeBoundary& aStart,
+                                      const RawRangeBoundary& aEnd) {
   mIsDone = false;
 
   RefPtr<nsRange> range;
   nsresult rv = nsRange::CreateRange(aStart, aEnd, getter_AddRefs(range));
   if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(!range) ||
       NS_WARN_IF(!range->IsPositioned())) {
     return NS_ERROR_INVALID_ARG;
   }
@@ -879,17 +709,17 @@ nsresult nsContentSubtreeIterator::Init(
     return NS_ERROR_UNEXPECTED;
   }
 
   mRange = std::move(range);
 
   return InitWithRange();
 }
 
-nsresult nsContentSubtreeIterator::InitWithRange() {
+nsresult ContentSubtreeIterator::InitWithRange() {
   MOZ_ASSERT(mRange);
   MOZ_ASSERT(mRange->IsPositioned());
 
   // get the start node and offset, convert to nsINode
   mCommonParent = mRange->GetCommonAncestor();
   nsINode* startContainer = mRange->GetStartContainer();
   int32_t startOffset = mRange->StartOffset();
   nsINode* endContainer = mRange->GetEndContainer();
@@ -978,17 +808,17 @@ nsresult nsContentSubtreeIterator::InitW
     offset = numChildren;
   }
   if (!offset || !numChildren) {
     node = endContainer;
   } else {
     lastCandidate = mRange->EndRef().Ref();
     MOZ_ASSERT(lastCandidate == endContainer->GetChildAt_Deprecated(--offset));
     NS_ASSERTION(lastCandidate,
-                 "tree traversal trouble in nsContentSubtreeIterator::Init");
+                 "tree traversal trouble in ContentSubtreeIterator::Init");
   }
 
   if (!lastCandidate) {
     // then lastCandidate is prev node before node
     lastCandidate = GetPrevSibling(node);
   }
 
   if (!lastCandidate) {
@@ -1015,34 +845,34 @@ nsresult nsContentSubtreeIterator::InitW
   mLast = GetTopAncestorInRange(lastCandidate);
 
   mCurNode = mFirst;
 
   return NS_OK;
 }
 
 /****************************************************************
- * nsContentSubtreeIterator overrides of ContentIterator routines
+ * ContentSubtreeIterator overrides of ContentIterator routines
  ****************************************************************/
 
 // we can't call PositionAt in a subtree iterator...
-void nsContentSubtreeIterator::First() {
+void ContentSubtreeIterator::First() {
   mIsDone = mFirst == nullptr;
 
   mCurNode = mFirst;
 }
 
 // we can't call PositionAt in a subtree iterator...
-void nsContentSubtreeIterator::Last() {
+void ContentSubtreeIterator::Last() {
   mIsDone = mLast == nullptr;
 
   mCurNode = mLast;
 }
 
-void nsContentSubtreeIterator::Next() {
+void ContentSubtreeIterator::Next() {
   if (mIsDone || !mCurNode) {
     return;
   }
 
   if (mCurNode == mLast) {
     mIsDone = true;
     return;
   }
@@ -1067,17 +897,17 @@ void nsContentSubtreeIterator::Next() {
   mCurNode = nextNode;
 
   // This shouldn't be needed, but since our selection code can put us
   // in a situation where mLast is in generated content, we need this
   // to stop the iterator when we've walked past past the last node!
   mIsDone = mCurNode == nullptr;
 }
 
-void nsContentSubtreeIterator::Prev() {
+void ContentSubtreeIterator::Prev() {
   // Prev should be optimized to use the mStartNodes, just as Next
   // uses mEndNodes.
   if (mIsDone || !mCurNode) {
     return;
   }
 
   if (mCurNode == mFirst) {
     mIsDone = true;
@@ -1095,27 +925,27 @@ void nsContentSubtreeIterator::Prev() {
   mCurNode = GetTopAncestorInRange(prevNode);
 
   // This shouldn't be needed, but since our selection code can put us
   // in a situation where mFirst is in generated content, we need this
   // to stop the iterator when we've walked past past the first node!
   mIsDone = mCurNode == nullptr;
 }
 
-nsresult nsContentSubtreeIterator::PositionAt(nsINode* aCurNode) {
+nsresult ContentSubtreeIterator::PositionAt(nsINode* aCurNode) {
   NS_ERROR("Not implemented!");
 
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 /****************************************************************
- * nsContentSubtreeIterator helper routines
+ * ContentSubtreeIterator helper routines
  ****************************************************************/
 
-nsIContent* nsContentSubtreeIterator::GetTopAncestorInRange(nsINode* aNode) {
+nsIContent* ContentSubtreeIterator::GetTopAncestorInRange(nsINode* aNode) {
   if (!aNode || !aNode->GetParentNode()) {
     return nullptr;
   }
 
   // aNode has a parent, so it must be content.
   nsIContent* content = aNode->AsContent();
 
   // sanity check: aNode is itself in the range
@@ -1145,8 +975,10 @@ nsIContent* nsContentSubtreeIterator::Ge
     if (nodeBefore || nodeAfter) {
       return content;
     }
     content = parent;
   }
 
   MOZ_CRASH("This should only be possible if aNode was null");
 }
+
+}  // namespace mozilla
copy from dom/base/nsContentIterator.cpp
copy to dom/base/ContentIterator.h
--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/ContentIterator.h
@@ -1,121 +1,57 @@
 /* -*- 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/. */
 
-#include "mozilla/DebugOnly.h"
-#include "nsISupports.h"
+#ifndef mozilla_ContentIterator_h
+#define mozilla_ContentIterator_h
+
+#include "mozilla/RangeBoundary.h"
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIContent.h"
 #include "nsIContentIterator.h"
 #include "nsRange.h"
-#include "nsIContent.h"
-#include "nsCOMPtr.h"
 #include "nsTArray.h"
-#include "nsContentUtils.h"
-#include "nsINode.h"
-#include "nsCycleCollectionParticipant.h"
-#include "nsElementTable.h"
-
-using mozilla::DebugOnly;
-using mozilla::RawRangeBoundary;
 
-// couple of utility static functs
-
-///////////////////////////////////////////////////////////////////////////
-// NodeIsInTraversalRange: returns true if content is visited during
-// the traversal of the range in the specified mode.
-//
-static bool NodeIsInTraversalRange(nsINode* aNode, bool aIsPreMode,
-                                   const RawRangeBoundary& aStart,
-                                   const RawRangeBoundary& aEnd) {
-  if (NS_WARN_IF(!aStart.IsSet()) || NS_WARN_IF(!aEnd.IsSet()) ||
-      NS_WARN_IF(!aNode)) {
-    return false;
-  }
+namespace mozilla {
 
-  // If a leaf node contains an end point of the traversal range, it is
-  // always in the traversal range.
-  if (aNode == aStart.Container() || aNode == aEnd.Container()) {
-    if (aNode->IsCharacterData()) {
-      return true;  // text node or something
-    }
-    if (!aNode->HasChildren()) {
-      MOZ_ASSERT(
-          aNode != aStart.Container() || aStart.IsStartOfContainer(),
-          "aStart.Container() doesn't have children and not a data node, "
-          "aStart should be at the beginning of its container");
-      MOZ_ASSERT(aNode != aEnd.Container() || aEnd.IsStartOfContainer(),
-                 "aEnd.Container() doesn't have children and not a data node, "
-                 "aEnd should be at the beginning of its container");
-      return true;
-    }
-  }
-
-  nsINode* parent = aNode->GetParentNode();
-  if (!parent) {
-    return false;
-  }
-
-  if (!aIsPreMode) {
-    // aNode should always be content, as we have a parent, but let's just be
-    // extra careful and check.
-    nsIContent* content =
-        NS_WARN_IF(!aNode->IsContent()) ? nullptr : aNode->AsContent();
-    // Post mode: start < node <= end.
-    RawRangeBoundary afterNode(parent, content);
-    return nsContentUtils::ComparePoints(aStart, afterNode) < 0 &&
-           nsContentUtils::ComparePoints(aEnd, afterNode) >= 0;
-  }
-
-  // Pre mode: start <= node < end.
-  RawRangeBoundary beforeNode(parent, aNode->GetPreviousSibling());
-  return nsContentUtils::ComparePoints(aStart, beforeNode) <= 0 &&
-         nsContentUtils::ComparePoints(aEnd, beforeNode) > 0;
-}
-
-/*
- *  A simple iterator class for traversing the content in "close tag" order
+/**
+ * A simple iterator class for traversing the content in "close tag" order.
  */
-class nsContentIterator : public nsIContentIterator {
+class ContentIterator : public nsIContentIterator {
  public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_CLASS(nsContentIterator)
+  NS_DECL_CYCLE_COLLECTION_CLASS(ContentIterator)
 
-  explicit nsContentIterator(bool aPre);
-
-  // nsIContentIterator interface methods ------------------------------
+  explicit ContentIterator(bool aPre);
 
   virtual nsresult Init(nsINode* aRoot) override;
-
   virtual nsresult Init(nsRange* aRange) override;
-
   virtual nsresult Init(nsINode* aStartContainer, uint32_t aStartOffset,
                         nsINode* aEndContainer, uint32_t aEndOffset) override;
-
   virtual nsresult Init(const RawRangeBoundary& aStart,
                         const RawRangeBoundary& aEnd) override;
 
   virtual void First() override;
-
   virtual void Last() override;
-
   virtual void Next() override;
-
   virtual void Prev() override;
 
   virtual nsINode* GetCurrentNode() override;
 
   virtual bool IsDone() override;
 
   virtual nsresult PositionAt(nsINode* aCurNode) override;
 
  protected:
-  virtual ~nsContentIterator();
+  virtual ~ContentIterator() = default;
 
   /**
    * Callers must guarantee that:
    * - Neither aStartContainer nor aEndContainer is nullptr.
    * - aStartOffset and aEndOffset are valid for its container.
    * - The start point and the end point are in document order.
    */
   nsresult InitInternal(const RawRangeBoundary& aStart,
@@ -145,1008 +81,68 @@ class nsContentIterator : public nsICont
   nsCOMPtr<nsINode> mFirst;
   nsCOMPtr<nsINode> mLast;
   nsCOMPtr<nsINode> mCommonParent;
 
   bool mIsDone;
   bool mPre;
 
  private:
-  // no copies or assigns  FIX ME
-  nsContentIterator(const nsContentIterator&);
-  nsContentIterator& operator=(const nsContentIterator&);
+  ContentIterator(const ContentIterator&) = delete;
+  ContentIterator& operator=(const ContentIterator&) = delete;
 };
 
-/******************************************************
- * repository cruft
- ******************************************************/
-
-already_AddRefed<nsIContentIterator> NS_NewContentIterator() {
-  nsCOMPtr<nsIContentIterator> iter = new nsContentIterator(false);
-  return iter.forget();
-}
-
-already_AddRefed<nsIContentIterator> NS_NewPreContentIterator() {
-  nsCOMPtr<nsIContentIterator> iter = new nsContentIterator(true);
-  return iter.forget();
-}
-
-/******************************************************
- * XPCOM cruft
- ******************************************************/
-
-NS_IMPL_CYCLE_COLLECTING_ADDREF(nsContentIterator)
-NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(nsContentIterator,
-                                                   LastRelease())
-
-NS_INTERFACE_MAP_BEGIN(nsContentIterator)
-  NS_INTERFACE_MAP_ENTRY(nsIContentIterator)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentIterator)
-  NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(nsContentIterator)
-NS_INTERFACE_MAP_END
-
-NS_IMPL_CYCLE_COLLECTION(nsContentIterator, mCurNode, mFirst, mLast,
-                         mCommonParent)
-
-void nsContentIterator::LastRelease() {
-  mCurNode = nullptr;
-  mFirst = nullptr;
-  mLast = nullptr;
-  mCommonParent = nullptr;
-}
-
-/******************************************************
- * constructor/destructor
- ******************************************************/
-
-nsContentIterator::nsContentIterator(bool aPre) : mIsDone(false), mPre(aPre) {}
-
-nsContentIterator::~nsContentIterator() {}
-
-/******************************************************
- * Init routines
- ******************************************************/
-
-nsresult nsContentIterator::Init(nsINode* aRoot) {
-  if (NS_WARN_IF(!aRoot)) {
-    return NS_ERROR_NULL_POINTER;
-  }
-
-  mIsDone = false;
-
-  if (mPre) {
-    mFirst = aRoot;
-    mLast = GetDeepLastChild(aRoot);
-    NS_WARNING_ASSERTION(mLast, "GetDeepLastChild returned null");
-  } else {
-    mFirst = GetDeepFirstChild(aRoot);
-    NS_WARNING_ASSERTION(mFirst, "GetDeepFirstChild returned null");
-    mLast = aRoot;
-  }
-
-  mCommonParent = aRoot;
-  mCurNode = mFirst;
-  return NS_OK;
-}
-
-nsresult nsContentIterator::Init(nsRange* aRange) {
-  mIsDone = false;
-
-  if (NS_WARN_IF(!aRange)) {
-    return NS_ERROR_INVALID_ARG;
-  }
-
-  if (NS_WARN_IF(!aRange->IsPositioned())) {
-    return NS_ERROR_INVALID_ARG;
-  }
-
-  return InitInternal(aRange->StartRef().AsRaw(), aRange->EndRef().AsRaw());
-}
-
-nsresult nsContentIterator::Init(nsINode* aStartContainer,
-                                 uint32_t aStartOffset, nsINode* aEndContainer,
-                                 uint32_t aEndOffset) {
-  mIsDone = false;
-
-  if (NS_WARN_IF(!nsRange::IsValidPoints(aStartContainer, aStartOffset,
-                                         aEndContainer, aEndOffset))) {
-    return NS_ERROR_INVALID_ARG;
-  }
-
-  return InitInternal(RawRangeBoundary(aStartContainer, aStartOffset),
-                      RawRangeBoundary(aEndContainer, aEndOffset));
-}
-
-nsresult nsContentIterator::Init(const RawRangeBoundary& aStart,
-                                 const RawRangeBoundary& aEnd) {
-  mIsDone = false;
-
-  if (NS_WARN_IF(!nsRange::IsValidPoints(aStart.Container(), aStart.Offset(),
-                                         aEnd.Container(), aEnd.Offset()))) {
-    return NS_ERROR_INVALID_ARG;
-  }
-
-  return InitInternal(aStart, aEnd);
-}
-
-nsresult nsContentIterator::InitInternal(const RawRangeBoundary& aStart,
-                                         const RawRangeBoundary& aEnd) {
-  // get common content parent
-  mCommonParent =
-      nsContentUtils::GetCommonAncestor(aStart.Container(), aEnd.Container());
-  if (NS_WARN_IF(!mCommonParent)) {
-    return NS_ERROR_FAILURE;
-  }
-
-  bool startIsData = aStart.Container()->IsCharacterData();
-
-  // Check to see if we have a collapsed range, if so, there is nothing to
-  // iterate over.
-  //
-  // XXX: CharacterDataNodes (text nodes) are currently an exception, since
-  //      we always want to be able to iterate text nodes at the end points
-  //      of a range.
-
-  if (!startIsData && aStart == aEnd) {
-    MakeEmpty();
-    return NS_OK;
-  }
-
-  // Handle ranges within a single character data node.
-  if (startIsData && aStart.Container() == aEnd.Container()) {
-    mFirst = aStart.Container()->AsContent();
-    mLast = mFirst;
-    mCurNode = mFirst;
-
-    return NS_OK;
-  }
-
-  // Find first node in range.
-
-  nsIContent* cChild = nullptr;
-
-  // Try to get the child at our starting point. This might return null if
-  // aStart is immediately after the last node in aStart.Container().
-  if (!startIsData) {
-    cChild = aStart.GetChildAtOffset();
-  }
-
-  if (!cChild) {
-    // No children (possibly a <br> or text node), or index is after last child.
-
-    if (mPre) {
-      // XXX: In the future, if start offset is after the last
-      //      character in the cdata node, should we set mFirst to
-      //      the next sibling?
-
-      // Normally we would skip the start node because the start node is outside
-      // of the range in pre mode. However, if aStartOffset == 0, and the node
-      // is a non-container node (e.g. <br>), we don't skip the node in this
-      // case in order to address bug 1215798.
-      bool startIsContainer = true;
-      if (aStart.Container()->IsHTMLElement()) {
-        nsAtom* name = aStart.Container()->NodeInfo()->NameAtom();
-        startIsContainer =
-            nsHTMLElement::IsContainer(nsHTMLTags::AtomTagToId(name));
-      }
-      if (!startIsData && (startIsContainer || !aStart.IsStartOfContainer())) {
-        mFirst = GetNextSibling(aStart.Container());
-        NS_WARNING_ASSERTION(mFirst, "GetNextSibling returned null");
-
-        // Does mFirst node really intersect the range?  The range could be
-        // 'degenerate', i.e., not collapsed but still contain no content.
-        if (mFirst &&
-            NS_WARN_IF(!NodeIsInTraversalRange(mFirst, mPre, aStart, aEnd))) {
-          mFirst = nullptr;
-        }
-      } else {
-        mFirst = aStart.Container()->AsContent();
-      }
-    } else {
-      // post-order
-      if (NS_WARN_IF(!aStart.Container()->IsContent())) {
-        // What else can we do?
-        mFirst = nullptr;
-      } else {
-        mFirst = aStart.Container()->AsContent();
-      }
-    }
-  } else {
-    if (mPre) {
-      mFirst = cChild;
-    } else {
-      // post-order
-      mFirst = GetDeepFirstChild(cChild);
-      NS_WARNING_ASSERTION(mFirst, "GetDeepFirstChild returned null");
-
-      // Does mFirst node really intersect the range?  The range could be
-      // 'degenerate', i.e., not collapsed but still contain no content.
-
-      if (mFirst && !NodeIsInTraversalRange(mFirst, mPre, aStart, aEnd)) {
-        mFirst = nullptr;
-      }
-    }
-  }
-
-  // Find last node in range.
-
-  bool endIsData = aEnd.Container()->IsCharacterData();
-
-  if (endIsData || !aEnd.Container()->HasChildren() ||
-      aEnd.IsStartOfContainer()) {
-    if (mPre) {
-      if (NS_WARN_IF(!aEnd.Container()->IsContent())) {
-        // Not much else to do here...
-        mLast = nullptr;
-      } else {
-        // If the end node is a non-container element and the end offset is 0,
-        // the last element should be the previous node (i.e., shouldn't
-        // include the end node in the range).
-        bool endIsContainer = true;
-        if (aEnd.Container()->IsHTMLElement()) {
-          nsAtom* name = aEnd.Container()->NodeInfo()->NameAtom();
-          endIsContainer =
-              nsHTMLElement::IsContainer(nsHTMLTags::AtomTagToId(name));
-        }
-        if (!endIsData && !endIsContainer && aEnd.IsStartOfContainer()) {
-          mLast = PrevNode(aEnd.Container());
-          NS_WARNING_ASSERTION(mLast, "PrevNode returned null");
-          if (mLast && mLast != mFirst &&
-              NS_WARN_IF(!NodeIsInTraversalRange(
-                  mLast, mPre, RawRangeBoundary(mFirst, 0), aEnd))) {
-            mLast = nullptr;
-          }
-        } else {
-          mLast = aEnd.Container()->AsContent();
-        }
-      }
-    } else {
-      // post-order
-      //
-      // XXX: In the future, if end offset is before the first character in the
-      //      cdata node, should we set mLast to the prev sibling?
-
-      if (!endIsData) {
-        mLast = GetPrevSibling(aEnd.Container());
-        NS_WARNING_ASSERTION(mLast, "GetPrevSibling returned null");
-
-        if (!NodeIsInTraversalRange(mLast, mPre, aStart, aEnd)) {
-          mLast = nullptr;
-        }
-      } else {
-        mLast = aEnd.Container()->AsContent();
-      }
-    }
-  } else {
-    cChild = aEnd.Ref();
-
-    if (NS_WARN_IF(!cChild)) {
-      // No child at offset!
-      MOZ_ASSERT_UNREACHABLE("nsContentIterator::nsContentIterator");
-      return NS_ERROR_FAILURE;
-    }
-
-    if (mPre) {
-      mLast = GetDeepLastChild(cChild);
-      NS_WARNING_ASSERTION(mLast, "GetDeepLastChild returned null");
-
-      if (NS_WARN_IF(!NodeIsInTraversalRange(mLast, mPre, aStart, aEnd))) {
-        mLast = nullptr;
-      }
-    } else {
-      // post-order
-      mLast = cChild;
-    }
-  }
-
-  // If either first or last is null, they both have to be null!
-
-  if (!mFirst || !mLast) {
-    mFirst = nullptr;
-    mLast = nullptr;
-  }
-
-  mCurNode = mFirst;
-  mIsDone = !mCurNode;
-
-  return NS_OK;
-}
-
-void nsContentIterator::MakeEmpty() {
-  mCurNode = nullptr;
-  mFirst = nullptr;
-  mLast = nullptr;
-  mCommonParent = nullptr;
-  mIsDone = true;
-}
-
-nsINode* nsContentIterator::GetDeepFirstChild(nsINode* aRoot) {
-  if (NS_WARN_IF(!aRoot) || !aRoot->HasChildren()) {
-    return aRoot;
-  }
-
-  return GetDeepFirstChild(aRoot->GetFirstChild());
-}
-
-nsIContent* nsContentIterator::GetDeepFirstChild(nsIContent* aRoot) {
-  if (NS_WARN_IF(!aRoot)) {
-    return nullptr;
-  }
-
-  nsIContent* node = aRoot;
-  nsIContent* child = node->GetFirstChild();
-
-  while (child) {
-    node = child;
-    child = node->GetFirstChild();
-  }
-
-  return node;
-}
-
-nsINode* nsContentIterator::GetDeepLastChild(nsINode* aRoot) {
-  if (NS_WARN_IF(!aRoot) || !aRoot->HasChildren()) {
-    return aRoot;
-  }
-
-  return GetDeepLastChild(aRoot->GetLastChild());
-}
-
-nsIContent* nsContentIterator::GetDeepLastChild(nsIContent* aRoot) {
-  if (NS_WARN_IF(!aRoot)) {
-    return nullptr;
-  }
-
-  nsIContent* node = aRoot;
-  while (node->HasChildren()) {
-    nsIContent* child = node->GetLastChild();
-    node = child;
-  }
-  return node;
-}
-
-// Get the next sibling, or parent's next sibling, or grandpa's next sibling...
-nsIContent* nsContentIterator::GetNextSibling(nsINode* aNode) {
-  if (NS_WARN_IF(!aNode)) {
-    return nullptr;
-  }
-
-  if (aNode->GetNextSibling()) {
-    return aNode->GetNextSibling();
-  }
-
-  nsINode* parent = aNode->GetParentNode();
-  if (NS_WARN_IF(!parent)) {
-    return nullptr;
-  }
-
-  // XXX This is a hack to preserve previous behaviour: This should be fixed
-  // in bug 1404916. If we were positioned on anonymous content, move to
-  // the first child of our parent.
-  if (parent->GetLastChild() && parent->GetLastChild() != aNode) {
-    return parent->GetFirstChild();
-  }
-
-  return GetNextSibling(parent);
-}
-
-// Get the prev sibling, or parent's prev sibling, or grandpa's prev sibling...
-nsIContent* nsContentIterator::GetPrevSibling(nsINode* aNode) {
-  if (NS_WARN_IF(!aNode)) {
-    return nullptr;
-  }
-
-  if (aNode->GetPreviousSibling()) {
-    return aNode->GetPreviousSibling();
-  }
-
-  nsINode* parent = aNode->GetParentNode();
-  if (NS_WARN_IF(!parent)) {
-    return nullptr;
-  }
-
-  // XXX This is a hack to preserve previous behaviour: This should be fixed
-  // in bug 1404916. If we were positioned on anonymous content, move to
-  // the last child of our parent.
-  if (parent->GetFirstChild() && parent->GetFirstChild() != aNode) {
-    return parent->GetLastChild();
-  }
-
-  return GetPrevSibling(parent);
-}
-
-nsINode* nsContentIterator::NextNode(nsINode* aNode) {
-  nsINode* node = aNode;
-
-  // if we are a Pre-order iterator, use pre-order
-  if (mPre) {
-    // if it has children then next node is first child
-    if (node->HasChildren()) {
-      nsIContent* firstChild = node->GetFirstChild();
-      MOZ_ASSERT(firstChild);
-
-      return firstChild;
-    }
-
-    // else next sibling is next
-    return GetNextSibling(node);
-  }
-
-  // post-order
-  nsINode* parent = node->GetParentNode();
-  if (NS_WARN_IF(!parent)) {
-    MOZ_ASSERT(parent, "The node is the root node but not the last node");
-    mIsDone = true;
-    return node;
-  }
-
-  nsIContent* sibling = node->GetNextSibling();
-  if (sibling) {
-    // next node is sibling's "deep left" child
-    return GetDeepFirstChild(sibling);
-  }
-
-  return parent;
-}
-
-nsINode* nsContentIterator::PrevNode(nsINode* aNode) {
-  nsINode* node = aNode;
-
-  // if we are a Pre-order iterator, use pre-order
-  if (mPre) {
-    nsINode* parent = node->GetParentNode();
-    if (NS_WARN_IF(!parent)) {
-      MOZ_ASSERT(parent, "The node is the root node but not the first node");
-      mIsDone = true;
-      return aNode;
-    }
-
-    nsIContent* sibling = node->GetPreviousSibling();
-    if (sibling) {
-      return GetDeepLastChild(sibling);
-    }
-
-    return parent;
-  }
-
-  // post-order
-  if (node->HasChildren()) {
-    return node->GetLastChild();
-  }
-
-  // else prev sibling is previous
-  return GetPrevSibling(node);
-}
-
-/******************************************************
- * ContentIterator routines
- ******************************************************/
-
-void nsContentIterator::First() {
-  if (mFirst) {
-    mozilla::DebugOnly<nsresult> rv = PositionAt(mFirst);
-    NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to position iterator!");
-  }
-
-  mIsDone = mFirst == nullptr;
-}
-
-void nsContentIterator::Last() {
-  // Note that mLast can be nullptr if MakeEmpty() is called in Init() since
-  // at that time, Init() returns NS_OK.
-  if (!mLast) {
-    MOZ_ASSERT(mIsDone);
-    return;
-  }
-
-  mozilla::DebugOnly<nsresult> rv = PositionAt(mLast);
-  NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to position iterator!");
-
-  mIsDone = mLast == nullptr;
-}
-
-void nsContentIterator::Next() {
-  if (mIsDone || NS_WARN_IF(!mCurNode)) {
-    return;
-  }
-
-  if (mCurNode == mLast) {
-    mIsDone = true;
-    return;
-  }
-
-  mCurNode = NextNode(mCurNode);
-}
-
-void nsContentIterator::Prev() {
-  if (NS_WARN_IF(mIsDone) || NS_WARN_IF(!mCurNode)) {
-    return;
-  }
-
-  if (mCurNode == mFirst) {
-    mIsDone = true;
-    return;
-  }
-
-  mCurNode = PrevNode(mCurNode);
-}
-
-bool nsContentIterator::IsDone() { return mIsDone; }
-
-// Keeping arrays of indexes for the stack of nodes makes PositionAt
-// interesting...
-nsresult nsContentIterator::PositionAt(nsINode* aCurNode) {
-  if (NS_WARN_IF(!aCurNode)) {
-    return NS_ERROR_NULL_POINTER;
-  }
-
-  // take an early out if this doesn't actually change the position
-  if (mCurNode == aCurNode) {
-    mIsDone = false;
-    return NS_OK;
-  }
-  mCurNode = aCurNode;
-
-  // Check to see if the node falls within the traversal range.
-
-  RawRangeBoundary first(mFirst, 0);
-  RawRangeBoundary last(mLast, 0);
-
-  if (mFirst && mLast) {
-    if (mPre) {
-      // In pre we want to record the point immediately before mFirst, which is
-      // the point immediately after mFirst's previous sibling.
-      first.SetAfterRef(mFirst->GetParentNode(), mFirst->GetPreviousSibling());
-
-      // If mLast has no children, then we want to make sure to include it.
-      if (!mLast->HasChildren()) {
-        last.SetAfterRef(mLast->GetParentNode(), mLast->AsContent());
-      }
-    } else {
-      // If the first node has any children, we want to be immediately after the
-      // last. Otherwise we want to be immediately before mFirst.
-      if (mFirst->HasChildren()) {
-        first.SetAfterRef(mFirst, mFirst->GetLastChild());
-      } else {
-        first.SetAfterRef(mFirst->GetParentNode(),
-                          mFirst->GetPreviousSibling());
-      }
-
-      // Set the last point immediately after the final node.
-      last.SetAfterRef(mLast->GetParentNode(), mLast->AsContent());
-    }
-  }
-
-  NS_WARNING_ASSERTION(first.IsSetAndValid(), "first is not valid");
-  NS_WARNING_ASSERTION(last.IsSetAndValid(), "last is not valid");
-
-  // The end positions are always in the range even if it has no parent.  We
-  // need to allow that or 'iter->Init(root)' would assert in Last() or First()
-  // for example, bug 327694.
-  if (mFirst != mCurNode && mLast != mCurNode &&
-      (NS_WARN_IF(!first.IsSet()) || NS_WARN_IF(!last.IsSet()) ||
-       NS_WARN_IF(!NodeIsInTraversalRange(mCurNode, mPre, first, last)))) {
-    mIsDone = true;
-    return NS_ERROR_FAILURE;
-  }
-
-  mIsDone = false;
-  return NS_OK;
-}
-
-nsINode* nsContentIterator::GetCurrentNode() {
-  if (mIsDone) {
-    return nullptr;
-  }
-
-  NS_ASSERTION(mCurNode, "Null current node in an iterator that's not done!");
-
-  return mCurNode;
-}
-
-/*====================================================================================*/
-/*====================================================================================*/
-
-/******************************************************
- * nsContentSubtreeIterator
- ******************************************************/
-
-/*
- *  A simple iterator class for traversing the content in "top subtree" order
+/**
+ *  A simple iterator class for traversing the content in "top subtree" order.
  */
-class nsContentSubtreeIterator : public nsContentIterator {
+class ContentSubtreeIterator final : public ContentIterator {
  public:
-  nsContentSubtreeIterator() : nsContentIterator(false) {}
+  ContentSubtreeIterator() : ContentIterator(false) {}
 
   NS_DECL_ISUPPORTS_INHERITED
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsContentSubtreeIterator,
-                                           nsContentIterator)
-
-  // nsContentIterator overrides ------------------------------
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ContentSubtreeIterator,
+                                           ContentIterator)
 
   virtual nsresult Init(nsINode* aRoot) override;
-
   virtual nsresult Init(nsRange* aRange) override;
-
   virtual nsresult Init(nsINode* aStartContainer, uint32_t aStartOffset,
                         nsINode* aEndContainer, uint32_t aEndOffset) override;
-
   virtual nsresult Init(const RawRangeBoundary& aStart,
                         const RawRangeBoundary& aEnd) override;
 
   virtual void Next() override;
-
   virtual void Prev() override;
+  // Must override these because we don't do PositionAt
+  virtual void First() override;
+  // Must override these because we don't do PositionAt
+  virtual void Last() override;
 
   virtual nsresult PositionAt(nsINode* aCurNode) override;
 
-  // Must override these because we don't do PositionAt
-  virtual void First() override;
-
-  // Must override these because we don't do PositionAt
-  virtual void Last() override;
-
  protected:
-  virtual ~nsContentSubtreeIterator() {}
+  virtual ~ContentSubtreeIterator() = default;
 
   /**
    * Callers must guarantee that mRange isn't nullptr and is positioned.
    */
   nsresult InitWithRange();
 
   // Returns the highest inclusive ancestor of aNode that's in the range
   // (possibly aNode itself).  Returns null if aNode is null, or is not itself
   // in the range.  A node is in the range if (node, 0) comes strictly after
   // the range endpoint, and (node, node.length) comes strictly before it, so
   // the range's start and end nodes will never be considered "in" it.
   nsIContent* GetTopAncestorInRange(nsINode* aNode);
 
   // no copy's or assigns  FIX ME
-  nsContentSubtreeIterator(const nsContentSubtreeIterator&);
-  nsContentSubtreeIterator& operator=(const nsContentSubtreeIterator&);
+  ContentSubtreeIterator(const ContentSubtreeIterator&) = delete;
+  ContentSubtreeIterator& operator=(const ContentSubtreeIterator&) = delete;
 
   virtual void LastRelease() override;
 
   RefPtr<nsRange> mRange;
 
   AutoTArray<nsIContent*, 8> mEndNodes;
 };
 
-NS_IMPL_ADDREF_INHERITED(nsContentSubtreeIterator, nsContentIterator)
-NS_IMPL_RELEASE_INHERITED(nsContentSubtreeIterator, nsContentIterator)
-
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsContentSubtreeIterator)
-NS_INTERFACE_MAP_END_INHERITING(nsContentIterator)
-
-NS_IMPL_CYCLE_COLLECTION_INHERITED(nsContentSubtreeIterator, nsContentIterator,
-                                   mRange)
-
-void nsContentSubtreeIterator::LastRelease() {
-  mRange = nullptr;
-  nsContentIterator::LastRelease();
-}
-
-/******************************************************
- * repository cruft
- ******************************************************/
-
-already_AddRefed<nsIContentIterator> NS_NewContentSubtreeIterator() {
-  nsCOMPtr<nsIContentIterator> iter = new nsContentSubtreeIterator();
-  return iter.forget();
-}
-
-/******************************************************
- * Init routines
- ******************************************************/
-
-nsresult nsContentSubtreeIterator::Init(nsINode* aRoot) {
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-nsresult nsContentSubtreeIterator::Init(nsRange* aRange) {
-  MOZ_ASSERT(aRange);
-
-  mIsDone = false;
-
-  if (NS_WARN_IF(!aRange->IsPositioned())) {
-    return NS_ERROR_INVALID_ARG;
-  }
-
-  mRange = aRange;
-
-  return InitWithRange();
-}
-
-nsresult nsContentSubtreeIterator::Init(nsINode* aStartContainer,
-                                        uint32_t aStartOffset,
-                                        nsINode* aEndContainer,
-                                        uint32_t aEndOffset) {
-  return Init(RawRangeBoundary(aStartContainer, aStartOffset),
-              RawRangeBoundary(aEndContainer, aEndOffset));
-}
-
-nsresult nsContentSubtreeIterator::Init(const RawRangeBoundary& aStart,
-                                        const RawRangeBoundary& aEnd) {
-  mIsDone = false;
-
-  RefPtr<nsRange> range;
-  nsresult rv = nsRange::CreateRange(aStart, aEnd, getter_AddRefs(range));
-  if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(!range) ||
-      NS_WARN_IF(!range->IsPositioned())) {
-    return NS_ERROR_INVALID_ARG;
-  }
-
-  if (NS_WARN_IF(range->StartRef() != aStart) ||
-      NS_WARN_IF(range->EndRef() != aEnd)) {
-    return NS_ERROR_UNEXPECTED;
-  }
-
-  mRange = std::move(range);
-
-  return InitWithRange();
-}
-
-nsresult nsContentSubtreeIterator::InitWithRange() {
-  MOZ_ASSERT(mRange);
-  MOZ_ASSERT(mRange->IsPositioned());
-
-  // get the start node and offset, convert to nsINode
-  mCommonParent = mRange->GetCommonAncestor();
-  nsINode* startContainer = mRange->GetStartContainer();
-  int32_t startOffset = mRange->StartOffset();
-  nsINode* endContainer = mRange->GetEndContainer();
-  int32_t endOffset = mRange->EndOffset();
-  MOZ_ASSERT(mCommonParent && startContainer && endContainer);
-  // Bug 767169
-  MOZ_ASSERT(uint32_t(startOffset) <= startContainer->Length() &&
-             uint32_t(endOffset) <= endContainer->Length());
-
-  // short circuit when start node == end node
-  if (startContainer == endContainer) {
-    nsINode* child = startContainer->GetFirstChild();
-
-    if (!child || startOffset == endOffset) {
-      // Text node, empty container, or collapsed
-      MakeEmpty();
-      return NS_OK;
-    }
-  }
-
-  // cache ancestors
-  mEndNodes.Clear();
-  nsIContent* endNode =
-      endContainer->IsContent() ? endContainer->AsContent() : nullptr;
-  while (endNode) {
-    mEndNodes.AppendElement(endNode);
-    endNode = endNode->GetParent();
-  }
-
-  nsIContent* firstCandidate = nullptr;
-  nsIContent* lastCandidate = nullptr;
-
-  // find first node in range
-  int32_t offset = mRange->StartOffset();
-
-  nsINode* node = nullptr;
-  if (!startContainer->GetChildCount()) {
-    // no children, start at the node itself
-    node = startContainer;
-  } else {
-    nsIContent* child = mRange->GetChildAtStartOffset();
-    MOZ_ASSERT(child == startContainer->GetChildAt_Deprecated(offset));
-    if (!child) {
-      // offset after last child
-      node = startContainer;
-    } else {
-      firstCandidate = child;
-    }
-  }
-
-  if (!firstCandidate) {
-    // then firstCandidate is next node after node
-    firstCandidate = GetNextSibling(node);
-
-    if (!firstCandidate) {
-      MakeEmpty();
-      return NS_OK;
-    }
-  }
-
-  firstCandidate = GetDeepFirstChild(firstCandidate);
-
-  // confirm that this first possible contained node is indeed contained.  Else
-  // we have a range that does not fully contain any node.
-
-  bool nodeBefore, nodeAfter;
-  MOZ_ALWAYS_SUCCEEDS(nsRange::CompareNodeToRange(firstCandidate, mRange,
-                                                  &nodeBefore, &nodeAfter));
-
-  if (nodeBefore || nodeAfter) {
-    MakeEmpty();
-    return NS_OK;
-  }
-
-  // cool, we have the first node in the range.  Now we walk up its ancestors
-  // to find the most senior that is still in the range.  That's the real first
-  // node.
-  mFirst = GetTopAncestorInRange(firstCandidate);
-
-  // now to find the last node
-  offset = mRange->EndOffset();
-  int32_t numChildren = endContainer->GetChildCount();
+}  // namespace mozilla
 
-  if (offset > numChildren) {
-    // Can happen for text nodes
-    offset = numChildren;
-  }
-  if (!offset || !numChildren) {
-    node = endContainer;
-  } else {
-    lastCandidate = mRange->EndRef().Ref();
-    MOZ_ASSERT(lastCandidate == endContainer->GetChildAt_Deprecated(--offset));
-    NS_ASSERTION(lastCandidate,
-                 "tree traversal trouble in nsContentSubtreeIterator::Init");
-  }
-
-  if (!lastCandidate) {
-    // then lastCandidate is prev node before node
-    lastCandidate = GetPrevSibling(node);
-  }
-
-  if (!lastCandidate) {
-    MakeEmpty();
-    return NS_OK;
-  }
-
-  lastCandidate = GetDeepLastChild(lastCandidate);
-
-  // confirm that this last possible contained node is indeed contained.  Else
-  // we have a range that does not fully contain any node.
-
-  MOZ_ALWAYS_SUCCEEDS(nsRange::CompareNodeToRange(lastCandidate, mRange,
-                                                  &nodeBefore, &nodeAfter));
-
-  if (nodeBefore || nodeAfter) {
-    MakeEmpty();
-    return NS_OK;
-  }
-
-  // cool, we have the last node in the range.  Now we walk up its ancestors to
-  // find the most senior that is still in the range.  That's the real first
-  // node.
-  mLast = GetTopAncestorInRange(lastCandidate);
-
-  mCurNode = mFirst;
-
-  return NS_OK;
-}
-
-/****************************************************************
- * nsContentSubtreeIterator overrides of ContentIterator routines
- ****************************************************************/
-
-// we can't call PositionAt in a subtree iterator...
-void nsContentSubtreeIterator::First() {
-  mIsDone = mFirst == nullptr;
-
-  mCurNode = mFirst;
-}
-
-// we can't call PositionAt in a subtree iterator...
-void nsContentSubtreeIterator::Last() {
-  mIsDone = mLast == nullptr;
-
-  mCurNode = mLast;
-}
-
-void nsContentSubtreeIterator::Next() {
-  if (mIsDone || !mCurNode) {
-    return;
-  }
-
-  if (mCurNode == mLast) {
-    mIsDone = true;
-    return;
-  }
-
-  nsINode* nextNode = GetNextSibling(mCurNode);
-  NS_ASSERTION(nextNode, "No next sibling!?! This could mean deadlock!");
-
-  int32_t i = mEndNodes.IndexOf(nextNode);
-  while (i != -1) {
-    // as long as we are finding ancestors of the endpoint of the range,
-    // dive down into their children
-    nextNode = nextNode->GetFirstChild();
-    NS_ASSERTION(nextNode, "Iterator error, expected a child node!");
-
-    // should be impossible to get a null pointer.  If we went all the way
-    // down the child chain to the bottom without finding an interior node,
-    // then the previous node should have been the last, which was
-    // was tested at top of routine.
-    i = mEndNodes.IndexOf(nextNode);
-  }
-
-  mCurNode = nextNode;
-
-  // This shouldn't be needed, but since our selection code can put us
-  // in a situation where mLast is in generated content, we need this
-  // to stop the iterator when we've walked past past the last node!
-  mIsDone = mCurNode == nullptr;
-}
-
-void nsContentSubtreeIterator::Prev() {
-  // Prev should be optimized to use the mStartNodes, just as Next
-  // uses mEndNodes.
-  if (mIsDone || !mCurNode) {
-    return;
-  }
-
-  if (mCurNode == mFirst) {
-    mIsDone = true;
-    return;
-  }
-
-  // If any of these function calls return null, so will all succeeding ones,
-  // so mCurNode will wind up set to null.
-  nsINode* prevNode = GetDeepFirstChild(mCurNode);
-
-  prevNode = PrevNode(prevNode);
-
-  prevNode = GetDeepLastChild(prevNode);
-
-  mCurNode = GetTopAncestorInRange(prevNode);
-
-  // This shouldn't be needed, but since our selection code can put us
-  // in a situation where mFirst is in generated content, we need this
-  // to stop the iterator when we've walked past past the first node!
-  mIsDone = mCurNode == nullptr;
-}
-
-nsresult nsContentSubtreeIterator::PositionAt(nsINode* aCurNode) {
-  NS_ERROR("Not implemented!");
-
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-/****************************************************************
- * nsContentSubtreeIterator helper routines
- ****************************************************************/
-
-nsIContent* nsContentSubtreeIterator::GetTopAncestorInRange(nsINode* aNode) {
-  if (!aNode || !aNode->GetParentNode()) {
-    return nullptr;
-  }
-
-  // aNode has a parent, so it must be content.
-  nsIContent* content = aNode->AsContent();
-
-  // sanity check: aNode is itself in the range
-  bool nodeBefore, nodeAfter;
-  nsresult res =
-      nsRange::CompareNodeToRange(aNode, mRange, &nodeBefore, &nodeAfter);
-  NS_ASSERTION(NS_SUCCEEDED(res) && !nodeBefore && !nodeAfter,
-               "aNode isn't in mRange, or something else weird happened");
-  if (NS_FAILED(res) || nodeBefore || nodeAfter) {
-    return nullptr;
-  }
-
-  while (content) {
-    nsIContent* parent = content->GetParent();
-    // content always has a parent.  If its parent is the root, however --
-    // i.e., either it's not content, or it is content but its own parent is
-    // null -- then we're finished, since we don't go up to the root.
-    //
-    // We have to special-case this because CompareNodeToRange treats the root
-    // node differently -- see bug 765205.
-    if (!parent || !parent->GetParentNode()) {
-      return content;
-    }
-    MOZ_ALWAYS_SUCCEEDS(
-        nsRange::CompareNodeToRange(parent, mRange, &nodeBefore, &nodeAfter));
-
-    if (nodeBefore || nodeAfter) {
-      return content;
-    }
-    content = parent;
-  }
-
-  MOZ_CRASH("This should only be possible if aNode was null");
-}
+#endif  // #ifndef mozilla_ContentIterator_h
--- a/dom/base/moz.build
+++ b/dom/base/moz.build
@@ -120,16 +120,17 @@ EXPORTS += [
 
 if CONFIG['MOZ_WEBRTC']:
     EXPORTS += [
         'nsDOMDataChannel.h',
         'nsDOMDataChannelDeclarations.h',
     ]
 
 EXPORTS.mozilla += [
+    'ContentIterator.h',
     'CORSMode.h',
     'FlushType.h',
     'FullscreenChange.h',
     'IdentifierMapEntry.h',
     'RangeBoundary.h',
     'ScriptableContentIterator.h',
     'SelectionChangeEventDispatcher.h',
     'TextInputProcessor.h',
@@ -256,16 +257,17 @@ UNIFIED_SOURCES += [
     'CharacterData.cpp',
     'ChildIterator.cpp',
     'ChromeMessageBroadcaster.cpp',
     'ChromeMessageSender.cpp',
     'ChromeNodeList.cpp',
     'ChromeUtils.cpp',
     'Comment.cpp',
     'ContentFrameMessageManager.cpp',
+    'ContentIterator.cpp',
     'ContentProcessMessageManager.cpp',
     'Crypto.cpp',
     'CustomElementRegistry.cpp',
     'DirectionalityUtils.cpp',
     'DispatcherTrait.cpp',
     'DocGroup.cpp',
     'Document.cpp',
     'DocumentFragment.cpp',
@@ -305,17 +307,16 @@ UNIFIED_SOURCES += [
     'Navigator.cpp',
     'NodeInfo.cpp',
     'NodeIterator.cpp',
     'NodeUbiReporting.cpp',
     'nsAttrValue.cpp',
     'nsAttrValueOrString.cpp',
     'nsCCUncollectableMarker.cpp',
     'nsContentAreaDragDrop.cpp',
-    'nsContentIterator.cpp',
     'nsContentList.cpp',
     'nsContentPermissionHelper.cpp',
     'nsContentPolicy.cpp',
     'nsContentSink.cpp',
     'nsContentTypeParser.cpp',
     'nsCopySupport.cpp',
     'nsDataDocumentContentPolicy.cpp',
     'nsDocumentEncoder.cpp',
--- a/dom/base/test/test_bug976673.html
+++ b/dom/base/test/test_bug976673.html
@@ -23,17 +23,17 @@ https://bugzilla.mozilla.org/show_bug.cg
 <button id="button">set focus</button>
 <iframe id="iframe" src="http://example.org:80/tests/dom/base/test/iframe_bug976673.html"></iframe>
 <script>
 
 SimpleTest.waitForExplicitFinish();
 
 // In e10s mode, ContentCacheInChild tries to retrieve selected text and
 // caret position when IMEContentObserver notifies IME of focus.  At this time,
-// we hit assertion in nsContentIterator.
+// we hit assertion in ContentIterator.
 SimpleTest.expectAssertions(0, 6);
 
 window.addEventListener("mousedown", function (aEvent) { aEvent.preventDefault(); });
 
 function testSetFocus(aEventType, aCallback)
 {
   var description = "Setting focus from " + aEventType + " handler: ";
 
--- a/dom/base/test/test_content_iterator_subtree.html
+++ b/dom/base/test/test_content_iterator_subtree.html
@@ -75,17 +75,17 @@ function getNodeDescription(aNode) {
   }
 }
 
 SimpleTest.waitForExplicitFinish();
 SimpleTest.waitForFocus(function () {
   let iter = createContentIterator();
 
   /**
-   * FYI: nsContentSubtreeIterator does not support initWithRootNode() nor positionAt().
+   * FYI: ContentSubtreeIterator does not support initWithRootNode() nor positionAt().
    */
 
   /**
    * Basic behavior tests of first(), last(), prev() and next() after initialized with a range which selects empty element.
    */
   document.body.innerHTML = "<div></div>";
   let range = document.createRange();
   range.selectNode(document.body.firstChild);
--- a/dom/events/ContentEventHandler.cpp
+++ b/dom/events/ContentEventHandler.cpp
@@ -194,17 +194,17 @@ nsresult ContentEventHandler::RawRange::
 // 2. End of range:
 //   2.1. Cases: ]textNode or text]Node or textNode]
 //        When a text node is end of a range, end node is the text node and
 //        end offset is any number between 0 and the length of the text.
 //   2.2. Case: ]<element>
 //        When before an element node (meaning before the open tag of the
 //        element) is end of a range, end node is previous node causing text.
 //        Note that this case shouldn't be handled directly.  If rule 2.1 and
-//        2.3 are handled correctly, the loop with nsContentIterator shouldn't
+//        2.3 are handled correctly, the loop with ContentIterator shouldn't
 //        reach the element node since the loop should've finished already at
 //        handling the last node which caused some text.
 //   2.3. Case: <element>]
 //        When a line break is caused before a non-empty element node and it's
 //        end of a range, end node is the element and end offset is 0.
 //        (i.e., including open tag of the element)
 //   2.4. Cases: <element/>]
 //        When after an empty element node is end of a range, end node is
@@ -2648,17 +2648,17 @@ nsresult ContentEventHandler::OnQueryDOM
     return NS_ERROR_INVALID_ARG;
   }
 
   if (aStartPosition == aEndPosition) {
     *aLength = 0;
     return NS_OK;
   }
 
-  // Don't create nsContentIterator instance until it's really necessary since
+  // Don't create ContentIterator instance until it's really necessary since
   // destroying without initializing causes unexpected NS_ASSERTION() call.
   nsCOMPtr<nsIContentIterator> iter;
 
   // Working with ContentIterator, we may need to adjust the end position for
   // including it forcibly.
   NodePosition endPosition(aEndPosition);
 
   // This may be called for retrieving the text of removed nodes.  Even in this
@@ -2787,17 +2787,17 @@ nsresult ContentEventHandler::OnQueryDOM
     }
   }
   return NS_OK;
 }
 
 nsresult ContentEventHandler::GetStartOffset(const RawRange& aRawRange,
                                              uint32_t* aOffset,
                                              LineBreakType aLineBreakType) {
-  // To match the "no skip start" hack in nsContentIterator::Init, when range
+  // To match the "no skip start" hack in ContentIterator::Init, when range
   // offset is 0 and the range node is not a container, we have to assume the
   // range _includes_ the node, which means the start offset should _not_
   // include the node.
   //
   // For example, for this content: <br>abc, and range (<br>, 0)-("abc", 1), the
   // range includes the linebreak from <br>, so the start offset should _not_
   // include <br>, and the start offset should be 0.
   //
--- a/dom/events/IMEContentObserver.cpp
+++ b/dom/events/IMEContentObserver.cpp
@@ -1546,17 +1546,17 @@ void IMEContentObserver::FlushMergeableN
   //       another change.
 
   MOZ_LOG(sIMECOLog, LogLevel::Debug,
           ("0x%p IMEContentObserver::FlushMergeableNotifications(), "
            "creating IMENotificationSender...",
            this));
 
   // If contents in selection range is modified, the selection range still
-  // has removed node from the tree.  In such case, nsContentIterator won't
+  // has removed node from the tree.  In such case, ContentIterator won't
   // work well.  Therefore, we shouldn't use AddScriptRunnder() here since
   // it may kick runnable event immediately after DOM tree is changed but
   // the selection range isn't modified yet.
   mQueuedSender = new IMENotificationSender(this);
   mQueuedSender->Dispatch(mDocShell);
   MOZ_LOG(sIMECOLog, LogLevel::Debug,
           ("0x%p IMEContentObserver::FlushMergeableNotifications(), "
            "finished",