editor/spellchecker/FilteredContentIterator.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "FilteredContentIterator.h"
   7
   8 #include <utility>
   9
  10 #include "mozilla/ContentIterator.h"
  11 #include "mozilla/dom/AbstractRange.h"
  12 #include "mozilla/Maybe.h"
  13 #include "mozilla/mozalloc.h"
  14 #include "nsAtom.h"
  15 #include "nsComponentManagerUtils.h"
  16 #include "nsComposeTxtSrvFilter.h"
  17 #include "nsContentUtils.h"
  18 #include "nsDebug.h"
  19 #include "nsError.h"
  20 #include "nsIContent.h"
  21 #include "nsINode.h"
  22 #include "nsISupports.h"
  23 #include "nsISupportsUtils.h"
  24 #include "nsRange.h"
  25
  26 namespace mozilla {
  27
  28 using namespace dom;
  29
  30 FilteredContentIterator::FilteredContentIterator(
  31     UniquePtr<nsComposeTxtSrvFilter> aFilter)
  32     : mCurrentIterator(nullptr),
  33       mFilter(std::move(aFilter)),
  34       mDidSkip(false),
  35       mIsOutOfRange(false),
  36       mDirection(eDirNotSet) {}
  37
  38 FilteredContentIterator::~FilteredContentIterator() {}
  39
  40 NS_IMPL_CYCLE_COLLECTION(FilteredContentIterator, mPostIterator, mPreIterator,
  41                          mRange)
  42
  43 nsresult FilteredContentIterator::Init(nsINode* aRoot) {
  44   NS_ENSURE_ARG_POINTER(aRoot);
  45   mIsOutOfRange = false;
  46   mDirection = eForward;
  47   mCurrentIterator = &mPreIterator;
  48
  49   mRange = nsRange::Create(aRoot);
  50   mRange->SelectNode(*aRoot, IgnoreErrors());
  51
  52   nsresult rv = mPreIterator.Init(mRange);
  53   NS_ENSURE_SUCCESS(rv, rv);
  54   return mPostIterator.Init(mRange);
  55 }
  56
  57 nsresult FilteredContentIterator::Init(const AbstractRange* aAbstractRange) {
  58   if (NS_WARN_IF(!aAbstractRange)) {
  59     return NS_ERROR_INVALID_ARG;
  60   }
  61
  62   if (NS_WARN_IF(!aAbstractRange->IsPositioned())) {
  63     return NS_ERROR_INVALID_ARG;
  64   }
  65
  66   mRange = nsRange::Create(aAbstractRange, IgnoreErrors());
  67   if (NS_WARN_IF(!mRange)) {
  68     return NS_ERROR_FAILURE;
  69   }
  70   return InitWithRange();
  71 }
  72
  73 nsresult FilteredContentIterator::Init(nsINode* aStartContainer,
  74                                        uint32_t aStartOffset,
  75                                        nsINode* aEndContainer,
  76                                        uint32_t aEndOffset) {
  77   return Init(RawRangeBoundary(aStartContainer, aStartOffset),
  78               RawRangeBoundary(aEndContainer, aEndOffset));
  79 }
  80
  81 nsresult FilteredContentIterator::Init(const RawRangeBoundary& aStartBoundary,
  82                                        const RawRangeBoundary& aEndBoundary) {
  83   RefPtr<nsRange> range =
  84       nsRange::Create(aStartBoundary, aEndBoundary, IgnoreErrors());
  85   if (NS_WARN_IF(!range) || NS_WARN_IF(!range->IsPositioned())) {
  86     return NS_ERROR_INVALID_ARG;
  87   }
  88
  89   MOZ_ASSERT(range->StartRef() == aStartBoundary);
  90   MOZ_ASSERT(range->EndRef() == aEndBoundary);
  91
  92   mRange = std::move(range);
  93
  94   return InitWithRange();
  95 }
  96
  97 nsresult FilteredContentIterator::InitWithRange() {
  98   MOZ_ASSERT(mRange);
  99   MOZ_ASSERT(mRange->IsPositioned());
 100
 101   mIsOutOfRange = false;
 102   mDirection = eForward;
 103   mCurrentIterator = &mPreIterator;
 104
 105   nsresult rv = mPreIterator.Init(mRange);
 106   if (NS_WARN_IF(NS_FAILED(rv))) {
 107     return rv;
 108   }
 109   return mPostIterator.Init(mRange);
 110 }
 111
 112 nsresult FilteredContentIterator::SwitchDirections(bool aChangeToForward) {
 113   nsINode* node = mCurrentIterator->GetCurrentNode();
 114
 115   if (aChangeToForward) {
 116     mCurrentIterator = &mPreIterator;
 117     mDirection = eForward;
 118   } else {
 119     mCurrentIterator = &mPostIterator;
 120     mDirection = eBackward;
 121   }
 122
 123   if (node) {
 124     nsresult rv = mCurrentIterator->PositionAt(node);
 125     if (NS_FAILED(rv)) {
 126       mIsOutOfRange = true;
 127       return rv;
 128     }
 129   }
 130   return NS_OK;
 131 }
 132
 133 void FilteredContentIterator::First() {
 134   if (!mCurrentIterator) {
 135     NS_ERROR("Missing iterator!");
 136
 137     return;
 138   }
 139
 140   // If we are switching directions then
 141   // we need to switch how we process the nodes
 142   if (mDirection != eForward) {
 143     mCurrentIterator = &mPreIterator;
 144     mDirection = eForward;
 145     mIsOutOfRange = false;
 146   }
 147
 148   mCurrentIterator->First();
 149
 150   if (mCurrentIterator->IsDone()) {
 151     return;
 152   }
 153
 154   nsINode* currentNode = mCurrentIterator->GetCurrentNode();
 155
 156   bool didCross;
 157   CheckAdvNode(currentNode, didCross, eForward);
 158 }
 159
 160 void FilteredContentIterator::Last() {
 161   if (!mCurrentIterator) {
 162     NS_ERROR("Missing iterator!");
 163
 164     return;
 165   }
 166
 167   // If we are switching directions then
 168   // we need to switch how we process the nodes
 169   if (mDirection != eBackward) {
 170     mCurrentIterator = &mPostIterator;
 171     mDirection = eBackward;
 172     mIsOutOfRange = false;
 173   }
 174
 175   mCurrentIterator->Last();
 176
 177   if (mCurrentIterator->IsDone()) {
 178     return;
 179   }
 180
 181   nsINode* currentNode = mCurrentIterator->GetCurrentNode();
 182
 183   bool didCross;
 184   CheckAdvNode(currentNode, didCross, eBackward);
 185 }
 186
 187 ///////////////////////////////////////////////////////////////////////////
 188 // ContentIsInTraversalRange: returns true if content is visited during
 189 // the traversal of the range in the specified mode.
 190 //
 191 static bool ContentIsInTraversalRange(nsIContent* aContent, bool aIsPreMode,
 192                                       nsINode* aStartContainer,
 193                                       int32_t aStartOffset,
 194                                       nsINode* aEndContainer,
 195                                       int32_t aEndOffset) {
 196   NS_ENSURE_TRUE(aStartContainer && aEndContainer && aContent, false);
 197
 198   nsIContent* parentContent = aContent->GetParent();
 199   if (MOZ_UNLIKELY(NS_WARN_IF(!parentContent))) {
 200     return false;
 201   }
 202   Maybe<uint32_t> offsetInParent = parentContent->ComputeIndexOf(aContent);
 203   NS_WARNING_ASSERTION(
 204       offsetInParent.isSome(),
 205       "Content is not in the parent, is this called during a DOM mutation?");
 206   if (MOZ_UNLIKELY(NS_WARN_IF(offsetInParent.isNothing()))) {
 207     return false;
 208   }
 209
 210   if (!aIsPreMode) {
 211     MOZ_ASSERT(*offsetInParent != UINT32_MAX);
 212     ++(*offsetInParent);
 213   }
 214
 215   const Maybe<int32_t> startRes = nsContentUtils::ComparePoints(
 216       aStartContainer, aStartOffset, parentContent, *offsetInParent);
 217   if (MOZ_UNLIKELY(NS_WARN_IF(!startRes))) {
 218     return false;
 219   }
 220   const Maybe<int32_t> endRes = nsContentUtils::ComparePoints(
 221       aEndContainer, aEndOffset, parentContent, *offsetInParent);
 222   if (MOZ_UNLIKELY(NS_WARN_IF(!endRes))) {
 223     return false;
 224   }
 225   return *startRes <= 0 && *endRes >= 0;
 226 }
 227
 228 static bool ContentIsInTraversalRange(nsRange* aRange, nsIContent* aNextContent,
 229                                       bool aIsPreMode) {
 230   // XXXbz we have a caller below (in AdvanceNode) who passes null for
 231   // aNextContent!
 232   NS_ENSURE_TRUE(aNextContent && aRange, false);
 233
 234   return ContentIsInTraversalRange(
 235       aNextContent, aIsPreMode, aRange->GetStartContainer(),
 236       static_cast<int32_t>(aRange->StartOffset()), aRange->GetEndContainer(),
 237       static_cast<int32_t>(aRange->EndOffset()));
 238 }
 239
 240 // Helper function to advance to the next or previous node
 241 nsresult FilteredContentIterator::AdvanceNode(nsINode* aNode,
 242                                               nsINode*& aNewNode,
 243                                               eDirectionType aDir) {
 244   nsCOMPtr<nsIContent> nextNode;
 245   if (aDir == eForward) {
 246     nextNode = aNode->GetNextSibling();
 247   } else {
 248     nextNode = aNode->GetPreviousSibling();
 249   }
 250
 251   if (nextNode) {
 252     // If we got here, that means we found the nxt/prv node
 253     // make sure it is in our DOMRange
 254     bool intersects =
 255         ContentIsInTraversalRange(mRange, nextNode, aDir == eForward);
 256     if (intersects) {
 257       aNewNode = nextNode;
 258       NS_ADDREF(aNewNode);
 259       return NS_OK;
 260     }
 261   } else {
 262     // The next node was null so we need to walk up the parent(s)
 263     nsCOMPtr<nsINode> parent = aNode->GetParentNode();
 264     NS_ASSERTION(parent, "parent can't be nullptr");
 265
 266     // Make sure the parent is in the DOMRange before going further
 267     // XXXbz why are we passing nextNode, not the parent???  If this gets fixed,
 268     // then ContentIsInTraversalRange can stop null-checking its second arg.
 269     bool intersects =
 270         ContentIsInTraversalRange(mRange, nextNode, aDir == eForward);
 271     if (intersects) {
 272       // Now find the nxt/prv node after/before this node
 273       nsresult rv = AdvanceNode(parent, aNewNode, aDir);
 274       if (NS_SUCCEEDED(rv) && aNewNode) {
 275         return NS_OK;
 276       }
 277     }
 278   }
 279
 280   // if we get here it pretty much means
 281   // we went out of the DOM Range
 282   mIsOutOfRange = true;
 283
 284   return NS_ERROR_FAILURE;
 285 }
 286
 287 // Helper function to see if the next/prev node should be skipped
 288 void FilteredContentIterator::CheckAdvNode(nsINode* aNode, bool& aDidSkip,
 289                                            eDirectionType aDir) {
 290   aDidSkip = false;
 291   mIsOutOfRange = false;
 292
 293   if (aNode && mFilter) {
 294     nsCOMPtr<nsINode> currentNode = aNode;
 295     while (1) {
 296       if (mFilter->Skip(aNode)) {
 297         aDidSkip = true;
 298         // Get the next/prev node and then
 299         // see if we should skip that
 300         nsCOMPtr<nsINode> advNode;
 301         nsresult rv = AdvanceNode(aNode, *getter_AddRefs(advNode), aDir);
 302         if (NS_SUCCEEDED(rv) && advNode) {
 303           aNode = advNode;
 304         } else {
 305           return;  // fell out of range
 306         }
 307       } else {
 308         if (aNode != currentNode) {
 309           nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));
 310           Unused << mCurrentIterator->PositionAt(content);
 311         }
 312         return;  // found something
 313       }
 314     }
 315   }
 316 }
 317
 318 void FilteredContentIterator::Next() {
 319   if (mIsOutOfRange || !mCurrentIterator) {
 320     NS_ASSERTION(mCurrentIterator, "Missing iterator!");
 321
 322     return;
 323   }
 324
 325   // If we are switching directions then
 326   // we need to switch how we process the nodes
 327   if (mDirection != eForward) {
 328     nsresult rv = SwitchDirections(true);
 329     if (NS_FAILED(rv)) {
 330       return;
 331     }
 332   }
 333
 334   mCurrentIterator->Next();
 335
 336   if (mCurrentIterator->IsDone()) {
 337     return;
 338   }
 339
 340   // If we can't get the current node then
 341   // don't check to see if we can skip it
 342   nsINode* currentNode = mCurrentIterator->GetCurrentNode();
 343
 344   CheckAdvNode(currentNode, mDidSkip, eForward);
 345 }
 346
 347 void FilteredContentIterator::Prev() {
 348   if (mIsOutOfRange || !mCurrentIterator) {
 349     NS_ASSERTION(mCurrentIterator, "Missing iterator!");
 350
 351     return;
 352   }
 353
 354   // If we are switching directions then
 355   // we need to switch how we process the nodes
 356   if (mDirection != eBackward) {
 357     nsresult rv = SwitchDirections(false);
 358     if (NS_FAILED(rv)) {
 359       return;
 360     }
 361   }
 362
 363   mCurrentIterator->Prev();
 364
 365   if (mCurrentIterator->IsDone()) {
 366     return;
 367   }
 368
 369   // If we can't get the current node then
 370   // don't check to see if we can skip it
 371   nsINode* currentNode = mCurrentIterator->GetCurrentNode();
 372
 373   CheckAdvNode(currentNode, mDidSkip, eBackward);
 374 }
 375
 376 nsINode* FilteredContentIterator::GetCurrentNode() {
 377   if (mIsOutOfRange || !mCurrentIterator) {
 378     return nullptr;
 379   }
 380
 381   return mCurrentIterator->GetCurrentNode();
 382 }
 383
 384 bool FilteredContentIterator::IsDone() {
 385   if (mIsOutOfRange || !mCurrentIterator) {
 386     return true;
 387   }
 388
 389   return mCurrentIterator->IsDone();
 390 }
 391
 392 nsresult FilteredContentIterator::PositionAt(nsINode* aCurNode) {
 393   NS_ENSURE_TRUE(mCurrentIterator, NS_ERROR_FAILURE);
 394   mIsOutOfRange = false;
 395   return mCurrentIterator->PositionAt(aCurNode);
 396 }
 397
 398 }  // namespace mozilla