Improve how DocumentMarkerController updates markers in response to text edits

third_party/WebKit/Source/core/editing/commands/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/editing/commands/CompositeEditCommand.h"
 
+#include <algorithm>
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Range.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/PlainTextRange.h"
 #include "core/editing/RelocatablePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/commands/AppendNodeCommand.h"
 #include "core/editing/commands/ApplyStyleCommand.h"
 #include "core/editing/commands/DeleteFromTextNodeCommand.h"
 #include "core/editing/commands/DeleteSelectionCommand.h"
 #include "core/editing/commands/InsertIntoTextNodeCommand.h"
 #include "core/editing/commands/InsertLineBreakCommand.h"
 #include "core/editing/commands/InsertNodeBeforeCommand.h"
 #include "core/editing/commands/InsertParagraphSeparatorCommand.h"
 #include "core/editing/commands/MergeIdenticalElementsCommand.h"
 #include "core/editing/commands/RemoveCSSPropertyCommand.h"
 #include "core/editing/commands/RemoveNodeCommand.h"
 #include "core/editing/commands/RemoveNodePreservingChildrenCommand.h"
 #include "core/editing/commands/ReplaceNodeWithSpanCommand.h"
 #include "core/editing/commands/ReplaceSelectionCommand.h"
+#include "core/editing/commands/SetCharacterDataCommand.h"
 #include "core/editing/commands/SetNodeAttributeCommand.h"
 #include "core/editing/commands/SplitElementCommand.h"
 #include "core/editing/commands/SplitTextNodeCommand.h"
 #include "core/editing/commands/SplitTextNodeContainingElementCommand.h"
 #include "core/editing/commands/WrapContentsInDummySpanCommand.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/editing/serializers/Serialization.h"
 #include "core/editing/spellcheck/SpellChecker.h"
 #include "core/events/ScopedEventQueue.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLDivElement.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLLIElement.h"
 #include "core/html/HTMLQuoteElement.h"
 #include "core/html/HTMLSpanElement.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutListItem.h"
 #include "core/layout/LayoutText.h"
 #include "core/layout/line/InlineTextBox.h"
-#include <algorithm>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 CompositeEditCommand::CompositeEditCommand(Document& document)
     : EditCommand(document) {
   setStartingSelection(document.frame()
                            ->selection()
                            .computeVisibleSelectionInDOMTreeDeprecated());
@@ skipping 440 matching lines @@
   // DeleteFromTextNodeCommand is never aborted.
   applyCommandToComposite(
       DeleteFromTextNodeCommand::create(node, offset, count),
       ASSERT_NO_EDITING_ABORT);
 }
 
 void CompositeEditCommand::replaceTextInNode(Text* node,
                                              unsigned offset,
                                              unsigned count,
                                              const String& replacementText) {
-  // DeleteFromTextNodeCommand and InsertIntoTextNodeCommand are never
-  // aborted.
+  // SetCharacterDataCommand is never aborted.
   applyCommandToComposite(
-      DeleteFromTextNodeCommand::create(node, offset, count),
+      SetCharacterDataCommand::create(node, offset, count, replacementText),
       ASSERT_NO_EDITING_ABORT);
-  if (!replacementText.isEmpty())
-    applyCommandToComposite(
-        InsertIntoTextNodeCommand::create(node, offset, replacementText),
-        ASSERT_NO_EDITING_ABORT);
 }
 
 Position CompositeEditCommand::replaceSelectedTextInNode(const String& text) {
   Position start = endingSelection().start();
   Position end = endingSelection().end();
   if (start.computeContainerNode() != end.computeContainerNode() ||
       !start.computeContainerNode()->isTextNode() ||
       isTabHTMLSpanElementTextNode(start.computeContainerNode()))
     return Position();
 
   Text* textNode = toText(start.computeContainerNode());
   replaceTextInNode(textNode, start.offsetInContainerNode(),
                     end.offsetInContainerNode() - start.offsetInContainerNode(),
                     text);
 
   return Position(textNode, start.offsetInContainerNode() + text.length());
 }
 
-static void copyMarkerTypesAndDescriptions(
-    const DocumentMarkerVector& markerPointers,
-    Vector<DocumentMarker::MarkerType>& types,
-    Vector<String>& descriptions) {
-  size_t arraySize = markerPointers.size();
-  types.reserveCapacity(arraySize);
-  descriptions.reserveCapacity(arraySize);
-  for (const auto& markerPointer : markerPointers) {
-    types.push_back(markerPointer->type());
-    descriptions.push_back(markerPointer->description());
-  }
-}
-
-void CompositeEditCommand::replaceTextInNodePreservingMarkers(
-    Text* node,
-    unsigned offset,
-    unsigned count,
-    const String& replacementText) {
-  DocumentMarkerController& markerController = document().markers();
-  Vector<DocumentMarker::MarkerType> types;
-  Vector<String> descriptions;
-  copyMarkerTypesAndDescriptions(
-      markerController.markersInRange(
-          EphemeralRange(Position(node, offset),
-                         Position(node, offset + count)),
-          DocumentMarker::AllMarkers()),
-      types, descriptions);
-
-  replaceTextInNode(node, offset, count, replacementText);
-
-  // Re-adding markers requires a clean tree.
-  document().updateStyleAndLayout();
-
-  DocumentLifecycle::DisallowTransitionScope disallowTransition(
-      document().lifecycle());
-  Position startPosition(node, offset);
-  Position endPosition(node, offset + replacementText.length());
-  DCHECK_EQ(types.size(), descriptions.size());
-
-  for (size_t i = 0; i < types.size(); ++i)
-    markerController.addMarker(startPosition, endPosition, types[i],
-                               descriptions[i]);
-}
-
 Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos) {
   if (!isTabHTMLSpanElementTextNode(pos.anchorNode()))
     return pos;
 
   switch (pos.anchorType()) {
     case PositionAnchorType::BeforeChildren:
     case PositionAnchorType::AfterChildren:
       NOTREACHED();
       return pos;
     case PositionAnchorType::OffsetInAnchor:
@@ skipping 143 matching lines @@
       !isWhitespace(toText(textNode->nextSibling())->data()[0]);
   const bool shouldEmitNBSPbeforeEnd =
       (isEndOfParagraph(visibleDownstreamPos) ||
        (unsigned)downstream == text.length()) &&
       !nextSiblingIsTextNode;
   String rebalancedString = stringWithRebalancedWhitespace(
       string, isStartOfParagraph(visibleUpstreamPos) || !upstream,
       shouldEmitNBSPbeforeEnd);
 
   if (string != rebalancedString)
-    replaceTextInNodePreservingMarkers(textNode, upstream, length,
-                                       rebalancedString);
+    replaceTextInNode(textNode, upstream, length, rebalancedString);
 }
 
 void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(
     Position& position) {
   if (!isRichlyEditablePosition(position))
     return;
   Node* node = position.anchorNode();
   if (!node || !node->isTextNode())
     return;
   Text* textNode = toText(node);
@@ skipping 20 matching lines @@
 }
 
 void CompositeEditCommand::
     replaceCollapsibleWhitespaceWithNonBreakingSpaceIfNeeded(
         const VisiblePosition& visiblePosition) {
   if (!isCollapsibleWhitespace(characterAfter(visiblePosition)))
     return;
   Position pos = mostForwardCaretPosition(visiblePosition.deepEquivalent());
   if (!pos.computeContainerNode() || !pos.computeContainerNode()->isTextNode())
     return;
-  replaceTextInNodePreservingMarkers(toText(pos.computeContainerNode()),
-                                     pos.offsetInContainerNode(), 1,
-                                     nonBreakingSpaceString());
+  replaceTextInNode(toText(pos.computeContainerNode()),
+                    pos.offsetInContainerNode(), 1, nonBreakingSpaceString());
 }
 
 void CompositeEditCommand::rebalanceWhitespace() {
   VisibleSelection selection = endingSelection();
   if (selection.isNone())
     return;
 
   rebalanceWhitespaceAt(selection.start());
   if (selection.isRange())
     rebalanceWhitespaceAt(selection.end());
@@ skipping 1172 matching lines @@
 
 DEFINE_TRACE(CompositeEditCommand) {
   visitor->trace(m_commands);
   visitor->trace(m_startingSelection);
   visitor->trace(m_endingSelection);
   visitor->trace(m_undoStep);
   EditCommand::trace(visitor);
 }
 
 }  // namespace blink