Rewrite DocumentMarkerController to use SynchronousMutationObserver

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
@@ skipping 512 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) {
+  // Notify listeners that a replacement has occurred rather than two separate
+  // insert + delete operations
+  SynchronousMutationNotifier::ScopedNotificationSuppressor suppressor(
+      &document());
+
   // DeleteFromTextNodeCommand and InsertIntoTextNodeCommand are never
   // aborted.
   applyCommandToComposite(
       DeleteFromTextNodeCommand::create(node, offset, count),
       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 152 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);

[yosin_UTC9, 2017/02/15 02:23:25]

Let's make |replaceTextInNode()| to use |CharacterData::setData()|, which does
insert/delete at once and notify didUpdateCharacterData().
It can be done by introducing SetCharacterDataCommand().

 }
 
 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 1140 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