Add m-esr52 at 52.6.0

1 files changed, 695 insertions, 0 deletions

diff --git a/editor/libeditor/SelectionState.cpp b/editor/libeditor/SelectionState.cpp
new file mode 100644
index 000000000..f9ad5947a
--- /dev/null
+++ b/editor/libeditor/SelectionState.cpp
@@ -0,0 +1,695 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/SelectionState.h"
+
+#include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc.
+#include "mozilla/EditorUtils.h"        // for EditorUtils
+#include "mozilla/dom/Selection.h"      // for Selection
+#include "nsAString.h"                  // for nsAString_internal::Length
+#include "nsCycleCollectionParticipant.h"
+#include "nsDebug.h"                    // for NS_ENSURE_TRUE, etc.
+#include "nsError.h"                    // for NS_OK, etc.
+#include "nsIContent.h"                 // for nsIContent
+#include "nsIDOMCharacterData.h"        // for nsIDOMCharacterData
+#include "nsIDOMNode.h"                 // for nsIDOMNode
+#include "nsISupportsImpl.h"            // for nsRange::Release
+#include "nsRange.h"                    // for nsRange
+
+namespace mozilla {
+
+using namespace dom;
+
+/******************************************************************************
+ * mozilla::SelectionState
+ *
+ * Class for recording selection info.  Stores selection as collection of
+ * { {startnode, startoffset} , {endnode, endoffset} } tuples.  Can't store
+ * ranges since dom gravity will possibly change the ranges.
+ ******************************************************************************/
+SelectionState::SelectionState()
+{
+}
+
+SelectionState::~SelectionState()
+{
+  MakeEmpty();
+}
+
+void
+SelectionState::SaveSelection(Selection* aSel)
+{
+  MOZ_ASSERT(aSel);
+  int32_t arrayCount = mArray.Length();
+  int32_t rangeCount = aSel->RangeCount();
+
+  // if we need more items in the array, new them
+  if (arrayCount < rangeCount) {
+    for (int32_t i = arrayCount; i < rangeCount; i++) {
+      mArray.AppendElement();
+      mArray[i] = new RangeItem();
+    }
+  } else if (arrayCount > rangeCount) {
+    // else if we have too many, delete them
+    for (int32_t i = arrayCount - 1; i >= rangeCount; i--) {
+      mArray.RemoveElementAt(i);
+    }
+  }
+
+  // now store the selection ranges
+  for (int32_t i = 0; i < rangeCount; i++) {
+    mArray[i]->StoreRange(aSel->GetRangeAt(i));
+  }
+}
+
+nsresult
+SelectionState::RestoreSelection(Selection* aSel)
+{
+  NS_ENSURE_TRUE(aSel, NS_ERROR_NULL_POINTER);
+
+  // clear out selection
+  aSel->RemoveAllRanges();
+
+  // set the selection ranges anew
+  size_t arrayCount = mArray.Length();
+  for (size_t i = 0; i < arrayCount; i++) {
+    RefPtr<nsRange> range = mArray[i]->GetRange();
+    NS_ENSURE_TRUE(range, NS_ERROR_UNEXPECTED);
+
+    nsresult rv = aSel->AddRange(range);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+  }
+  return NS_OK;
+}
+
+bool
+SelectionState::IsCollapsed()
+{
+  if (mArray.Length() != 1) {
+    return false;
+  }
+  RefPtr<nsRange> range = mArray[0]->GetRange();
+  NS_ENSURE_TRUE(range, false);
+  bool bIsCollapsed = false;
+  range->GetCollapsed(&bIsCollapsed);
+  return bIsCollapsed;
+}
+
+bool
+SelectionState::IsEqual(SelectionState* aSelState)
+{
+  NS_ENSURE_TRUE(aSelState, false);
+  size_t myCount = mArray.Length(), itsCount = aSelState->mArray.Length();
+  if (myCount != itsCount) {
+    return false;
+  }
+  if (!myCount) {
+    return false;
+  }
+
+  for (size_t i = 0; i < myCount; i++) {
+    RefPtr<nsRange> myRange = mArray[i]->GetRange();
+    RefPtr<nsRange> itsRange = aSelState->mArray[i]->GetRange();
+    NS_ENSURE_TRUE(myRange && itsRange, false);
+
+    int16_t compResult;
+    nsresult rv;
+    rv = myRange->CompareBoundaryPoints(nsIDOMRange::START_TO_START, itsRange, &compResult);
+    if (NS_FAILED(rv) || compResult) {
+      return false;
+    }
+    rv = myRange->CompareBoundaryPoints(nsIDOMRange::END_TO_END, itsRange, &compResult);
+    if (NS_FAILED(rv) || compResult) {
+      return false;
+    }
+  }
+  // if we got here, they are equal
+  return true;
+}
+
+void
+SelectionState::MakeEmpty()
+{
+  // free any items in the array
+  mArray.Clear();
+}
+
+bool
+SelectionState::IsEmpty()
+{
+  return mArray.IsEmpty();
+}
+
+/******************************************************************************
+ * mozilla::RangeUpdater
+ *
+ * Class for updating nsRanges in response to editor actions.
+ ******************************************************************************/
+
+RangeUpdater::RangeUpdater()
+  : mLock(false)
+{
+}
+
+RangeUpdater::~RangeUpdater()
+{
+  // nothing to do, we don't own the items in our array.
+}
+
+void
+RangeUpdater::RegisterRangeItem(RangeItem* aRangeItem)
+{
+  if (!aRangeItem) {
+    return;
+  }
+  if (mArray.Contains(aRangeItem)) {
+    NS_ERROR("tried to register an already registered range");
+    return;  // don't register it again.  It would get doubly adjusted.
+  }
+  mArray.AppendElement(aRangeItem);
+}
+
+void
+RangeUpdater::DropRangeItem(RangeItem* aRangeItem)
+{
+  if (!aRangeItem) {
+    return;
+  }
+  mArray.RemoveElement(aRangeItem);
+}
+
+nsresult
+RangeUpdater::RegisterSelectionState(SelectionState& aSelState)
+{
+  size_t theCount = aSelState.mArray.Length();
+  if (theCount < 1) {
+    return NS_ERROR_FAILURE;
+  }
+
+  for (size_t i = 0; i < theCount; i++) {
+    RegisterRangeItem(aSelState.mArray[i]);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::DropSelectionState(SelectionState& aSelState)
+{
+  size_t theCount = aSelState.mArray.Length();
+  if (theCount < 1) {
+    return NS_ERROR_FAILURE;
+  }
+
+  for (size_t i = 0; i < theCount; i++) {
+    DropRangeItem(aSelState.mArray[i]);
+  }
+
+  return NS_OK;
+}
+
+// gravity methods:
+
+nsresult
+RangeUpdater::SelAdjCreateNode(nsINode* aParent,
+                               int32_t aPosition)
+{
+  if (mLock) {
+    // lock set by Will/DidReplaceParent, etc...
+    return NS_OK;
+  }
+  NS_ENSURE_TRUE(aParent, NS_ERROR_NULL_POINTER);
+  size_t count = mArray.Length();
+  if (!count) {
+    return NS_OK;
+  }
+
+  for (size_t i = 0; i < count; i++) {
+    RangeItem* item = mArray[i];
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
+
+    if (item->startNode == aParent && item->startOffset > aPosition) {
+      item->startOffset++;
+    }
+    if (item->endNode == aParent && item->endOffset > aPosition) {
+      item->endOffset++;
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::SelAdjCreateNode(nsIDOMNode* aParent,
+                               int32_t aPosition)
+{
+  nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
+  return SelAdjCreateNode(parent, aPosition);
+}
+
+nsresult
+RangeUpdater::SelAdjInsertNode(nsINode* aParent,
+                               int32_t aPosition)
+{
+  return SelAdjCreateNode(aParent, aPosition);
+}
+
+nsresult
+RangeUpdater::SelAdjInsertNode(nsIDOMNode* aParent,
+                               int32_t aPosition)
+{
+  return SelAdjCreateNode(aParent, aPosition);
+}
+
+void
+RangeUpdater::SelAdjDeleteNode(nsINode* aNode)
+{
+  if (mLock) {
+    // lock set by Will/DidReplaceParent, etc...
+    return;
+  }
+  MOZ_ASSERT(aNode);
+  size_t count = mArray.Length();
+  if (!count) {
+    return;
+  }
+
+  nsCOMPtr<nsINode> parent = aNode->GetParentNode();
+  int32_t offset = parent ? parent->IndexOf(aNode) : -1;
+
+  // check for range endpoints that are after aNode and in the same parent
+  for (size_t i = 0; i < count; i++) {
+    RangeItem* item = mArray[i];
+    MOZ_ASSERT(item);
+
+    if (item->startNode == parent && item->startOffset > offset) {
+      item->startOffset--;
+    }
+    if (item->endNode == parent && item->endOffset > offset) {
+      item->endOffset--;
+    }
+
+    // check for range endpoints that are in aNode
+    if (item->startNode == aNode) {
+      item->startNode   = parent;
+      item->startOffset = offset;
+    }
+    if (item->endNode == aNode) {
+      item->endNode   = parent;
+      item->endOffset = offset;
+    }
+
+    // check for range endpoints that are in descendants of aNode
+    nsCOMPtr<nsINode> oldStart;
+    if (EditorUtils::IsDescendantOf(item->startNode, aNode)) {
+      oldStart = item->startNode;  // save for efficiency hack below.
+      item->startNode   = parent;
+      item->startOffset = offset;
+    }
+
+    // avoid having to call IsDescendantOf() for common case of range startnode == range endnode.
+    if (item->endNode == oldStart ||
+        EditorUtils::IsDescendantOf(item->endNode, aNode)) {
+      item->endNode   = parent;
+      item->endOffset = offset;
+    }
+  }
+}
+
+void
+RangeUpdater::SelAdjDeleteNode(nsIDOMNode* aNode)
+{
+  nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+  NS_ENSURE_TRUE_VOID(node);
+  return SelAdjDeleteNode(node);
+}
+
+nsresult
+RangeUpdater::SelAdjSplitNode(nsIContent& aOldRightNode,
+                              int32_t aOffset,
+                              nsIContent* aNewLeftNode)
+{
+  if (mLock) {
+    // lock set by Will/DidReplaceParent, etc...
+    return NS_OK;
+  }
+  NS_ENSURE_TRUE(aNewLeftNode, NS_ERROR_NULL_POINTER);
+  size_t count = mArray.Length();
+  if (!count) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsINode> parent = aOldRightNode.GetParentNode();
+  int32_t offset = parent ? parent->IndexOf(&aOldRightNode) : -1;
+
+  // first part is same as inserting aNewLeftnode
+  nsresult rv = SelAdjInsertNode(parent, offset - 1);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // next step is to check for range enpoints inside aOldRightNode
+  for (size_t i = 0; i < count; i++) {
+    RangeItem* item = mArray[i];
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
+
+    if (item->startNode == &aOldRightNode) {
+      if (item->startOffset > aOffset) {
+        item->startOffset -= aOffset;
+      } else {
+        item->startNode = aNewLeftNode;
+      }
+    }
+    if (item->endNode == &aOldRightNode) {
+      if (item->endOffset > aOffset) {
+        item->endOffset -= aOffset;
+      } else {
+        item->endNode = aNewLeftNode;
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::SelAdjJoinNodes(nsINode& aLeftNode,
+                              nsINode& aRightNode,
+                              nsINode& aParent,
+                              int32_t aOffset,
+                              int32_t aOldLeftNodeLength)
+{
+  if (mLock) {
+    // lock set by Will/DidReplaceParent, etc...
+    return NS_OK;
+  }
+  size_t count = mArray.Length();
+  if (!count) {
+    return NS_OK;
+  }
+
+  for (size_t i = 0; i < count; i++) {
+    RangeItem* item = mArray[i];
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
+
+    if (item->startNode == &aParent) {
+      // adjust start point in aParent
+      if (item->startOffset > aOffset) {
+        item->startOffset--;
+      } else if (item->startOffset == aOffset) {
+        // join keeps right hand node
+        item->startNode = &aRightNode;
+        item->startOffset = aOldLeftNodeLength;
+      }
+    } else if (item->startNode == &aRightNode) {
+      // adjust start point in aRightNode
+      item->startOffset += aOldLeftNodeLength;
+    } else if (item->startNode == &aLeftNode) {
+      // adjust start point in aLeftNode
+      item->startNode = &aRightNode;
+    }
+
+    if (item->endNode == &aParent) {
+      // adjust end point in aParent
+      if (item->endOffset > aOffset) {
+        item->endOffset--;
+      } else if (item->endOffset == aOffset) {
+        // join keeps right hand node
+        item->endNode = &aRightNode;
+        item->endOffset = aOldLeftNodeLength;
+      }
+    } else if (item->endNode == &aRightNode) {
+      // adjust end point in aRightNode
+       item->endOffset += aOldLeftNodeLength;
+    } else if (item->endNode == &aLeftNode) {
+      // adjust end point in aLeftNode
+      item->endNode = &aRightNode;
+    }
+  }
+
+  return NS_OK;
+}
+
+void
+RangeUpdater::SelAdjInsertText(Text& aTextNode,
+                               int32_t aOffset,
+                               const nsAString& aString)
+{
+  if (mLock) {
+    // lock set by Will/DidReplaceParent, etc...
+    return;
+  }
+
+  size_t count = mArray.Length();
+  if (!count) {
+    return;
+  }
+
+  size_t len = aString.Length();
+  for (size_t i = 0; i < count; i++) {
+    RangeItem* item = mArray[i];
+    MOZ_ASSERT(item);
+
+    if (item->startNode == &aTextNode && item->startOffset > aOffset) {
+      item->startOffset += len;
+    }
+    if (item->endNode == &aTextNode && item->endOffset > aOffset) {
+      item->endOffset += len;
+    }
+  }
+  return;
+}
+
+nsresult
+RangeUpdater::SelAdjDeleteText(nsIContent* aTextNode,
+                               int32_t aOffset,
+                               int32_t aLength)
+{
+  if (mLock) {
+    // lock set by Will/DidReplaceParent, etc...
+    return NS_OK;
+  }
+
+  size_t count = mArray.Length();
+  if (!count) {
+    return NS_OK;
+  }
+  NS_ENSURE_TRUE(aTextNode, NS_ERROR_NULL_POINTER);
+
+  for (size_t i = 0; i < count; i++) {
+    RangeItem* item = mArray[i];
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
+
+    if (item->startNode == aTextNode && item->startOffset > aOffset) {
+      item->startOffset -= aLength;
+      if (item->startOffset < 0) {
+        item->startOffset = 0;
+      }
+    }
+    if (item->endNode == aTextNode && item->endOffset > aOffset) {
+      item->endOffset -= aLength;
+      if (item->endOffset < 0) {
+        item->endOffset = 0;
+      }
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::SelAdjDeleteText(nsIDOMCharacterData* aTextNode,
+                               int32_t aOffset,
+                               int32_t aLength)
+{
+  nsCOMPtr<nsIContent> textNode = do_QueryInterface(aTextNode);
+  return SelAdjDeleteText(textNode, aOffset, aLength);
+}
+
+nsresult
+RangeUpdater::WillReplaceContainer()
+{
+  if (mLock) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  mLock = true;
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::DidReplaceContainer(Element* aOriginalNode,
+                                  Element* aNewNode)
+{
+  NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
+  mLock = false;
+
+  NS_ENSURE_TRUE(aOriginalNode && aNewNode, NS_ERROR_NULL_POINTER);
+  size_t count = mArray.Length();
+  if (!count) {
+    return NS_OK;
+  }
+
+  for (size_t i = 0; i < count; i++) {
+    RangeItem* item = mArray[i];
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
+
+    if (item->startNode == aOriginalNode) {
+      item->startNode = aNewNode;
+    }
+    if (item->endNode == aOriginalNode) {
+      item->endNode = aNewNode;
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::WillRemoveContainer()
+{
+  if (mLock) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  mLock = true;
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::DidRemoveContainer(nsINode* aNode,
+                                 nsINode* aParent,
+                                 int32_t aOffset,
+                                 uint32_t aNodeOrigLen)
+{
+  NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
+  mLock = false;
+
+  NS_ENSURE_TRUE(aNode && aParent, NS_ERROR_NULL_POINTER);
+  size_t count = mArray.Length();
+  if (!count) {
+    return NS_OK;
+  }
+
+  for (size_t i = 0; i < count; i++) {
+    RangeItem* item = mArray[i];
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
+
+    if (item->startNode == aNode) {
+      item->startNode = aParent;
+      item->startOffset += aOffset;
+    } else if (item->startNode == aParent && item->startOffset > aOffset) {
+      item->startOffset += (int32_t)aNodeOrigLen - 1;
+    }
+
+    if (item->endNode == aNode) {
+      item->endNode = aParent;
+      item->endOffset += aOffset;
+    } else if (item->endNode == aParent && item->endOffset > aOffset) {
+      item->endOffset += (int32_t)aNodeOrigLen - 1;
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::DidRemoveContainer(nsIDOMNode* aNode,
+                                 nsIDOMNode* aParent,
+                                 int32_t aOffset,
+                                 uint32_t aNodeOrigLen)
+{
+  nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+  nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
+  return DidRemoveContainer(node, parent, aOffset, aNodeOrigLen);
+}
+
+nsresult
+RangeUpdater::WillInsertContainer()
+{
+  if (mLock) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  mLock = true;
+  return NS_OK;
+}
+
+nsresult
+RangeUpdater::DidInsertContainer()
+{
+  NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
+  mLock = false;
+  return NS_OK;
+}
+
+void
+RangeUpdater::WillMoveNode()
+{
+  mLock = true;
+}
+
+void
+RangeUpdater::DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
+                            nsINode* aNewParent, int32_t aNewOffset)
+{
+  MOZ_ASSERT(aOldParent);
+  MOZ_ASSERT(aNewParent);
+  NS_ENSURE_TRUE_VOID(mLock);
+  mLock = false;
+
+  for (size_t i = 0, count = mArray.Length(); i < count; ++i) {
+    RangeItem* item = mArray[i];
+    NS_ENSURE_TRUE_VOID(item);
+
+    // like a delete in aOldParent
+    if (item->startNode == aOldParent && item->startOffset > aOldOffset) {
+      item->startOffset--;
+    }
+    if (item->endNode == aOldParent && item->endOffset > aOldOffset) {
+      item->endOffset--;
+    }
+
+    // and like an insert in aNewParent
+    if (item->startNode == aNewParent && item->startOffset > aNewOffset) {
+      item->startOffset++;
+    }
+    if (item->endNode == aNewParent && item->endOffset > aNewOffset) {
+      item->endOffset++;
+    }
+  }
+}
+
+/******************************************************************************
+ * mozilla::RangeItem
+ *
+ * Helper struct for SelectionState.  This stores range endpoints.
+ ******************************************************************************/
+
+RangeItem::RangeItem()
+{
+}
+
+RangeItem::~RangeItem()
+{
+}
+
+NS_IMPL_CYCLE_COLLECTION(RangeItem, startNode, endNode)
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(RangeItem, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(RangeItem, Release)
+
+void
+RangeItem::StoreRange(nsRange* aRange)
+{
+  MOZ_ASSERT(aRange);
+  startNode = aRange->GetStartParent();
+  startOffset = aRange->StartOffset();
+  endNode = aRange->GetEndParent();
+  endOffset = aRange->EndOffset();
+}
+
+already_AddRefed<nsRange>
+RangeItem::GetRange()
+{
+  RefPtr<nsRange> range = new nsRange(startNode);
+  if (NS_FAILED(range->Set(startNode, startOffset, endNode, endOffset))) {
+    return nullptr;
+  }
+  return range.forget();
+}
+
+} // namespace mozilla