[oilpan] Handlify Nodes in htmlediting

Source/core/editing/htmlediting.h

 /*
  * Copyright (C) 2004, 2006, 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 36 matching lines @@
 
 // This file contains a set of helper functions used by the editing commands
 
 // -------------------------------------------------------------------------
 // Node
 // -------------------------------------------------------------------------
 
 // 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
 
 // FIXME: editingIgnoresContent, canHaveChildrenForEditing, and isAtomicNode
 // should be renamed to reflect its usage.
 
 // 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&);
 
 // -------------------------------------------------------------------------
 // Position
 // -------------------------------------------------------------------------
     
 // Functions returning Position
     
 Position nextCandidate(const Position&);
 Position previousCandidate(const Position&);
     
 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
     
 int comparePositions(const Position&, const Position&);
 
 // boolean functions on Position
 
 enum EUpdateStyle { UpdateStyle, DoNotUpdateStyle };
 bool isEditablePosition(const Position&, EditableType = ContentIsEditable, EUpdateStyle = UpdateStyle);
 bool isRichlyEditablePosition(const Position&, EditableType = ContentIsEditable);
 bool isFirstVisiblePositionInSpecialElement(const Position&);
 bool isLastVisiblePositionInSpecialElement(const Position&);
 bool lineBreakExistsAtPosition(const Position&);
 bool isVisiblyAdjacent(const Position& first, const Position& second);
 bool isAtUnsplittableElement(const Position&);
 
 // miscellaneous functions on Position
 
 unsigned numEnclosingMailBlockquotes(const Position&);
-void updatePositionForNodeRemoval(Position&, Node*);
+void updatePositionForNodeRemoval(Position&, const Handle<Node>&);
 
 // -------------------------------------------------------------------------
 // VisiblePosition
 // -------------------------------------------------------------------------
     
 // 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&);
     
 int comparePositions(const VisiblePosition&, const VisiblePosition&);
 
 int indexForVisiblePosition(const VisiblePosition&, Handle<ContainerNode>& scope);
 VisiblePosition visiblePositionForIndex(int index, const Handle<ContainerNode>& scope);
 
 // -------------------------------------------------------------------------
 // Range
 // -------------------------------------------------------------------------
 
 // 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
 // -------------------------------------------------------------------------
     
 // Functions returning HTMLElement
     
 Result<HTMLElement> createDefaultParagraphElement(const Handle<Document>&);
 Result<HTMLElement> createBreakElement(const Handle<Document>&);
 Result<HTMLElement> createOrderedListElement(const Handle<Document>&);
 Result<HTMLElement> createUnorderedListElement(const Handle<Document>&);
 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
 // -------------------------------------------------------------------------
     
 // Functions returning Element
     
 Result<Element> createTabSpanElement(const Handle<Document>&);
 Result<Element> createTabSpanElement(const Handle<Document>&, PassRefPtr<Node> tabTextNode);
 Result<Element> createTabSpanElement(const Handle<Document>&, const String& tabText);
@@ skipping 29 matching lines @@
     // FIXME: this is required until 6853027 is fixed and text checking can do this for us.
     return character == '\'' || character == rightSingleQuotationMark || character == hebrewPunctuationGershayim;
 }
 
 String stringWithRebalancedWhitespace(const String&, bool startIsStartOfParagraph, bool endIsEndOfParagraph);
 const String& nonBreakingSpaceString();
 
 }
 
 #endif