Changeset 150879 in webkit

Timestamp:

May 29, 2013 1:57:42 AM (11 years ago)

Author:

akling@apple.com

Message:

Move leaf Node traversal helpers to htmlediting.cpp
<​http://webkit.org/b/116940>

Reviewed by Antti Koivisto.

Move Node::previousLeafNode() and Node::nextLeafNode() to htmlediting.cpp along with their helpers.
Fixes an 8-year old FIXME. \o/

• dom/Node.h:
• dom/Node.cpp:
• dom/Position.cpp:

(WebCore::nextRenderedEditable):
(WebCore::previousRenderedEditable):

• editing/VisibleUnits.cpp:

(WebCore::previousLeafWithSameEditability):
(WebCore::nextLeafWithSameEditability):

• editing/htmlediting.h:
• editing/htmlediting.cpp:

(WebCore::previousNodeConsideringAtomicNodes):
(WebCore::nextNodeConsideringAtomicNodes):
(WebCore::previousLeafNode):
(WebCore::nextLeafNode):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• dom/Node.cpp (modified) (1 diff)
• dom/Node.h (modified) (1 diff)
• dom/Position.cpp (modified) (2 diffs)
• editing/VisibleUnits.cpp (modified) (2 diffs)
• editing/htmlediting.cpp (modified) (1 diff)
• editing/htmlediting.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-05-29  Andreas Kling  <akling@apple.com>
+
+        Move leaf Node traversal helpers to htmlediting.cpp
+        <http://webkit.org/b/116940>
+
+        Reviewed by Antti Koivisto.
+
+        Move Node::previousLeafNode() and Node::nextLeafNode() to htmlediting.cpp along with their helpers.
+        Fixes an 8-year old FIXME. \o/
+
+        * dom/Node.h:
+        * dom/Node.cpp:
+        * dom/Position.cpp:
+        (WebCore::nextRenderedEditable):
+        (WebCore::previousRenderedEditable):
+        * editing/VisibleUnits.cpp:
+        (WebCore::previousLeafWithSameEditability):
+        (WebCore::nextLeafWithSameEditability):
+        * editing/htmlediting.h:
+        * editing/htmlediting.cpp:
+        (WebCore::previousNodeConsideringAtomicNodes):
+        (WebCore::nextNodeConsideringAtomicNodes):
+        (WebCore::previousLeafNode):
+        (WebCore::nextLeafNode):
+
 2013-05-29  Peter Gal  <galpeter@inf.u-szeged.hu>
 

trunk/Source/WebCore/dom/Node.cpp

@@ -1091 +1091 @@
 }
 
-// FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
-Node *Node::previousNodeConsideringAtomicNodes() const
-{
-    if (previousSibling()) {
-        Node *n = previousSibling();
-        while (!isAtomicNode(n) && n->lastChild())
-            n = n->lastChild();
-        return n;
-    }
-    else if (parentNode()) {
-        return parentNode();
-    }
-    else {
-        return 0;
-    }
-}
-
-Node *Node::nextNodeConsideringAtomicNodes() const
-{
-    if (!isAtomicNode(this) && firstChild())
-        return firstChild();
-    if (nextSibling())
-        return nextSibling();
-    const Node *n = this;
-    while (n && !n->nextSibling())
-        n = n->parentNode();
-    if (n)
-        return n->nextSibling();
-    return 0;
-}
-
-Node *Node::previousLeafNode() const
-{
-    Node *node = previousNodeConsideringAtomicNodes();
-    while (node) {
-        if (isAtomicNode(node))
-            return node;
-        node = node->previousNodeConsideringAtomicNodes();
-    }
-    return 0;
-}
-
-Node *Node::nextLeafNode() const
-{
-    Node *node = nextNodeConsideringAtomicNodes();
-    while (node) {
-        if (isAtomicNode(node))
-            return node;
-        node = node->nextNodeConsideringAtomicNodes();
-    }
-    return 0;
-}
-
 ContainerNode* Node::parentNodeForRenderingAndStyle()
 {

trunk/Source/WebCore/dom/Node.h

@@ -310 +310 @@
     virtual bool canContainRangeEndPoint() const { return false; }
 
-    // FIXME: These two functions belong in editing -- "atomic node" is an editing concept.
-    Node* previousNodeConsideringAtomicNodes() const;
-    Node* nextNodeConsideringAtomicNodes() const;
-    
-    // Returns the next leaf node or 0 if there are no more.
-    // Delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
-    // Uses an editing-specific concept of what a leaf node is, and should probably be moved
-    // out of the Node class into an editing-specific source file.
-    Node* nextLeafNode() const;
-
-    // Returns the previous leaf node or 0 if there are no more.
-    // Delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
-    // Uses an editing-specific concept of what a leaf node is, and should probably be moved
-    // out of the Node class into an editing-specific source file.
-    Node* previousLeafNode() const;
-
     bool isRootEditableElement() const;
     Element* rootEditableElement() const;

trunk/Source/WebCore/dom/Position.cpp

@@ -52 +52 @@
 static Node* nextRenderedEditable(Node* node)
 {
-    while ((node = node->nextLeafNode())) {
+    while ((node = nextLeafNode(node))) {
         if (!node->rendererIsEditable())
             continue;
@@ -66 +66 @@
 static Node* previousRenderedEditable(Node* node)
 {
-    while ((node = node->previousLeafNode())) {
+    while ((node = previousLeafNode(node))) {
         if (!node->rendererIsEditable())
             continue;

trunk/Source/WebCore/editing/VisibleUnits.cpp

@@ -52 +52 @@
 {
     bool editable = node->rendererIsEditable(editableType);
-    node = node->previousLeafNode();
+    node = previousLeafNode(node);
     while (node) {
         if (editable == node->rendererIsEditable(editableType))
             return node;
-        node = node->previousLeafNode();
+        node = previousLeafNode(node);
     }
     return 0;
@@ -67 +67 @@
     
     bool editable = node->rendererIsEditable(editableType);
-    node = node->nextLeafNode();
+    node = nextLeafNode(node);
     while (node) {
         if (editable == node->rendererIsEditable(editableType))
             return node;
-        node = node->nextLeafNode();
+        node = nextLeafNode(node);
     }
     return 0;

trunk/Source/WebCore/editing/htmlediting.cpp

@@ -803 +803 @@
 }
 
+static Node* previousNodeConsideringAtomicNodes(const Node* node)
+{
+    if (node->previousSibling()) {
+        Node* n = node->previousSibling();
+        while (!isAtomicNode(n) && n->lastChild())
+            n = n->lastChild();
+        return n;
+    }
+    if (node->parentNode())
+        return node->parentNode();
+    return 0;
+}
+
+static Node* nextNodeConsideringAtomicNodes(const Node* node)
+{
+    if (!isAtomicNode(node) && node->firstChild())
+        return node->firstChild();
+    if (node->nextSibling())
+        return node->nextSibling();
+    const Node* n = node;
+    while (n && !n->nextSibling())
+        n = n->parentNode();
+    if (n)
+        return n->nextSibling();
+    return 0;
+}
+
+Node* previousLeafNode(const Node* node)
+{
+    Node* n = previousNodeConsideringAtomicNodes(node);
+    while (n) {
+        if (isAtomicNode(n))
+            return n;
+        n = previousNodeConsideringAtomicNodes(n);
+    }
+    return 0;
+}
+
+Node* nextLeafNode(const Node* node)
+{
+    Node* n = nextNodeConsideringAtomicNodes(node);
+    while (node) {
+        if (isAtomicNode(n))
+            return n;
+        n = nextNodeConsideringAtomicNodes(n);
+    }
+    return 0;
+}
+
 // FIXME: do not require renderer, so that this can be used within fragments, or rename to isRenderedTable()
 bool isTableElement(Node* n)

trunk/Source/WebCore/editing/htmlediting.h

@@ -74 +74 @@
 Node* isFirstPositionAfterTable(const VisiblePosition&);
 
+// These two deliver leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
+Node* nextLeafNode(const Node*);
+Node* previousLeafNode(const Node*);
+
 // offset functions on Node