[oilpan] Handlify Nodes in htmlediting

Source/core/editing/InsertListCommand.cpp

 /*
  * Copyright (C) 2006, 2010 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 22 matching lines @@
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/html/HTMLElement.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 static Node* enclosingListChild(Node* node, Node* listNode)
 {
-    Node* listChild = enclosingListChild(node);
+    Handle<Node> listChild = enclosingListChild(adoptRawResult(node));
     while (listChild && enclosingList(listChild) != listNode) {
         HandleScope scope;
-        listChild = enclosingListChild(listChild->parentNode().handle().raw());
+        listChild = enclosingListChild(listChild->parentNode());
     }
-    return listChild;
+    return listChild.raw();
 }
 
 Result<HTMLElement> InsertListCommand::insertList(const Handle<Document>& document, Type type)
 {
     RefPtr<InsertListCommand> insertCommand = create(document, type);
     insertCommand->apply();
     return insertCommand->m_listElement;
 }
 
 Result<HTMLElement> InsertListCommand::fixOrphanedListChild(Node* node)
@@ skipping 20 matching lines @@
         mergeIdenticalElements(list, nextList);
         return nextList;
     }
     return list;
 }
 
 bool InsertListCommand::selectionHasListOfType(const VisibleSelection& selection, const QualifiedName& listTag)
 {
     VisiblePosition start = selection.visibleStart();
 
-    if (!enclosingList(start.deepEquivalent().deprecatedNode().handle().raw()))
+    if (!enclosingList(start.deepEquivalent().deprecatedNode()))
         return false;
 
     VisiblePosition end = startOfParagraph(selection.visibleEnd());
     while (start.isNotNull() && start != end) {
         HandleScope scope;
-        Handle<Element> listNode = enclosingList(start.deepEquivalent().deprecatedNode().handle().raw());
+        Handle<Element> listNode = enclosingList(start.deepEquivalent().deprecatedNode());
         if (!listNode || !listNode->hasTagName(listTag))
             return false;
         start = startOfNextParagraph(start);
     }
 
     return true;
 }
 
 InsertListCommand::InsertListCommand(const Handle<Document>& document, Type type)
     : CompositeEditCommand(document), m_type(type)
@@ skipping 83 matching lines @@
 
     doApplyForSingleParagraph(false, listTag, endingSelection().firstRange());
 }
 
 void InsertListCommand::doApplyForSingleParagraph(bool forceCreateList, const QualifiedName& listTag, const Handle<Range>& currentSelection)
 {
     // FIXME: This will produce unexpected results for a selection that starts just before a
     // table and ends inside the first cell, selectionForParagraphIteration should probably
     // be renamed and deployed inside setEndingSelection().
     Handle<Node> selectionNode = endingSelection().start().deprecatedNode();
-    Node* listChildNode = enclosingListChild(selectionNode.raw());
+    Handle<Node> listChildNode = enclosingListChild(selectionNode);
     bool switchListType = false;
     if (listChildNode) {
         // Remove the list chlild.
         Handle<HTMLElement> listNode = enclosingList(listChildNode);
         if (!listNode) {
-            listNode = fixOrphanedListChild(listChildNode);
+            listNode = fixOrphanedListChild(listChildNode.raw());
             listNode = mergeWithNeighboringLists(listNode);
         }
         if (!listNode->hasTagName(listTag))
             // listChildNode will be removed from the list and a list of type m_type will be created.
             switchListType = true;
 
         // If the list is of the desired type, and we are not removing the list, then exit early.
         if (!switchListType && forceCreateList)
             return;
 
         // If the entire list is selected, then convert the whole list.
-        if (switchListType && isNodeVisiblyContainedWithin(listNode.raw(), currentSelection)) {
-            bool rangeStartIsInList = visiblePositionBeforeNode(listNode.raw()) == currentSelection->startPosition();
-            bool rangeEndIsInList = visiblePositionAfterNode(listNode.raw()) == currentSelection->endPosition();
+        if (switchListType && isNodeVisiblyContainedWithin(listNode, currentSelection)) {
+            bool rangeStartIsInList = visiblePositionBeforeNode(listNode) == currentSelection->startPosition();
+            bool rangeEndIsInList = visiblePositionAfterNode(listNode) == currentSelection->endPosition();
 
             Handle<HTMLElement> newList = createHTMLElement(document(), listTag);
             insertNodeBefore(newList, listNode);
 
             Handle<Node> firstChildInList = adoptRawResult(enclosingListChild(VisiblePosition(firstPositionInNode(listNode)).deepEquivalent().deprecatedNode().handle().raw(), listNode.raw()));
             Handle<Node> outerBlock = firstChildInList->isBlockFlowElement() ? firstChildInList : Handle<Node>(listNode);
             moveParagraphWithClones(firstPositionInNode(listNode), lastPositionInNode(listNode), newList, outerBlock);
 
             // Manually remove listNode because moveParagraphWithClones sometimes leaves it behind in the document.
             // See the bug 33668 and editing/execCommand/insert-list-orphaned-item-with-nested-lists.html.
             // FIXME: This might be a bug in moveParagraphWithClones or deleteSelection.
             if (listNode && listNode->inDocument())
                 removeNode(listNode);
 
             newList = mergeWithNeighboringLists(newList);
 
             // Restore the start and the end of current selection if they started inside listNode
             // because moveParagraphWithClones could have removed them.
             if (rangeStartIsInList && newList)
                 currentSelection->setStart(newList, 0, IGNORE_EXCEPTION);
             if (rangeEndIsInList && newList)
                 currentSelection->setEnd(newList, lastOffsetInNode(newList), IGNORE_EXCEPTION);
 
             setEndingSelection(VisiblePosition(firstPositionInNode(newList)));
 
             return;
         }
         
-        unlistifyParagraph(endingSelection().visibleStart(), listNode, listChildNode);
+        unlistifyParagraph(endingSelection().visibleStart(), listNode, listChildNode.raw());
     }
 
     if (!listChildNode || switchListType || forceCreateList)
         m_listElement = listifyParagraph(endingSelection().visibleStart(), listTag);
 }
 
 void InsertListCommand::unlistifyParagraph(const VisiblePosition& originalStart, const Handle<HTMLElement>& listNode, Node* listChildNode)
 {
     Node* nextListChild;
     Node* previousListChild;
@@ skipping 12 matching lines @@
         ASSERT(nextListChild != listChildNode);
         previousListChild = enclosingListChild(start.previous().deepEquivalent().deprecatedNode().handle().raw(), listNode.raw());
         ASSERT(previousListChild != listChildNode);
     }
     // When removing a list, we must always create a placeholder to act as a point of insertion
     // for the list content being removed.
     Handle<Element> placeholder = createBreakElement(document());
     Handle<Element> nodeToInsert = placeholder;
     // If the content of the list item will be moved into another list, put it in a list item
     // so that we don't create an orphaned list child.
-    if (enclosingList(listNode.raw())) {
+    if (enclosingList(listNode)) {
         nodeToInsert = createListItemElement(document());
         appendNode(placeholder, nodeToInsert);
     }
 
     if (nextListChild && previousListChild) {
         // We want to pull listChildNode out of listNode, and place it before nextListChild 
         // and after previousListChild, so we split listNode and insert it between the two lists.  
         // But to split listNode, we must first split ancestors of listChildNode between it and listNode,
         // if any exist.
         // FIXME: We appear to split at nextListChild as opposed to listChildNode so that when we remove
@@ skipping 11 matching lines @@
         insertNodeBefore(nodeToInsert, listNode);
     } else
         insertNodeAfter(nodeToInsert, listNode);
 
     VisiblePosition insertionPoint = VisiblePosition(positionBeforeNode(placeholder));
     moveParagraphs(start, end, insertionPoint, /* preserveSelection */ true, /* preserveStyle */ true, adoptRawResult(listChildNode));
 }
 
 static Result<Element> adjacentEnclosingList(const VisiblePosition& pos, const VisiblePosition& adjacentPos, const QualifiedName& listTag)
 {
-    Handle<Element> listNode = outermostEnclosingList(adjacentPos.deepEquivalent().deprecatedNode().handle().raw());
+    Handle<Element> listNode = outermostEnclosingList(adjacentPos.deepEquivalent().deprecatedNode());
     if (!listNode)
         return nullptr;
 
-    Node* previousCell = enclosingTableCell(pos.deepEquivalent());
-    Node* currentCell = enclosingTableCell(adjacentPos.deepEquivalent());
+    Handle<Node> previousCell = enclosingTableCell(pos.deepEquivalent());
+    Handle<Node> currentCell = enclosingTableCell(adjacentPos.deepEquivalent());
 
     if (!listNode->hasTagName(listTag)
         || listNode->contains(pos.deepEquivalent().deprecatedNode())
         || previousCell != currentCell
-        || enclosingList(listNode.raw()) != enclosingList(pos.deepEquivalent().deprecatedNode().handle().raw()))
+        || enclosingList(listNode) != enclosingList(pos.deepEquivalent().deprecatedNode()))
         return nullptr;
 
     return listNode;
 }
 
 Result<HTMLElement> InsertListCommand::listifyParagraph(const VisiblePosition& originalStart, const QualifiedName& listTag)
 {
     VisiblePosition start = startOfParagraph(originalStart, CanSkipOverEditingBoundary);
     VisiblePosition end = endOfParagraph(start, CanSkipOverEditingBoundary);
     
@@ skipping 11 matching lines @@
     Handle<HTMLElement> listElement;
     if (previousList)
         appendNode(listItemElement, previousList);
     else if (nextList)
         insertNodeAt(listItemElement, positionBeforeNode(nextList));
     else {
         // Create the list.
         listElement = createHTMLElement(document(), listTag);
         appendNode(listItemElement, listElement);
 
-        if (start == end && isBlock(start.deepEquivalent().deprecatedNode().handle().raw())) {
+        if (start == end && isBlock(start.deepEquivalent().deprecatedNode())) {
             // Inserting the list into an empty paragraph that isn't held open 
             // by a br or a '\n', will invalidate start and end.  Insert 
             // a placeholder and then recompute start and end.
             Handle<Node> placeholder = insertBlockPlaceholder(start.deepEquivalent());
             start = positionBeforeNode(placeholder);
             end = start;
         }
 
         // Insert the list at a position visually equivalent to start of the
         // paragraph that is being moved into the list. 
         // Try to avoid inserting it somewhere where it will be surrounded by 
         // inline ancestors of start, since it is easier for editing to produce 
         // clean markup when inline elements are pushed down as far as possible.
         Position insertionPos(start.deepEquivalent().upstream());
         // Also avoid the containing list item.
-        Handle<Node> listChild = adoptRawResult(enclosingListChild(insertionPos.deprecatedNode().handle().raw()));
+        Handle<Node> listChild = enclosingListChild(insertionPos.deprecatedNode());
         if (listChild && listChild->hasTagName(liTag))
             insertionPos = positionInParentBeforeNode(listChild);
 
         insertNodeAt(listElement, insertionPos);
 
         // We inserted the list at the start of the content we're about to move
         // Update the start of content, so we don't try to move the list into itself.  bug 19066
         // Layout is necessary since start's node's inline renderers may have been destroyed by the insertion
         // The end of the content may have changed after the insertion and layout so update it as well.
         if (insertionPos == start.deepEquivalent()) {
             listElement->document()->updateLayoutIgnorePendingStylesheets();
             start = startOfParagraph(originalStart, CanSkipOverEditingBoundary);
             end = endOfParagraph(start, CanSkipOverEditingBoundary);
         }
     }
 
     moveParagraph(start, end, positionBeforeNode(placeholder), true);
 
     if (listElement)
         return mergeWithNeighboringLists(listElement);
 
     if (canMergeLists(previousList, nextList))
         mergeIdenticalElements(previousList, nextList);
 
     return listElement;
 }
 
 }