[oilpan] Handlify Nodes in htmlediting

Source/core/editing/DeleteSelectionCommand.cpp

 /*
  * Copyright (C) 2005 Apple Computer, 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 29 matching lines @@
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/page/EditorClient.h"
 #include "core/page/Frame.h"
 #include "core/rendering/RenderTableCell.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
-static bool isTableRow(const Node* node)
+static bool isTableRow(const Handle<const Node>& node)
 {
     return node && node->hasTagName(trTag);
 }
 
 static bool isTableCellEmpty(const Handle<Node>& cell)
 {
-    ASSERT(isTableCell(cell.raw()));
+    ASSERT(isTableCell(cell));
     return VisiblePosition(firstPositionInNode(cell)) == VisiblePosition(lastPositionInNode(cell));
 }
 
 static bool isTableRowEmpty(const Handle<Node>& row)
 {
-    if (!isTableRow(row.raw()))
+    if (!isTableRow(row))
         return false;
 
     for (Handle<Node> child = row->firstChild(); child; child = child->nextSibling()) {
         HandleScope scope;
-        if (isTableCell(child.raw()) && !isTableCellEmpty(child))
+        if (isTableCell(child) && !isTableCellEmpty(child))
             return false;
     }
 
     return true;
 }
 
 DeleteSelectionCommand::DeleteSelectionCommand(const Handle<Document>& document, bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements, bool sanitizeMarkup)
     : CompositeEditCommand(document)
     , m_hasSelectionToDelete(false)
     , m_smartDelete(smartDelete)
@@ skipping 25 matching lines @@
     , m_selectionToDelete(selection)
     , m_startBlock(0)
     , m_endBlock(0)
     , m_typingStyle(0)
     , m_deleteIntoBlockquoteStyle(0)
 {
 }
 
 void DeleteSelectionCommand::initializeStartEnd(Position& start, Position& end)
 {
-    Node* startSpecialContainer = 0;
-    Node* endSpecialContainer = 0;
+    Handle<Node> startSpecialContainer;
+    Handle<Node> endSpecialContainer;
  
     start = m_selectionToDelete.start();
     end = m_selectionToDelete.end();
  
     // For HRs, we'll get a position at (HR,1) when hitting delete from the beginning of the previous line, or (HR,0) when forward deleting,
     // but in these cases, we want to delete it, so manually expand the selection
     if (start.deprecatedNode()->hasTagName(hrTag))
         start = positionBeforeNode(start.deprecatedNode());
     else if (end.deprecatedNode()->hasTagName(hrTag))
         end = positionAfterNode(end.deprecatedNode());
     
     // FIXME: This is only used so that moveParagraphs can avoid the bugs in special element expansion.
     if (!m_expandForSpecialElements)
         return;
     
     while (1) {
         HandleScope scope;
-        startSpecialContainer = 0;
-        endSpecialContainer = 0;
+        startSpecialContainer = nullptr;
+        endSpecialContainer = nullptr;
     
         Position s = positionBeforeContainingSpecialElement(start, &startSpecialContainer);
         Position e = positionAfterContainingSpecialElement(end, &endSpecialContainer);
         
         if (!startSpecialContainer && !endSpecialContainer)
             break;
             
         if (VisiblePosition(start) != m_selectionToDelete.visibleStart() || VisiblePosition(end) != m_selectionToDelete.visibleEnd())
             break;
 
         // If we're going to expand to include the startSpecialContainer, it must be fully selected.
-        if (startSpecialContainer && !endSpecialContainer && comparePositions(positionInParentAfterNode(adoptRawResult(startSpecialContainer)), end) > -1)
+        if (startSpecialContainer && !endSpecialContainer && comparePositions(positionInParentAfterNode(startSpecialContainer), end) > -1)
             break;
 
         // If we're going to expand to include the endSpecialContainer, it must be fully selected.
-        if (endSpecialContainer && !startSpecialContainer && comparePositions(start, positionInParentBeforeNode(adoptRawResult(endSpecialContainer))) > -1)
+        if (endSpecialContainer && !startSpecialContainer && comparePositions(start, positionInParentBeforeNode(endSpecialContainer)) > -1)
             break;
 
-        if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSpecialContainer))
+        if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSpecialContainer.raw()))
             // Don't adjust the end yet, it is the end of a special element that contains the start
             // special element (which may or may not be fully selected).
             start = s;
-        else if (endSpecialContainer && endSpecialContainer->isDescendantOf(startSpecialContainer))
+        else if (endSpecialContainer && endSpecialContainer->isDescendantOf(startSpecialContainer.raw()))
             // Don't adjust the start yet, it is the start of a special element that contains the end
             // special element (which may or may not be fully selected).
             end = e;
         else {
             start = s;
             end = e;
         }
     }
 }
 
@@ skipping 17 matching lines @@
     initializeStartEnd(start, end);
     
     m_upstreamStart = start.upstream();
     m_downstreamStart = start.downstream();
     m_upstreamEnd = end.upstream();
     m_downstreamEnd = end.downstream();
     
     m_startRoot = editableRootForPosition(start);
     m_endRoot = editableRootForPosition(end);
     
-    m_startTableRow = adoptRawResult(enclosingNodeOfType(start, &isTableRow));
-    m_endTableRow = adoptRawResult(enclosingNodeOfType(end, &isTableRow));
+    m_startTableRow = enclosingNodeOfType(start, &isTableRow);
+    m_endTableRow = enclosingNodeOfType(end, &isTableRow);
     
     // Don't move content out of a table cell.
     // If the cell is non-editable, enclosingNodeOfType won't return it by default, so
     // tell that function that we don't care if it returns non-editable nodes.
-    Handle<Node> startCell = adoptRawResult(enclosingNodeOfType(m_upstreamStart, &isTableCell, CanCrossEditingBoundary));
-    Handle<Node> endCell = adoptRawResult(enclosingNodeOfType(m_downstreamEnd, &isTableCell, CanCrossEditingBoundary));
+    Handle<Node> startCell = enclosingNodeOfType(m_upstreamStart, &isTableCell, CanCrossEditingBoundary);
+    Handle<Node> endCell = enclosingNodeOfType(m_downstreamEnd, &isTableCell, CanCrossEditingBoundary);
     // FIXME: This isn't right.  A borderless table with two rows and a single column would appear as two paragraphs.
     if (endCell && endCell != startCell)
         m_mergeBlocksAfterDelete = false;
     
     // Usually the start and the end of the selection to delete are pulled together as a result of the deletion.
     // Sometimes they aren't (like when no merge is requested), so we must choose one position to hold the caret 
     // and receive the placeholder after deletion.
     VisiblePosition visibleEnd(m_downstreamEnd);
     if (m_mergeBlocksAfterDelete && !isEndOfParagraph(visibleEnd))
         m_endingPosition = m_downstreamEnd;
@@ skipping 52 matching lines @@
             setStartingSelectionOnSmartDelete(m_downstreamStart, m_downstreamEnd);
         }
     }
     
     // We must pass call parentAnchoredEquivalent on the positions since some editing positions
     // that appear inside their nodes aren't really inside them.  [hr, 0] is one example.
     // FIXME: parentAnchoredEquivalent should eventually be moved into enclosing element getters
     // like the one below, since editing functions should obviously accept editing positions.
     // FIXME: Passing false to enclosingNodeOfType tells it that it's OK to return a non-editable
     // node.  This was done to match existing behavior, but it seems wrong.
-    m_startBlock = adoptRawResult(enclosingNodeOfType(m_downstreamStart.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary));
-    m_endBlock = adoptRawResult(enclosingNodeOfType(m_upstreamEnd.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary));
+    m_startBlock = enclosingNodeOfType(m_downstreamStart.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary);
+    m_endBlock = enclosingNodeOfType(m_upstreamEnd.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary);
 }
 
 void DeleteSelectionCommand::saveTypingStyleState()
 {
     // A common case is deleting characters that are all from the same text node. In 
     // that case, the style at the start of the selection before deletion will be the 
     // same as the style at the start of the selection after deletion (since those
     // two positions will be identical). Therefore there is no need to save the
     // typing style at the start of the selection, nor is there a reason to 
     // compute the style at the start of the selection after deletion (see the 
     // early return in calculateTypingStyleAfterDelete).
     if (m_upstreamStart.deprecatedNode() == m_downstreamEnd.deprecatedNode() && m_upstreamStart.deprecatedNode()->isTextNode())
         return;
 
     // Figure out the typing style in effect before the delete is done.
     m_typingStyle = EditingStyle::create(m_selectionToDelete.start());
-    m_typingStyle->removeStyleAddedByNode(adoptRawResult(enclosingAnchorElement(m_selectionToDelete.start())));
+    m_typingStyle->removeStyleAddedByNode(enclosingAnchorElement(m_selectionToDelete.start()));
 
     // If we're deleting into a Mail blockquote, save the style at end() instead of start()
     // We'll use this later in computeTypingStyleAfterDelete if we end up outside of a Mail blockquote
     if (enclosingNodeOfType(m_selectionToDelete.start(), isMailBlockquote))
         m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.end());
     else
         m_deleteIntoBlockquoteStyle = 0;
 }
 
 bool DeleteSelectionCommand::handleSpecialCaseBRDelete()
@@ skipping 26 matching lines @@
 }
 
 static Position firstEditablePositionInNode(const Handle<Node>& node)
 {
     ASSERT(node);
     Handle<Node> next = node;
     while (next && !next->rendererIsEditable()) {
         HandleScope scope;
         next = NodeTraversal::next(next, node);
     }
-    return next ? firstPositionInOrBeforeNode(next.raw()) : Position();
+    return next ? firstPositionInOrBeforeNode(next) : Position();
 }
 
 void DeleteSelectionCommand::removeNode(const Handle<Node>& node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
 {
     if (!node)
         return;
         
     if (m_startRoot != m_endRoot && !(node->isDescendantOf(m_startRoot.raw()) && node->isDescendantOf(m_endRoot.raw()))) {
         // If a node is not in both the start and end editable roots, remove it only if its inside an editable region.
         if (!node->parentNode()->rendererIsEditable()) {
@@ skipping 10 matching lines @@
                 if (nextChild && nextChild->parentNode() != node)
                     return;
                 child = nextChild;
             }
             
             // Don't remove editable regions that are inside non-editable ones, just clear them.
             return;
         }
     }
     
-    if (isTableStructureNode(node.raw()) || node->isRootEditableElement()) {
+    if (isTableStructureNode(node) || node->isRootEditableElement()) {
         // Do not remove an element of table structure; remove its contents.
         // Likewise for the root editable element.
         for (Handle<Node> child = node->firstChild(); child; ) {
             HandleScope scope;
             Handle<Node> remove = child;
             child = child->nextSibling();
             removeNode(remove, shouldAssumeContentIsAlwaysEditable);
         }
         
         // Make sure empty cell has some height, if a placeholder can be inserted.
         document()->updateLayoutIgnorePendingStylesheets();
         RenderObject *r = node->renderer();
         if (r && r->isTableCell() && toRenderTableCell(r)->contentHeight() <= 0) {
             Position firstEditablePosition = firstEditablePositionInNode(node);
             if (firstEditablePosition.isNotNull())
                 insertBlockPlaceholder(firstEditablePosition);
         }
         return;
     }
     
     if (node == m_startBlock && !isEndOfBlock(VisiblePosition(firstPositionInNode(m_startBlock)).previous()))
         m_needPlaceholder = true;
     else if (node == m_endBlock && !isStartOfBlock(VisiblePosition(lastPositionInNode(m_startBlock)).next()))
         m_needPlaceholder = true;
     
     // FIXME: Update the endpoints of the range being deleted.
-    updatePositionForNodeRemoval(m_endingPosition, node.raw());
-    updatePositionForNodeRemoval(m_leadingWhitespace, node.raw());
-    updatePositionForNodeRemoval(m_trailingWhitespace, node.raw());
+    updatePositionForNodeRemoval(m_endingPosition, node);
+    updatePositionForNodeRemoval(m_leadingWhitespace, node);
+    updatePositionForNodeRemoval(m_trailingWhitespace, node);
     
     CompositeEditCommand::removeNode(node, shouldAssumeContentIsAlwaysEditable);
 }
 
 static void updatePositionForTextRemoval(const Handle<Node>& node, int offset, int count, Position& position)
 {
     if (position.anchorType() != Position::PositionIsOffsetInAnchor || position.containerNode() != node)
         return;
 
     if (position.offsetInContainerNode() > offset + count)
@@ skipping 34 matching lines @@
 {
     if (m_upstreamStart.isNull())
         return;
 
     int startOffset = m_upstreamStart.deprecatedEditingOffset();
     Handle<Node> startNode = m_upstreamStart.deprecatedNode();
     
     makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss();
 
     // Never remove the start block unless it's a table, in which case we won't merge content in.
-    if (startNode == m_startBlock && startOffset == 0 && canHaveChildrenForEditing(startNode.raw()) && !startNode->hasTagName(tableTag)) {
+    if (startNode == m_startBlock && startOffset == 0 && canHaveChildrenForEditing(startNode) && !startNode->hasTagName(tableTag)) {
         startOffset = 0;
         startNode = NodeTraversal::next(startNode);
         if (!startNode)
             return;
     }
 
-    if (startOffset >= caretMaxOffset(startNode.raw()) && startNode->isTextNode()) {
+    if (startOffset >= caretMaxOffset(startNode) && startNode->isTextNode()) {
         Handle<Text> text = toText(startNode);
-        if (text->length() > (unsigned)caretMaxOffset(startNode.raw()))
-            deleteTextFromNode(text, caretMaxOffset(startNode.raw()), text->length() - caretMaxOffset(startNode.raw()));
+        if (text->length() > (unsigned)caretMaxOffset(startNode))
+            deleteTextFromNode(text, caretMaxOffset(startNode), text->length() - caretMaxOffset(startNode));
     }
 
-    if (startOffset >= lastOffsetForEditing(startNode.raw())) {
+    if (startOffset >= lastOffsetForEditing(startNode)) {
         startNode = NodeTraversal::nextSkippingChildren(startNode);
         startOffset = 0;
     }
 
     // Done adjusting the start.  See if we're all done.
     if (!startNode)
         return;
 
     if (startNode == m_downstreamEnd.deprecatedNode()) {
         if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) {
@@ skipping 26 matching lines @@
                 node = startNode->childNode(startOffset);
             }
         } else if (startNode == m_upstreamEnd.deprecatedNode() && startNode->isTextNode()) {
             Handle<Text> text = toText(m_upstreamEnd.deprecatedNode());
             deleteTextFromNode(text, 0, m_upstreamEnd.deprecatedEditingOffset());
         }
         
         // handle deleting all nodes that are completely selected
         while (node && node != m_downstreamEnd.deprecatedNode()) {
             HandleScope scope;
-            if (comparePositions(firstPositionInOrBeforeNode(node.raw()), m_downstreamEnd) >= 0) {
+            if (comparePositions(firstPositionInOrBeforeNode(node), m_downstreamEnd) >= 0) {
                 // NodeTraversal::nextSkippingChildren just blew past the end position, so stop deleting
                 node = nullptr;
             } else if (!m_downstreamEnd.deprecatedNode()->isDescendantOf(node.raw())) {
                 Handle<Node> nextNode = NodeTraversal::nextSkippingChildren(node);
                 // if we just removed a node from the end container, update end position so the
                 // check above will work
-                updatePositionForNodeRemoval(m_downstreamEnd, node.raw());
+                updatePositionForNodeRemoval(m_downstreamEnd, node);
                 removeNode(node);
                 node = nextNode;
             } else {
                 Handle<Node> n = node->lastDescendant();
-                if (m_downstreamEnd.deprecatedNode() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(n.raw())) {
+                if (m_downstreamEnd.deprecatedNode() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(n)) {
                     removeNode(node);
                     node = nullptr;
                 } else
                     node = NodeTraversal::next(node);
             }
         }
         
-        if (m_downstreamEnd.deprecatedNode() != startNode && !m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode().handle().raw()) && m_downstreamEnd.anchorNode()->inDocument() && m_downstreamEnd.deprecatedEditingOffset() >= caretMinOffset(m_downstreamEnd.deprecatedNode().handle().raw())) {
-            if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.deprecatedNode().handle().raw())) {
+        if (m_downstreamEnd.deprecatedNode() != startNode && !m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode().handle().raw()) && m_downstreamEnd.anchorNode()->inDocument() && m_downstreamEnd.deprecatedEditingOffset() >= caretMinOffset(m_downstreamEnd.deprecatedNode())) {
+            if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.deprecatedNode())) {
                 // The node itself is fully selected, not just its contents.  Delete it.
                 removeNode(m_downstreamEnd.deprecatedNode());
             } else {
                 if (m_downstreamEnd.deprecatedNode()->isTextNode()) {
                     // in a text node that needs to be trimmed
                     Handle<Text> text = toText(m_downstreamEnd.deprecatedNode());
                     if (m_downstreamEnd.deprecatedEditingOffset() > 0) {
                         deleteTextFromNode(text, 0, m_downstreamEnd.deprecatedEditingOffset());
                     }
                 // Remove children of m_downstreamEnd.deprecatedNode() that come after m_upstreamStart.
@@ skipping 65 matching lines @@
         
     // There's nothing to merge.
     if (m_upstreamStart == m_downstreamEnd)
         return;
         
     VisiblePosition startOfParagraphToMove(m_downstreamEnd);
     VisiblePosition mergeDestination(m_upstreamStart);
     
     // m_downstreamEnd's block has been emptied out by deletion.  There is no content inside of it to
     // move, so just remove it.
-    Handle<Element> endBlock = enclosingBlock(m_downstreamEnd.deprecatedNode().handle().raw());
+    Handle<Element> endBlock = enclosingBlock(m_downstreamEnd.deprecatedNode());
     if (!endBlock || !endBlock->contains(startOfParagraphToMove.deepEquivalent().deprecatedNode()) || !startOfParagraphToMove.deepEquivalent().deprecatedNode()) {
-        removeNode(enclosingBlock(m_downstreamEnd.deprecatedNode().handle().raw()));
+        removeNode(enclosingBlock(m_downstreamEnd.deprecatedNode()));
         return;
     }
     
     // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.
-    if (!mergeDestination.deepEquivalent().deprecatedNode() || !mergeDestination.deepEquivalent().deprecatedNode()->isDescendantOf(enclosingBlock(m_upstreamStart.containerNode().handle().raw()).handle().raw()) || m_startsAtEmptyLine) {
+    if (!mergeDestination.deepEquivalent().deprecatedNode() || !mergeDestination.deepEquivalent().deprecatedNode()->isDescendantOf(enclosingBlock(m_upstreamStart.containerNode()).handle().raw()) || m_startsAtEmptyLine) {
         insertNodeAt(createBreakElement(document()), m_upstreamStart);
         mergeDestination = VisiblePosition(m_upstreamStart);
     }
     
     if (mergeDestination == startOfParagraphToMove)
         return;
         
     VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove);
     
     if (mergeDestination == endOfParagraphToMove)
         return;
     
     // The rule for merging into an empty block is: only do so if its farther to the right.
     // FIXME: Consider RTL.
     if (!m_startsAtEmptyLine && isStartOfParagraph(mergeDestination) && startOfParagraphToMove.absoluteCaretBounds().x() > mergeDestination.absoluteCaretBounds().x()) {
         if (mergeDestination.deepEquivalent().downstream().deprecatedNode()->hasTagName(brTag)) {
             removeNodeAndPruneAncestors(mergeDestination.deepEquivalent().downstream().deprecatedNode());
             m_endingPosition = startOfParagraphToMove.deepEquivalent();
             return;
         }
     }
     
     // Block images, tables and horizontal rules cannot be made inline with content at mergeDestination.  If there is 
     // any (!isStartOfParagraph(mergeDestination)), don't merge, just move the caret to just before the selection we deleted.
     // See https://bugs.webkit.org/show_bug.cgi?id=25439
-    if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().deprecatedNode().handle().raw()) && !isStartOfParagraph(mergeDestination)) {
+    if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().deprecatedNode()) && !isStartOfParagraph(mergeDestination)) {
         m_endingPosition = m_upstreamStart;
         return;
     }
     
     Handle<Range> range = Range::create(document(), startOfParagraphToMove.deepEquivalent().parentAnchoredEquivalent(), endOfParagraphToMove.deepEquivalent().parentAnchoredEquivalent());
     Handle<Range> rangeToBeReplaced = Range::create(document(), mergeDestination.deepEquivalent().parentAnchoredEquivalent(), mergeDestination.deepEquivalent().parentAnchoredEquivalent());
     if (!document()->frame()->editor()->client()->shouldMoveRangeAfterDelete(range, rangeToBeReplaced))
         return;
     
     // moveParagraphs will insert placeholders if it removes blocks that would require their use, don't let block
@@ skipping 149 matching lines @@
     EAffinity affinity = m_selectionToDelete.affinity();
     
     Position downstreamEnd = m_selectionToDelete.end().downstream();
     m_needPlaceholder = isStartOfParagraph(m_selectionToDelete.visibleStart(), CanCrossEditingBoundary)
             && isEndOfParagraph(m_selectionToDelete.visibleEnd(), CanCrossEditingBoundary)
             && !lineBreakExistsAtVisiblePosition(m_selectionToDelete.visibleEnd());
     if (m_needPlaceholder) {
         // Don't need a placeholder when deleting a selection that starts just before a table
         // and ends inside it (we do need placeholders to hold open empty cells, but that's
         // handled elsewhere).
-        if (Handle<Node> table = adoptRawResult(isLastPositionBeforeTable(m_selectionToDelete.visibleStart())))
+        if (Handle<Node> table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart()))
             if (m_selectionToDelete.end().deprecatedNode()->isDescendantOf(table.raw()))
                 m_needPlaceholder = false;
     }
         
     
     // set up our state
     initializePositionData();
 
     // Delete any text that may hinder our ability to fixup whitespace after the delete
     deleteInsignificantTextDownstream(m_trailingWhitespace);    
@@ skipping 49 matching lines @@
 
 // Normally deletion doesn't preserve the typing style that was present before it.  For example,
 // type a character, Bold, then delete the character and start typing.  The Bold typing style shouldn't
 // stick around.  Deletion should preserve a typing style that *it* sets, however.
 bool DeleteSelectionCommand::preservesTypingStyle() const
 {
     return m_typingStyle;
 }
 
 } // namespace WebCore