Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / third_party / WebKit / Source / core / editing / htmlediting.h

diff --git a/src/third_party/WebKit/Source/core/editing/htmlediting.h b/src/third_party/WebKit/Source/core/editing/htmlediting.h
index 309520a..cc119fa 100644 (file)
--- a/src/third_party/WebKit/Source/core/editing/htmlediting.h
+++ b/src/third_party/WebKit/Source/core/editing/htmlediting.h
@@ -32,14 +32,20 @@
 #include "wtf/Forward.h"
 #include "wtf/unicode/CharacterNames.h"
 
-namespace WebCore {
+namespace blink {
 
 class Document;
 class Element;
 class ExceptionState;
+class HTMLBRElement;
 class HTMLElement;
+class HTMLLIElement;
+class HTMLOListElement;
+class HTMLSpanElement;
+class HTMLUListElement;
 class Node;
 class Position;
+class PositionWithAffinity;
 class Range;
 class VisiblePosition;
 class VisibleSelection;
@@ -53,23 +59,25 @@ class VisibleSelection;
 
 // Functions returning Node
 
-Node* highestEditableRoot(const Position&, EditableType = ContentIsEditable);
+ContainerNode* highestEditableRoot(const Position&, EditableType = ContentIsEditable);
 
 Node* highestEnclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*),
     EditingBoundaryCrossingRule = CannotCrossEditingBoundary, Node* stayWithin = 0);
 Node* highestNodeToRemoveInPruning(Node*, Node* excludeNode = 0);
-Node* lowestEditableAncestor(Node*);
+Element* lowestEditableAncestor(Node*);
 
 Element* enclosingBlock(Node*, EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
-Node* enclosingTableCell(const Position&);
+Element* enclosingBlockFlowElement(Node&); // Deprecated, use enclosingBlock instead.
+bool inSameContainingBlockFlowElement(Node*, Node*);
+Element* enclosingTableCell(const Position&);
 Node* enclosingEmptyListItem(const VisiblePosition&);
 Element* enclosingAnchorElement(const Position&);
-Node* enclosingNodeWithTag(const Position&, const QualifiedName&);
+Element* enclosingElementWithTag(const Position&, const QualifiedName&);
 Node* enclosingNodeOfType(const Position&, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule = CannotCrossEditingBoundary);
 
-Node* tabSpanNode(const Node*);
-Node* isLastPositionBeforeTable(const VisiblePosition&);
-Node* isFirstPositionAfterTable(const VisiblePosition&);
+HTMLSpanElement* tabSpanElement(const Node*);
+Element* isLastPositionBeforeTable(const VisiblePosition&);
+Element* isFirstPositionAfterTable(const VisiblePosition&);
 
 // offset functions on Node
 
@@ -97,22 +105,23 @@ inline bool canHaveChildrenForEditing(const Node* node)
 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 isRenderedTable(const Node*);
-bool isTableElement(const Node*);
+bool isSpecialHTMLElement(const Node*);
+bool isTabHTMLSpanElement(const Node*);
+bool isTabHTMLSpanElementTextNode(const Node*);
+bool isMailHTMLBlockquoteElement(const Node*);
+bool isRenderedTableElement(const Node*);
+bool isRenderedHTMLTableElement(const Node*);
 bool isTableCell(const Node*);
 bool isEmptyTableCell(const Node*);
 bool isTableStructureNode(const Node*);
-bool isListElement(Node*);
+bool isHTMLListElement(Node*);
 bool isListItem(const Node*);
 bool isNodeRendered(const Node*);
-bool isNodeVisiblyContainedWithin(Node*, const Range*);
+bool isNodeVisiblyContainedWithin(Node&, const Range&);
 bool isRenderedAsNonInlineTableImageOrHR(const Node*);
 bool areIdenticalElements(const Node*, const Node*);
 bool isNonTableCellHTMLBlockElement(const Node*);
+bool isBlockFlowElement(const Node&);
 TextDirection directionOfEnclosingBlock(const Position&);
 
 // -------------------------------------------------------------------------
@@ -127,8 +136,8 @@ Position previousCandidate(const Position&);
 Position nextVisuallyDistinctCandidate(const Position&);
 Position previousVisuallyDistinctCandidate(const Position&);
 
-Position positionBeforeContainingSpecialElement(const Position&, Node** containingSpecialElement = 0);
-Position positionAfterContainingSpecialElement(const Position&, Node** containingSpecialElement = 0);
+Position positionBeforeContainingSpecialElement(const Position&, HTMLElement** containingSpecialElement = 0);
+Position positionAfterContainingSpecialElement(const Position&, HTMLElement** containingSpecialElement = 0);
 
 inline Position firstPositionInOrBeforeNode(Node* node)
 {
@@ -144,6 +153,8 @@ inline Position lastPositionInOrAfterNode(Node* node)
     return editingIgnoresContent(node) ? positionAfterNode(node) : lastPositionInNode(node);
 }
 
+Position lastEditablePositionBeforePositionInRoot(const Position&, Node*);
+
 // comparision functions on Position
 
 int comparePositions(const Position&, const Position&);
@@ -152,6 +163,10 @@ int comparePositions(const PositionWithAffinity&, const PositionWithAffinity&);
 // boolean functions on Position
 
 enum EUpdateStyle { UpdateStyle, DoNotUpdateStyle };
+// FIXME: Both isEditablePosition and isRichlyEditablePosition rely on up-to-date
+// style to give proper results. They shouldn't update style by default, but
+// should make it clear that that is the contract.
+// FIXME: isRichlyEditablePosition should also take EUpdateStyle.
 bool isEditablePosition(const Position&, EditableType = ContentIsEditable, EUpdateStyle = UpdateStyle);
 bool isRichlyEditablePosition(const Position&, EditableType = ContentIsEditable);
 bool lineBreakExistsAtPosition(const Position&);
@@ -160,8 +175,11 @@ bool isAtUnsplittableElement(const Position&);
 
 // miscellaneous functions on Position
 
+enum WhitespacePositionOption { NotConsiderNonCollapsibleWhitespace, ConsiderNonCollapsibleWhitespace };
+Position leadingWhitespacePosition(const Position&, EAffinity, WhitespacePositionOption = NotConsiderNonCollapsibleWhitespace);
+Position trailingWhitespacePosition(const Position&, EAffinity, WhitespacePositionOption = NotConsiderNonCollapsibleWhitespace);
 unsigned numEnclosingMailBlockquotes(const Position&);
-void updatePositionForNodeRemoval(Position&, Node*);
+void updatePositionForNodeRemoval(Position&, Node&);
 
 // -------------------------------------------------------------------------
 // VisiblePosition
@@ -169,16 +187,16 @@ void updatePositionForNodeRemoval(Position&, Node*);
 
 // Functions returning VisiblePosition
 
-VisiblePosition firstEditablePositionAfterPositionInRoot(const Position&, Node*);
-VisiblePosition lastEditablePositionBeforePositionInRoot(const Position&, Node*);
-VisiblePosition visiblePositionBeforeNode(Node*);
-VisiblePosition visiblePositionAfterNode(Node*);
+VisiblePosition firstEditableVisiblePositionAfterPositionInRoot(const Position&, ContainerNode*);
+VisiblePosition lastEditableVisiblePositionBeforePositionInRoot(const Position&, ContainerNode*);
+VisiblePosition visiblePositionBeforeNode(Node&);
+VisiblePosition visiblePositionAfterNode(Node&);
 
 bool lineBreakExistsAtVisiblePosition(const VisiblePosition&);
 
 int comparePositions(const VisiblePosition&, const VisiblePosition&);
 
-int indexForVisiblePosition(const VisiblePosition&, RefPtr<ContainerNode>& scope);
+int indexForVisiblePosition(const VisiblePosition&, RefPtrWillBeRawPtr<ContainerNode>& scope);
 VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope);
 
 // -------------------------------------------------------------------------
@@ -187,7 +205,7 @@ VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope);
 
 // Functions returning Range
 
-PassRefPtr<Range> createRange(Document&, const VisiblePosition& start, const VisiblePosition& end, ExceptionState&);
+PassRefPtrWillBeRawPtr<Range> createRange(Document&, const VisiblePosition& start, const VisiblePosition& end, ExceptionState&);
 
 // -------------------------------------------------------------------------
 // HTMLElement
@@ -195,16 +213,16 @@ PassRefPtr<Range> createRange(Document&, const VisiblePosition& start, const Vis
 
 // Functions returning HTMLElement
 
-PassRefPtr<HTMLElement> createDefaultParagraphElement(Document&);
-PassRefPtr<HTMLElement> createBreakElement(Document&);
-PassRefPtr<HTMLElement> createOrderedListElement(Document&);
-PassRefPtr<HTMLElement> createUnorderedListElement(Document&);
-PassRefPtr<HTMLElement> createListItemElement(Document&);
-PassRefPtr<HTMLElement> createHTMLElement(Document&, const QualifiedName&);
-PassRefPtr<HTMLElement> createHTMLElement(Document&, const AtomicString&);
+PassRefPtrWillBeRawPtr<HTMLElement> createDefaultParagraphElement(Document&);
+PassRefPtrWillBeRawPtr<HTMLBRElement> createBreakElement(Document&);
+PassRefPtrWillBeRawPtr<HTMLOListElement> createOrderedListElement(Document&);
+PassRefPtrWillBeRawPtr<HTMLUListElement> createUnorderedListElement(Document&);
+PassRefPtrWillBeRawPtr<HTMLLIElement> createListItemElement(Document&);
+PassRefPtrWillBeRawPtr<HTMLElement> createHTMLElement(Document&, const QualifiedName&);
+PassRefPtrWillBeRawPtr<HTMLElement> createHTMLElement(Document&, const AtomicString&);
 
 HTMLElement* enclosingList(Node*);
-HTMLElement* outermostEnclosingList(Node*, Node* rootList = 0);
+HTMLElement* outermostEnclosingList(Node*, HTMLElement* rootList = 0);
 Node* enclosingListChild(Node*);
 
 // -------------------------------------------------------------------------
@@ -213,10 +231,10 @@ Node* enclosingListChild(Node*);
 
 // Functions returning Element
 
-PassRefPtr<Element> createTabSpanElement(Document&);
-PassRefPtr<Element> createTabSpanElement(Document&, PassRefPtr<Node> tabTextNode);
-PassRefPtr<Element> createTabSpanElement(Document&, const String& tabText);
-PassRefPtr<Element> createBlockPlaceholderElement(Document&);
+PassRefPtrWillBeRawPtr<HTMLSpanElement> createTabSpanElement(Document&);
+PassRefPtrWillBeRawPtr<HTMLSpanElement> createTabSpanElement(Document&, PassRefPtrWillBeRawPtr<Text> tabTextNode);
+PassRefPtrWillBeRawPtr<HTMLSpanElement> createTabSpanElement(Document&, const String& tabText);
+PassRefPtrWillBeRawPtr<HTMLBRElement> createBlockPlaceholderElement(Document&);
 
 Element* editableRootForPosition(const Position&, EditableType = ContentIsEditable);
 Element* unsplittableElementForPosition(const Position&);
@@ -241,6 +259,12 @@ inline bool isWhitespace(UChar c)
     return c == noBreakSpace || c == ' ' || c == '\n' || c == '\t';
 }
 
+// FIXME: Can't really answer this question correctly without knowing the white-space mode.
+inline bool isCollapsibleWhitespace(UChar c)
+{
+    return c == ' ' || c == '\n';
+}
+
 inline bool isAmbiguousBoundaryCharacter(UChar character)
 {
     // These are characters that can behave as word boundaries, but can appear within words.