[oilpan] Handlify Nodes in htmlediting

Source/core/editing/htmlediting.h

Index: Source/core/editing/htmlediting.h
diff --git a/Source/core/editing/htmlediting.h b/Source/core/editing/htmlediting.h
index 2c0d72dfee6fc48df66b2ba7576b673ae3cc9f66..c55fe1b987b2f8ad14fa982bfe5d21cc2ce602ae 100644
--- a/Source/core/editing/htmlediting.h
+++ b/Source/core/editing/htmlediting.h
@@ -54,29 +54,29 @@ class VisibleSelection;
 // Functions returning Node
 
 Result<Node> highestAncestor(const Handle<Node>&);
-Node* highestEditableRoot(const Position&, EditableType = ContentIsEditable);
+Result<Node> highestEditableRoot(const Position&, EditableType = ContentIsEditable);
 
-Node* highestEnclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*),
-    EditingBoundaryCrossingRule = CannotCrossEditingBoundary, Node* stayWithin = 0);
-Node* highestNodeToRemoveInPruning(Node*);
-Node* lowestEditableAncestor(Node*);
+Result<Node> highestEnclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Handle<const Node>&),
+    EditingBoundaryCrossingRule = CannotCrossEditingBoundary, const Handle<Node>& stayWithin = nullptr);
+Result<Node> highestNodeToRemoveInPruning(const Handle<Node>&);
+Result<Node> lowestEditableAncestor(const Handle<Node>&);
 
-Result<Element> enclosingBlock(Node*, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
-Node* enclosingTableCell(const Position&);
-Node* enclosingEmptyListItem(const VisiblePosition&);
-Node* enclosingAnchorElement(const Position&);
-Node* enclosingNodeWithTag(const Position&, const QualifiedName&);
-Node* enclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
+Result<Element> enclosingBlock(const Handle<Node>&, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
+Result<Node> enclosingTableCell(const Position&);
+Result<Node> enclosingEmptyListItem(const VisiblePosition&);
+Result<Node> enclosingAnchorElement(const Position&);
+Result<Node> enclosingNodeWithTag(const Position&, const QualifiedName&);
+Result<Node> enclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Handle<const Node>&), EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
 
-Node* tabSpanNode(const Node*);
-Node* isLastPositionBeforeTable(const VisiblePosition&);
-Node* isFirstPositionAfterTable(const VisiblePosition&);
+Result<Node> tabSpanNode(const Handle<const Node>&);
+Result<Node> isLastPositionBeforeTable(const VisiblePosition&);
+Result<Node> isFirstPositionAfterTable(const VisiblePosition&);
 
 // offset functions on Node
 
-int lastOffsetForEditing(const Node*);
-int caretMinOffset(const Node*);
-int caretMaxOffset(const Node*);
+int lastOffsetForEditing(const Handle<const Node>&);
+int caretMinOffset(const Handle<const Node>&);
+int caretMaxOffset(const Handle<const Node>&);
 
 // boolean functions on Node
 
@@ -85,34 +85,34 @@ int caretMaxOffset(const Node*);
 
 // Returns true for nodes that either have no content, or have content that is ignored (skipped over) while editing.
 // There are no VisiblePositions inside these nodes.
-inline bool editingIgnoresContent(const Node* node)
+inline bool editingIgnoresContent(const Handle<const Node>& node)
 {
     return !node->canContainRangeEndPoint();
 }
 
-inline bool canHaveChildrenForEditing(const Node* node)
+inline bool canHaveChildrenForEditing(const Handle<const Node>& node)
 {
     return !node->isTextNode() && node->canContainRangeEndPoint();
 }
 
-bool isAtomicNode(const Node*);
-bool isBlock(const Node*);
-bool isInline(const Node*);
-bool isSpecialElement(const Node*);
-bool isTabSpanNode(const Node*);
-bool isTabSpanTextNode(const Node*);
-bool isMailBlockquote(const Node*);
-bool isTableElement(Node*);
-bool isTableCell(const Node*);
-bool isEmptyTableCell(const Node*);
-bool isTableStructureNode(const Node*);
-bool isListElement(Node*);
-bool isListItem(const Node*);
-bool isNodeRendered(const Node*);
-bool isNodeVisiblyContainedWithin(Node*, const Handle<const Range>&);
-bool isRenderedAsNonInlineTableImageOrHR(const Node*);
-bool areIdenticalElements(const Node*, const Node*);
-bool isNonTableCellHTMLBlockElement(const Node*);
+bool isAtomicNode(const Handle<const Node>&);
+bool isBlock(const Handle<const Node>&);
+bool isInline(const Handle<const Node>&);
+bool isSpecialElement(const Handle<const Node>&);
+bool isTabSpanNode(const Handle<const Node>&);
+bool isTabSpanTextNode(const Handle<const Node>&);
+bool isMailBlockquote(const Handle<const Node>&);
+bool isTableElement(const Handle<Node>&);
+bool isTableCell(const Handle<const Node>&);
+bool isEmptyTableCell(const Handle<const Node>&);
+bool isTableStructureNode(const Handle<const Node>&);
+bool isListElement(const Handle<Node>&);
+bool isListItem(const Handle<const Node>&);
+bool isNodeRendered(const Handle<const Node>&);
+bool isNodeVisiblyContainedWithin(const Handle<Node>&, const Handle<const Range>&);
+bool isRenderedAsNonInlineTableImageOrHR(const Handle<const Node>&);
+bool areIdenticalElements(const Handle<const Node>&, const Handle<const Node>&);
+bool isNonTableCellHTMLBlockElement(const Handle<const Node>&);
 TextDirection directionOfEnclosingBlock(const Position&);
 
 // -------------------------------------------------------------------------
@@ -128,24 +128,24 @@ Position nextVisuallyDistinctCandidate(const Position&);
 Position previousVisuallyDistinctCandidate(const Position&);
 
 Position positionOutsideTabSpan(const Position&);
-Position positionBeforeContainingSpecialElement(const Position&, Node** containingSpecialElement = 0);
-Position positionAfterContainingSpecialElement(const Position&, Node** containingSpecialElement = 0);
-Position positionOutsideContainingSpecialElement(const Position&, Node** containingSpecialElement = 0);
+Position positionBeforeContainingSpecialElement(const Position&, Handle<Node>* containingSpecialElement = 0);
+Position positionAfterContainingSpecialElement(const Position&, Handle<Node>* containingSpecialElement = 0);
+Position positionOutsideContainingSpecialElement(const Position&, Handle<Node>* containingSpecialElement = 0);
 
-inline Position firstPositionInOrBeforeNode(Node* node)
+inline Position firstPositionInOrBeforeNode(const Handle<Node>& node)
 {
     HandleScope scope;
     if (!node)
         return Position();
-    return editingIgnoresContent(node) ? positionBeforeNode(adoptRawResult(node)) : firstPositionInNode(adoptRawResult(node));
+    return editingIgnoresContent(node) ? positionBeforeNode(node) : firstPositionInNode(node);
 }
 
-inline Position lastPositionInOrAfterNode(Node* node)
+inline Position lastPositionInOrAfterNode(const Handle<Node>& node)
 {
     HandleScope scope;
     if (!node)
         return Position();
-    return editingIgnoresContent(node) ? positionAfterNode(adoptRawResult(node)) : lastPositionInNode(adoptRawResult(node));
+    return editingIgnoresContent(node) ? positionAfterNode(node) : lastPositionInNode(node);
 }
 
 // comparision functions on Position
@@ -166,7 +166,7 @@ bool isAtUnsplittableElement(const Position&);
 // miscellaneous functions on Position
 
 unsigned numEnclosingMailBlockquotes(const Position&);
-void updatePositionForNodeRemoval(Position&, Node*);
+void updatePositionForNodeRemoval(Position&, const Handle<Node>&);
 
 // -------------------------------------------------------------------------
 // VisiblePosition
@@ -174,10 +174,10 @@ void updatePositionForNodeRemoval(Position&, Node*);
     
 // Functions returning VisiblePosition
     
-VisiblePosition firstEditablePositionAfterPositionInRoot(const Position&, Node*);
-VisiblePosition lastEditablePositionBeforePositionInRoot(const Position&, Node*);
-VisiblePosition visiblePositionBeforeNode(Node*);
-VisiblePosition visiblePositionAfterNode(Node*);
+VisiblePosition firstEditablePositionAfterPositionInRoot(const Position&, const Handle<Node>&);
+VisiblePosition lastEditablePositionBeforePositionInRoot(const Position&, const Handle<Node>&);
+VisiblePosition visiblePositionBeforeNode(const Handle<Node>&);
+VisiblePosition visiblePositionAfterNode(const Handle<Node>&);
 
 bool lineBreakExistsAtVisiblePosition(const VisiblePosition&);
     
@@ -193,7 +193,7 @@ VisiblePosition visiblePositionForIndex(int index, const Handle<ContainerNode>&
 // Functions returning Range
 
 Result<Range> createRange(const Handle<Document>&, const VisiblePosition& start, const VisiblePosition& end, ExceptionCode&);
-Result<Range> extendRangeToWrappingNodes(const Handle<Range>& rangeToExtend, const Handle<const Range>& maximumRange, const Node* rootNode);
+Result<Range> extendRangeToWrappingNodes(const Handle<Range>& rangeToExtend, const Handle<const Range>& maximumRange, const Handle<const Node>& rootNode);
 
 // -------------------------------------------------------------------------
 // HTMLElement
@@ -209,9 +209,9 @@ Result<HTMLElement> createListItemElement(const Handle<Document>&);
 Result<HTMLElement> createHTMLElement(const Handle<Document>&, const QualifiedName&);
 Result<HTMLElement> createHTMLElement(const Handle<Document>&, const AtomicString&);
 
-Result<HTMLElement> enclosingList(Node*);
-Result<HTMLElement> outermostEnclosingList(Node*, Node* rootList = 0);
-Node* enclosingListChild(Node*);
+Result<HTMLElement> enclosingList(const Handle<Node>&);
+Result<HTMLElement> outermostEnclosingList(const Handle<Node>&, const Handle<Node>& rootList = nullptr);
+Result<Node> enclosingListChild(const Handle<Node>&);
 
 // -------------------------------------------------------------------------
 // Element