Changeset 113125 in webkit

Timestamp:

Apr 3, 2012 7:11:42 PM (12 years ago)

Author:

hayato@chromium.org

Message:

Make FocusController use a ComposedShadowTreeWalker, instead of ReifiedTreeTraversal APIs.
​https://bugs.webkit.org/show_bug.cgi?id=82694

Reviewed by Dimitri Glazkov.

Rewrite a focus controller so that it uses ComposedShadowTreeWalker
since that is a preferred way to traverse composed shadow tree.
I'll get rid of ReifiedTreeTraversal in follow-up patches, which is now deprecated.

No new tests. No change in functionality.

• page/FocusController.cpp:

(WebCore::walkerFrom):
(WebCore):
(WebCore::walkerFromNext):
(WebCore::walkerFromPrevious):
(WebCore::nextNode):
(WebCore::previousNode):
(WebCore::FocusController::findNodeWithExactTabIndex):
(WebCore::nextNodeWithGreaterTabIndex):
(WebCore::previousNodeWithLowerTabIndex):
(WebCore::FocusController::nextFocusableNode):
(WebCore::FocusController::previousFocusableNode):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• page/FocusController.cpp (modified) (10 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-04-03  Hayato Ito  <hayato@chromium.org>
+
+        Make FocusController use a ComposedShadowTreeWalker, instead of ReifiedTreeTraversal APIs.
+        https://bugs.webkit.org/show_bug.cgi?id=82694
+
+        Reviewed by Dimitri Glazkov.
+
+        Rewrite a focus controller so that it uses ComposedShadowTreeWalker
+        since that is a preferred way to traverse composed shadow tree.
+        I'll get rid of ReifiedTreeTraversal in follow-up patches, which is now deprecated.
+
+        No new tests. No change in functionality.
+
+        * page/FocusController.cpp:
+        (WebCore::walkerFrom):
+        (WebCore):
+        (WebCore::walkerFromNext):
+        (WebCore::walkerFromPrevious):
+        (WebCore::nextNode):
+        (WebCore::previousNode):
+        (WebCore::FocusController::findNodeWithExactTabIndex):
+        (WebCore::nextNodeWithGreaterTabIndex):
+        (WebCore::previousNodeWithLowerTabIndex):
+        (WebCore::FocusController::nextFocusableNode):
+        (WebCore::FocusController::previousFocusableNode):
+
 2012-04-03  Srikumar Bonda  <srikumar.b@gmail.com>
 

trunk/Source/WebCore/page/FocusController.cpp

@@ -30 +30 @@
 #include "AXObjectCache.h"
 #include "Chrome.h"
+#include "ComposedShadowTreeWalker.h"
 #include "Document.h"
 #include "Editor.h"
@@ -49 +50 @@
 #include "Page.h"
 #include "Range.h"
-#include "ReifiedTreeTraversal.h"
 #include "RenderLayer.h"
 #include "RenderObject.h"
@@ -70 +70 @@
 {
     return node && node->isElementNode() && toElement(node)->hasShadowRoot();
+}
+
+static inline ComposedShadowTreeWalker walkerFrom(const Node* node)
+{
+    return ComposedShadowTreeWalker(node, ComposedShadowTreeWalker::DoNotCrossUpperBoundary);
+}
+
+static inline ComposedShadowTreeWalker walkerFromNext(const Node* node)
+{
+    ComposedShadowTreeWalker walker = ComposedShadowTreeWalker(node, ComposedShadowTreeWalker::DoNotCrossUpperBoundary);
+    walker.next();
+    return walker;
+}
+
+static inline ComposedShadowTreeWalker walkerFromPrevious(const Node* node)
+{
+    ComposedShadowTreeWalker walker = ComposedShadowTreeWalker(node, ComposedShadowTreeWalker::DoNotCrossUpperBoundary);
+    walker.previous();
+    return walker;
+}
+
+static inline Node* nextNode(const Node* node)
+{
+    return walkerFromNext(node).get();
+}
+
+static inline Node* previousNode(const Node* node)
+{
+    return walkerFromPrevious(node).get();
 }
 
@@ -421 +450 @@
 {
     // Search is inclusive of start
-    for (Node* node = start; node; node = (direction == FocusDirectionForward ? ReifiedTreeTraversal::traverseNextNodeWithoutCrossingUpperBoundary(node): ReifiedTreeTraversal::traversePreviousNodeWithoutCrossingUpperBoundary(node))) {
-        if (shouldVisit(node, event) && adjustedTabIndex(node, event) == tabIndex)
-            return node;
+    for (ComposedShadowTreeWalker walker = walkerFrom(start); walker.get(); direction == FocusDirectionForward ? walker.next() : walker.previous()) {
+        if (shouldVisit(walker.get(), event) && adjustedTabIndex(walker.get(), event) == tabIndex)
+            return walker.get();
     }
     return 0;
@@ -433 +462 @@
     int winningTabIndex = std::numeric_limits<short>::max() + 1;
     Node* winner = 0;
-    for (Node* n = start; n; n = ReifiedTreeTraversal::traverseNextNodeWithoutCrossingUpperBoundary(n))
-        if (shouldVisit(n, event) && n->tabIndex() > tabIndex && n->tabIndex() < winningTabIndex) {
-            winner = n;
-            winningTabIndex = n->tabIndex();
-        }
+    for (ComposedShadowTreeWalker walker = walkerFrom(start); walker.get(); walker.next()) {
+        Node* node = walker.get();
+        if (shouldVisit(node, event) && node->tabIndex() > tabIndex && node->tabIndex() < winningTabIndex) {
+            winner = node;
+            winningTabIndex = node->tabIndex();
+        }
+    }
 
     return winner;
@@ -447 +478 @@
     int winningTabIndex = 0;
     Node* winner = 0;
-    for (Node* n = start; n; n = ReifiedTreeTraversal::traversePreviousNodeWithoutCrossingUpperBoundary(n)) {
-        int currentTabIndex = adjustedTabIndex(n, event);
-        if ((shouldVisit(n, event) || isNonFocusableShadowHost(n, event)) && currentTabIndex < tabIndex && currentTabIndex > winningTabIndex) {
-            winner = n;
+    for (ComposedShadowTreeWalker walker = walkerFrom(start); walker.get(); walker.previous()) {
+        Node* node = walker.get();
+        int currentTabIndex = adjustedTabIndex(node, event);
+        if ((shouldVisit(node, event) || isNonFocusableShadowHost(node, event)) && currentTabIndex < tabIndex && currentTabIndex > winningTabIndex) {
+            winner = node;
             winningTabIndex = currentTabIndex;
         }
@@ -463 +495 @@
         // If a node is excluded from the normal tabbing cycle, the next focusable node is determined by tree order
         if (tabIndex < 0) {
-            for (Node* n = ReifiedTreeTraversal::traverseNextNodeWithoutCrossingUpperBoundary(start); n; n = ReifiedTreeTraversal::traverseNextNodeWithoutCrossingUpperBoundary(n)) {
-                if (shouldVisit(n, event) && adjustedTabIndex(n, event) >= 0)
-                    return n;
+            for (ComposedShadowTreeWalker walker = walkerFromNext(start); walker.get(); walker.next()) {
+                if (shouldVisit(walker.get(), event) && adjustedTabIndex(walker.get(), event) >= 0)
+                    return walker.get();
             }
         }
 
         // First try to find a node with the same tabindex as start that comes after start in the scope.
-        if (Node* winner = findNodeWithExactTabIndex(ReifiedTreeTraversal::traverseNextNodeWithoutCrossingUpperBoundary(start), tabIndex, event, FocusDirectionForward))
+        if (Node* winner = findNodeWithExactTabIndex(nextNode(start), tabIndex, event, FocusDirectionForward))
             return winner;
 
@@ -491 +523 @@
 Node* FocusController::previousFocusableNode(FocusScope scope, Node* start, KeyboardEvent* event)
 {
-    Node* last;
-    for (last = scope.rootNode(); ReifiedTreeTraversal::lastChildWithoutCrossingUpperBoundary(last); last = ReifiedTreeTraversal::lastChildWithoutCrossingUpperBoundary(last)) { }
+    Node* last = 0;
+    for (ComposedShadowTreeWalker walker = walkerFrom(scope.rootNode()); walker.get(); walker.lastChild())
+        last = walker.get();
+    ASSERT(last);
 
     // First try to find the last node in the scope that comes before start and has the same tabindex as start.
@@ -499 +533 @@
     int startingTabIndex;
     if (start) {
-        startingNode = ReifiedTreeTraversal::traversePreviousNodeWithoutCrossingUpperBoundary(start);
+        startingNode = previousNode(start);
         startingTabIndex = adjustedTabIndex(start, event);
     } else {
@@ -508 +542 @@
     // However, if a node is excluded from the normal tabbing cycle, the previous focusable node is determined by tree order
     if (startingTabIndex < 0) {
-        for (Node* n = startingNode; n; n = ReifiedTreeTraversal::traversePreviousNodeWithoutCrossingUpperBoundary(n)) {
-            if (shouldVisit(n, event) && adjustedTabIndex(n, event) >= 0)
-                return n;
+        for (ComposedShadowTreeWalker walker = walkerFrom(startingNode); walker.get(); walker.previous()) {
+            if (shouldVisit(walker.get(), event) && adjustedTabIndex(walker.get(), event) >= 0)
+                return walker.get();
         }
     }