[oilpan] Handlify Nodes in htmlediting

Source/core/editing/ApplyStyleCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008, 2009 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 247 matching lines @@
     int startIndex = TextIterator::rangeLength(startRange, true);
     int endIndex = TextIterator::rangeLength(endRange, true);
 
     VisiblePosition paragraphStart(startOfParagraph(visibleStart));
     VisiblePosition nextParagraphStart(endOfParagraph(paragraphStart).next());
     VisiblePosition beyondEnd(endOfParagraph(visibleEnd).next());
     while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {
         HandleScope scope;
         StyleChange styleChange(style, paragraphStart.deepEquivalent());
         if (styleChange.cssStyle().length() || m_removeOnly) {
-            Handle<Node> block = enclosingBlock(paragraphStart.deepEquivalent().deprecatedNode().handle().raw());
+            Handle<Node> block = enclosingBlock(paragraphStart.deepEquivalent().deprecatedNode());
             if (!m_removeOnly) {
                 Handle<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());
                 if (newBlock)
                     block = newBlock;
             }
             ASSERT(!block || block->isHTMLElement());
             if (block && block->isHTMLElement()) {
                 removeCSSStyle(style, toHTMLElement(block));
                 if (!m_removeOnly)
                     addBlockStyle(styleChange, toHTMLElement(block));
@@ skipping 71 matching lines @@
     // If the end node is before the start node (can only happen if the end node is
     // an ancestor of the start node), we gather nodes up to the next sibling of the end node
     Handle<Node> beyondEnd;
     if (start.deprecatedNode()->isDescendantOf(end.deprecatedNode().handle().raw()))
         beyondEnd = NodeTraversal::nextSkippingChildren(end.deprecatedNode());
     else
         beyondEnd = NodeTraversal::next(end.deprecatedNode());
     
     start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
     Handle<Node> startNode = start.deprecatedNode();
-    if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode.raw())) // Move out of text node if range does not include its characters.
+    if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
         startNode = NodeTraversal::next(startNode);
 
     // Store away font size before making any changes to the document.
     // This ensures that changes to one node won't effect another.
     CollectionRoot<HashMap<Member<Node>, float> > startingFontSizes;
     for (Handle<Node> node = startNode; node != beyondEnd; node = NodeTraversal::next(node)) {
         HandleScope scope;
         startingFontSizes->set(node, computedFontSize(node));
     }
 
@@ skipping 74 matching lines @@
         if (isSpanWithoutAttributesOrUnstyledStyleSpan(node))
             removeNodePreservingChildren(node);
         node = next;
     }
 }
 
 Result<HTMLElement> ApplyStyleCommand::splitAncestorsWithUnicodeBidi(const Handle<Node>& node, bool before, WritingDirection allowedDirection)
 {
     // We are allowed to leave the highest ancestor with unicode-bidi unsplit if it is unicode-bidi: embed and direction: allowedDirection.
     // In that case, we return the unsplit ancestor. Otherwise, we return 0.
-    Handle<Node> block = enclosingBlock(node.raw());
+    Handle<Node> block = enclosingBlock(node);
     if (!block)
         return nullptr;
 
     Handle<Node> highestAncestorWithUnicodeBidi;
     Handle<Node> nextHighestAncestorWithUnicodeBidi;
     int highestAncestorUnicodeBidi = 0;
     for (Handle<Node> n = node->parentNode(); n != block; n = n->parentNode()) {
         HandleScope scope;
         Handle<CSSStyleDeclaration> styleDeclaration = CSSComputedStyleDeclaration::create(n);
         int unicodeBidi = getIdentifierValue(styleDeclaration, CSSPropertyUnicodeBidi);
@@ skipping 31 matching lines @@
             splitElement(parent, before ? currentNode : currentNode->nextSibling().handle());
         if (parent == highestAncestorWithUnicodeBidi)
             break;
         currentNode = parent;
     }
     return unsplitAncestor;
 }
 
 void ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock(const Handle<Node>& node, const Handle<Node>& unsplitAncestor)
 {
-    Handle<Node> block = enclosingBlock(node.raw());
+    Handle<Node> block = enclosingBlock(node);
     if (!block)
         return;
 
     Handle<Node> parent;
     for (Handle<Node> n = node->parentNode(); n != block && n != unsplitAncestor; n = parent) {
         HandleScope scope;
         parent = n->parentNode();
         if (!n->isStyledElement())
             continue;
 
@@ skipping 134 matching lines @@
     }
 
     // update document layout once before running the rest of the function
     // so that we avoid the expense of updating before each and every call
     // to check a computed style
     document()->updateLayoutIgnorePendingStylesheets();
 
     RefPtr<EditingStyle> styleToApply = style;
     if (hasTextDirection) {
         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
-        Handle<Node> embeddingStartNode = highestEmbeddingAncestor(start.deprecatedNode(), enclosingBlock(start.deprecatedNode().handle().raw()));
-        Handle<Node> embeddingEndNode = highestEmbeddingAncestor(end.deprecatedNode(), enclosingBlock(end.deprecatedNode().handle().raw()));
+        Handle<Node> embeddingStartNode = highestEmbeddingAncestor(start.deprecatedNode(), enclosingBlock(start.deprecatedNode()));
+        Handle<Node> embeddingEndNode = highestEmbeddingAncestor(end.deprecatedNode(), enclosingBlock(end.deprecatedNode()));
 
         if (embeddingStartNode || embeddingEndNode) {
             Position embeddingApplyStart = embeddingStartNode ? positionInParentAfterNode(embeddingStartNode) : start;
             Position embeddingApplyEnd = embeddingEndNode ? positionInParentBeforeNode(embeddingEndNode) : end;
             ASSERT(embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull());
 
             if (!embeddingStyle) {
                 styleWithoutEmbedding = style->copy();
                 embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();
             }
             fixRangeAndApplyInlineStyle(embeddingStyle.get(), embeddingApplyStart, embeddingApplyEnd);
 
             styleToApply = styleWithoutEmbedding;
         }
     }
 
     fixRangeAndApplyInlineStyle(styleToApply.get(), start, end);
 
     // Remove dummy style spans created by splitting text elements.
     cleanupUnstyledAppleStyleSpans(startDummySpanAncestor);
     if (endDummySpanAncestor != startDummySpanAncestor)
         cleanupUnstyledAppleStyleSpans(endDummySpanAncestor);
 }
 
 void ApplyStyleCommand::fixRangeAndApplyInlineStyle(EditingStyle* style, const Position& start, const Position& end)
 {
     Handle<Node> startNode = start.deprecatedNode();
 
-    if (start.deprecatedEditingOffset() >= caretMaxOffset(start.deprecatedNode().handle().raw())) {
+    if (start.deprecatedEditingOffset() >= caretMaxOffset(start.deprecatedNode())) {
         startNode = NodeTraversal::next(startNode);
-        if (!startNode || comparePositions(end, firstPositionInOrBeforeNode(startNode.raw())) < 0)
+        if (!startNode || comparePositions(end, firstPositionInOrBeforeNode(startNode)) < 0)
             return;
     }
 
     Handle<Node> pastEndNode = end.deprecatedNode();
-    if (end.deprecatedEditingOffset() >= caretMaxOffset(end.deprecatedNode().handle().raw()))
+    if (end.deprecatedEditingOffset() >= caretMaxOffset(end.deprecatedNode()))
         pastEndNode = NodeTraversal::nextSkippingChildren(end.deprecatedNode());
 
     // FIXME: Callers should perform this operation on a Range that includes the br
     // if they want style applied to the empty line.
     if (start == end && start.deprecatedNode()->hasTagName(brTag))
         pastEndNode = NodeTraversal::next(start.deprecatedNode());
 
     // Start from the highest fully selected ancestor so that we can modify the fully selected node.
     // e.g. When applying font-size: large on <font color="blue">hello</font>, we need to include the font element in our run
     // to generate <font color="blue" size="4">hello</font> instead of <font color="blue"><font size="4">hello</font></font>
     Handle<Range> range = Range::create(startNode->document(), start, end);
     Handle<Element> editableRoot = startNode->rootEditableElement();
     if (startNode != editableRoot) {
         while (1) {
             HandleScope scope;
-            if (!editableRoot || startNode->parentNode() == editableRoot || !isNodeVisiblyContainedWithin(startNode->parentNode().handle().raw(), range))
+            if (!editableRoot || startNode->parentNode() == editableRoot || !isNodeVisiblyContainedWithin(startNode->parentNode(), range))
                 break;
             startNode = startNode->parentNode();
         }
     }
 
     applyInlineStyleToNodeRange(style, startNode, pastEndNode);
 }
 
 static bool containsNonEditableRegion(const Handle<Node>& node)
 {
@@ skipping 56 matching lines @@
                 break;
             // Add to this element's inline style and skip over its contents.
             Handle<HTMLElement> element = toHTMLElement(node);
             Handle<StylePropertySet> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());
             inlineStyle->mergeAndOverrideOnConflict(style->style());
             setNodeAttribute(element, styleAttr, inlineStyle->asText());
             next = NodeTraversal::nextSkippingChildren(node);
             continue;
         }
         
-        if (isBlock(node.raw()))
+        if (isBlock(node))
             continue;
         
         if (node->childNodeCount()) {
             if (node->contains(pastEndNode) || containsNonEditableRegion(node) || !node->parentNode()->rendererIsEditable())
                 continue;
-            if (editingIgnoresContent(node.raw())) {
+            if (editingIgnoresContent(node)) {
                 next = NodeTraversal::nextSkippingChildren(node);
                 continue;
             }
         }
 
         Handle<Node> runStart = node;
         Handle<Node> runEnd = node;
         Handle<Node> sibling = node->nextSibling();
         while (1) {
             HandleScope scope;
             if (!sibling || sibling == pastEndNode || sibling->contains(pastEndNode)
-                || (isBlock(sibling.raw()) && !sibling->hasTagName(brTag))
+                || (isBlock(sibling) && !sibling->hasTagName(brTag))
                 || containsNonEditableRegion(sibling))
                 break;
             runEnd = sibling;
             sibling = runEnd->nextSibling();
         }
         next = NodeTraversal::nextSkippingChildren(runEnd);
 
         Handle<Node> pastEndNode = NodeTraversal::nextSkippingChildren(runEnd);
         if (!shouldApplyInlineStyleToRun(style, runStart, pastEndNode))
             continue;
@@ skipping 46 matching lines @@
     }
     return false;
 }
 
 void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, Persistent<Node>& runStart, Persistent<Node>& runEnd, const Handle<Node>& pastEndNode)
 {
     ASSERT(runStart && runEnd);
     Handle<Node> next = runStart;
     for (Handle<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
         HandleScope scope;
-        if (editingIgnoresContent(node.raw())) {
+        if (editingIgnoresContent(node)) {
             ASSERT(!node->contains(pastEndNode));
             next = NodeTraversal::nextSkippingChildren(node);
         } else
             next = NodeTraversal::next(node);
         if (!node->isHTMLElement())
             continue;
 
         Handle<Node> previousSibling = node->previousSibling();
         Handle<Node> nextSibling = node->nextSibling();
         Handle<ContainerNode> parent = node->parentNode();
@@ skipping 103 matching lines @@
 
     return true;
 }
 
 Result<HTMLElement> ApplyStyleCommand::highestAncestorWithConflictingInlineStyle(EditingStyle* style, const Handle<Node>& node)
 {
     if (!node)
         return nullptr;
 
     Handle<HTMLElement> result;
-    Handle<Node> unsplittableElement = unsplittableElementForPosition(firstPositionInOrBeforeNode(node.raw()));
+    Handle<Node> unsplittableElement = unsplittableElementForPosition(firstPositionInOrBeforeNode(node));
 
     for (Handle<Node> n = node; n; n = n->parentNode()) {
         HandleScope scope;
         if (n->isHTMLElement() && shouldRemoveInlineStyleFromElement(style, toHTMLElement(n)))
             result = toHTMLElement(n);
         // Should stop at the editable root (cannot cross editing boundary) and
         // also stop at the unsplittable element to be consistent with other UAs
         if (n == unsplittableElement)
             break;
     }
@@ skipping 117 matching lines @@
     // are removed from the document during the work of this function.
     // If pushDownInlineStyleAroundNode has pruned start.deprecatedNode() or end.deprecatedNode(),
     // use pushDownStart or pushDownEnd instead, which pushDownInlineStyleAroundNode won't prune.
     Position s = start.isNull() || start.isOrphan() ? pushDownStart : start;
     Position e = end.isNull() || end.isOrphan() ? pushDownEnd : end;
 
     Handle<Node> node = start.deprecatedNode();
     while (node) {
         HandleScope scope;
         Handle<Node> next;
-        if (editingIgnoresContent(node.raw())) {
+        if (editingIgnoresContent(node)) {
             ASSERT(node == end.deprecatedNode() || !node->contains(end.deprecatedNode()));
             next = NodeTraversal::nextSkippingChildren(node);
         } else
             next = NodeTraversal::next(node);
         if (node->isHTMLElement() && nodeFullySelected(node, start, end)) {
             Handle<HTMLElement> elem = toHTMLElement(node);
             Handle<Node> prevNode = NodeTraversal::previousPostOrder(elem);
             Handle<Node> nextNode = NodeTraversal::next(elem);
             RefPtr<EditingStyle> styleToPushDown;
             Handle<Node> childNode;
             if (isStyledInlineElementToRemove(elem)) {
                 styleToPushDown = EditingStyle::create();
                 childNode = elem->firstChild();
             }
 
             removeInlineStyleFromElement(style, elem, RemoveIfNeeded, styleToPushDown.get());
             if (!elem->inDocument()) {
                 if (s.deprecatedNode() == elem) {
                     // Since elem must have been fully selected, and it is at the start
                     // of the selection, it is clear we can set the new s offset to 0.
                     ASSERT(s.anchorType() == Position::PositionIsBeforeAnchor || s.offsetInContainerNode() <= 0);
-                    s = firstPositionInOrBeforeNode(nextNode.raw());
+                    s = firstPositionInOrBeforeNode(nextNode);
                 }
                 if (e.deprecatedNode() == elem) {
                     // Since elem must have been fully selected, and it is at the end
                     // of the selection, it is clear we can set the new e offset to
                     // the max range offset of prevNode.
                     ASSERT(s.anchorType() == Position::PositionIsAfterAnchor || !offsetIsBeforeLastNodeOffset(s.offsetInContainerNode(), s.containerNode()));
-                    e = lastPositionInOrAfterNode(prevNode.raw());
+                    e = lastPositionInOrAfterNode(prevNode);
                 }
             }
 
             if (styleToPushDown) {
                 for (; childNode; childNode = childNode->nextSibling())
                     applyInlineStyleToPushDown(childNode, styleToPushDown.get());
             }
         }
         if (node == end.deprecatedNode())
             break;
         node = next;
     }
 
     updateStartEnd(s, e);
 }
 
 bool ApplyStyleCommand::nodeFullySelected(const Handle<Node>& node, const Position &start, const Position &end) const
 {
     ASSERT(node);
     ASSERT(node->isElementNode());
 
     // The tree may have changed and Position::upstream() relies on an up-to-date layout.
     node->document()->updateLayoutIgnorePendingStylesheets();
 
-    return comparePositions(firstPositionInOrBeforeNode(node.raw()), start) >= 0
-        && comparePositions(lastPositionInOrAfterNode(node.raw()).upstream(), end) <= 0;
+    return comparePositions(firstPositionInOrBeforeNode(node), start) >= 0
+        && comparePositions(lastPositionInOrAfterNode(node).upstream(), end) <= 0;
 }
 
 bool ApplyStyleCommand::nodeFullyUnselected(const Handle<Node>& node, const Position &start, const Position &end) const
 {
     ASSERT(node);
     ASSERT(node->isElementNode());
 
-    bool isFullyBeforeStart = comparePositions(lastPositionInOrAfterNode(node.raw()).upstream(), start) < 0;
-    bool isFullyAfterEnd = comparePositions(firstPositionInOrBeforeNode(node.raw()), end) > 0;
+    bool isFullyBeforeStart = comparePositions(lastPositionInOrAfterNode(node).upstream(), start) < 0;
+    bool isFullyAfterEnd = comparePositions(firstPositionInOrBeforeNode(node), end) > 0;
 
     return isFullyBeforeStart || isFullyAfterEnd;
 }
 
 void ApplyStyleCommand::splitTextAtStart(const Position& start, const Position& end)
 {
     ASSERT(start.containerNode()->isTextNode());
 
     Position newEnd;
     if (end.anchorType() == Position::PositionIsOffsetInAnchor && start.containerNode() == end.containerNode())
@@ skipping 57 matching lines @@
 bool ApplyStyleCommand::shouldSplitTextElement(const Handle<Element>& element, EditingStyle* style)
 {
     if (!element || !element->isHTMLElement())
         return false;
 
     return shouldRemoveInlineStyleFromElement(style, toHTMLElement(element));
 }
 
 bool ApplyStyleCommand::isValidCaretPositionInTextNode(const Position& position)
 {
-    Node* node = position.containerNode().handle().raw();
+    Handle<Node> node = position.containerNode();
     if (position.anchorType() != Position::PositionIsOffsetInAnchor || !node->isTextNode())
         return false;
     int offsetInText = position.offsetInContainerNode();
     return offsetInText > caretMinOffset(node) && offsetInText < caretMaxOffset(node);
 }
 
 bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position& start, const Position& end)
 {
-    Node* startNode = start.containerNode().handle().raw();
+    Handle<Node> startNode = start.containerNode();
     int startOffset = start.computeOffsetInContainerNode();
     if (startOffset)
         return false;
 
     if (isAtomicNode(startNode)) {
         // note: prior siblings could be unrendered elements. it's silly to miss the
         // merge opportunity just for that.
         if (startNode->previousSibling())
             return false;
 
-        startNode = startNode->parentNode().handle().raw();
+        startNode = startNode->parentNode();
         startOffset = 0;
     }
 
     if (!startNode->isElementNode())
         return false;
 
     Handle<Node> previousSibling = startNode->previousSibling();
 
-    if (previousSibling && areIdenticalElements(startNode, previousSibling.raw())) {
+    if (previousSibling && areIdenticalElements(startNode, previousSibling)) {
         Handle<Element> previousElement = toElement(previousSibling);
-        Handle<Element> element = adoptRawResult(toElement(startNode));
+        Handle<Element> element = toElement(startNode);
         Handle<Node> startChild = element->firstChild();
         ASSERT(startChild);
         mergeIdenticalElements(previousElement, element);
 
         int startOffsetAdjustment = startChild->nodeIndex();
         int endOffsetAdjustment = startNode == end.deprecatedNode() ? startOffsetAdjustment : 0;
-        updateStartEnd(Position(adoptRawResult(startNode), startOffsetAdjustment, Position::PositionIsOffsetInAnchor),
+        updateStartEnd(Position(startNode, startOffsetAdjustment, Position::PositionIsOffsetInAnchor),
                        Position(end.deprecatedNode(), end.deprecatedEditingOffset() + endOffsetAdjustment, Position::PositionIsOffsetInAnchor)); 
         return true;
     }
 
     return false;
 }
 
 bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position& start, const Position& end)
 {
     Handle<Node> endNode = end.containerNode();
     int endOffset = end.computeOffsetInContainerNode();
 
-    if (isAtomicNode(endNode.raw())) {
+    if (isAtomicNode(endNode)) {
         if (offsetIsBeforeLastNodeOffset(endOffset, endNode))
             return false;
 
         unsigned parentLastOffset = end.deprecatedNode()->parentNode()->childNodes()->length() - 1;
         if (end.deprecatedNode()->nextSibling())
             return false;
 
         endNode = end.deprecatedNode()->parentNode();
         endOffset = parentLastOffset;
     }
 
     if (!endNode->isElementNode() || endNode->hasTagName(brTag))
         return false;
 
     Handle<Node> nextSibling = endNode->nextSibling();
-    if (nextSibling && areIdenticalElements(endNode.raw(), nextSibling.raw())) {
+    if (nextSibling && areIdenticalElements(endNode, nextSibling)) {
         Handle<Element> nextElement = toElement(nextSibling);
-        Handle<Element> element = adoptRawResult(toElement(endNode.raw()));
+        Handle<Element> element = toElement(endNode);
         Handle<Node> nextChild = nextElement->firstChild();
 
         mergeIdenticalElements(element, nextElement);
 
         bool shouldUpdateStart = start.containerNode() == endNode;
         int endOffset = nextChild ? nextChild->nodeIndex() : nextElement->childNodes()->length();
         updateStartEnd(shouldUpdateStart ? Position(nextElement, start.offsetInContainerNode(), Position::PositionIsOffsetInAnchor) : start,
             Position(nextElement, endOffset, Position::PositionIsOffsetInAnchor));
         return true;
     }
@@ skipping 19 matching lines @@
             appendNode(node, element);
         }
         if (node.raw() == endNode)
             break;
         node = next;
     }
 
     Handle<Node> nextSibling = element->nextSibling();
     Handle<Node> previousSibling = element->previousSibling();
     if (nextSibling && nextSibling->isElementNode() && nextSibling->rendererIsEditable()
-        && areIdenticalElements(element.raw(), toElement(nextSibling).handle().raw()))
+        && areIdenticalElements(element, toElement(nextSibling)))
         mergeIdenticalElements(element, toElement(nextSibling));
 
     if (previousSibling && previousSibling->isElementNode() && previousSibling->rendererIsEditable()) {
         Handle<Node> mergedElement = previousSibling->nextSibling();
         if (mergedElement->isElementNode() && mergedElement->rendererIsEditable()
-            && areIdenticalElements(toElement(previousSibling).handle().raw(), toElement(mergedElement).handle().raw()))
+            && areIdenticalElements(toElement(previousSibling), toElement(mergedElement)))
             mergeIdenticalElements(toElement(previousSibling), toElement(mergedElement));
     }
 
     // FIXME: We should probably call updateStartEnd if the start or end was in the node
     // range so that the endingSelection() is canonicalized.  See the comments at the end of
     // VisibleSelection::validate().
 }
 
 void ApplyStyleCommand::addBlockStyle(const StyleChange& styleChange, const Handle<HTMLElement>& block)
 {
@@ skipping 31 matching lines @@
 Position ApplyStyleCommand::positionToComputeInlineStyleChange(const Handle<Node>& startNode, Persistent<Node>& dummyElement)
 {
     // It's okay to obtain the style at the startNode because we've removed all relevant styles from the current run.
     Position positionForStyleComparison;
     if (!startNode->isElementNode()) {
         dummyElement = createStyleSpanElement(document());
         insertNodeAt(dummyElement, positionBeforeNode(startNode));
         return positionBeforeNode(dummyElement);
     }
 
-    return firstPositionInOrBeforeNode(startNode.raw());
+    return firstPositionInOrBeforeNode(startNode);
 }
 
 void ApplyStyleCommand::applyInlineStyleChange(const Handle<Node>& passedStart, const Handle<Node>& passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement)
 {
     Handle<Node> startNode = passedStart;
     Handle<Node> endNode = passedEnd;
     ASSERT(startNode->inDocument());
     ASSERT(endNode->inDocument());
 
     // Find appropriate font and span elements top-down.
@@ skipping 120 matching lines @@
         String textToMove = nextText->data();
         insertTextIntoNode(childText, childText->length(), textToMove);
         removeNode(next);
         // don't move child node pointer. it may want to merge with more text nodes.
     }
 
     updateStartEnd(newStart, newEnd);
 }
 
 }