Change API name and return type of findFocusableNode

Source/core/page/FocusController.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nuanti Ltd.
  *
  * 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
@@ skipping 342 matching lines @@
 Node* FocusController::findFocusableNodeDecendingDownIntoFrameDocument(WebFocusType type, Node* node)
 {
     // The node we found might be a HTMLFrameOwnerElement, so descend down the tree until we find either:
     // 1) a focusable node, or
     // 2) the deepest-nested HTMLFrameOwnerElement.
     while (node && node->isFrameOwnerElement()) {
         HTMLFrameOwnerElement& owner = toHTMLFrameOwnerElement(*node);
         if (!owner.contentFrame() || !owner.contentFrame()->isLocalFrame())
             break;
         toLocalFrame(owner.contentFrame())->document()->updateLayoutIgnorePendingStylesheets();
-        Node* foundNode = findFocusableNode(type, FocusNavigationScope::ownedByIFrame(owner), nullptr);
-        if (!foundNode)
+        Element* foundElement = findFocusableElement(type, FocusNavigationScope::ownedByIFrame(owner), nullptr);
+        if (!foundElement)
             break;
-        ASSERT(node != foundNode);
-        node = foundNode;
+        ASSERT(node != foundElement);
+        node = foundElement;
     }
     return node;
 }
 
 bool FocusController::setInitialFocus(WebFocusType type)
 {
     bool didAdvanceFocus = advanceFocus(type, true);
 
     // If focus is being set initially, accessibility needs to be informed that system focus has moved
     // into the web area again, even if focus did not change within WebCore. PostNotification is called instead
@@ skipping 51 matching lines @@
         if (!initialFocus && m_page->chromeClient().canTakeFocus(type)) {
             document->setFocusedElement(nullptr);
             setFocusedFrame(nullptr);
             m_page->chromeClient().takeFocus(type);
             return true;
         }
 
         // Chrome doesn't want focus, so we should wrap focus.
         if (!m_page->mainFrame()->isLocalFrame())
             return false;
-        node = findFocusableNodeRecursively(type, FocusNavigationScope::focusNavigationScopeOf(*m_page->deprecatedLocalMainFrame()->document()), nullptr);
+        node = findFocusableElementRecursively(type, FocusNavigationScope::focusNavigationScopeOf(*m_page->deprecatedLocalMainFrame()->document()), nullptr);
         node = findFocusableNodeDecendingDownIntoFrameDocument(type, node.get());
 
         if (!node)
             return false;
     }
 
     ASSERT(node);
 
     if (node == document->focusedElement())
         // Focus wrapped around to the same node.
@@ skipping 44 matching lines @@
         findFocusableNodeAcrossFocusScopesForward(scope, currentNode) :
         findFocusableNodeAcrossFocusScopesBackward(scope, currentNode);
 }
 
 Node* FocusController::findFocusableNodeAcrossFocusScopesForward(const FocusNavigationScope& scope, Node* currentNode)
 {
     ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
     Node* found;
     if (currentNode && isShadowHostWithoutCustomFocusLogic(*currentNode)) {
         FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*currentNode);
-        Node* foundInInnerFocusScope = findFocusableNodeRecursivelyForward(innerScope, nullptr);
-        found = foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableNodeRecursivelyForward(scope, currentNode);
+        Node* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
+        found = foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, currentNode);
     } else {
-        found = findFocusableNodeRecursivelyForward(scope, currentNode);
+        found = findFocusableElementRecursivelyForward(scope, currentNode);
     }
 
     // If there's no focusable node to advance to, move up the focus scopes until we find one.
     FocusNavigationScope currentScope = scope;
     while (!found) {
         Node* owner = currentScope.owner();
         if (!owner)
             break;
         currentScope = FocusNavigationScope::focusNavigationScopeOf(*owner);
-        found = findFocusableNodeRecursivelyForward(currentScope, owner);
+        found = findFocusableElementRecursivelyForward(currentScope, owner);
     }
     return findFocusableNodeDecendingDownIntoFrameDocument(WebFocusTypeForward, found);
 }
 
 Node* FocusController::findFocusableNodeAcrossFocusScopesBackward(const FocusNavigationScope& scope, Node* currentNode)
 {
     ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
-    Node* found = findFocusableNodeRecursivelyBackward(scope, currentNode);
+    Node* found = findFocusableElementRecursivelyBackward(scope, currentNode);
 
     // If there's no focusable node to advance to, move up the focus scopes until we find one.
     FocusNavigationScope currentScope = scope;
     while (!found) {
         Node* owner = currentScope.owner();
         if (!owner)
             break;
         currentScope = FocusNavigationScope::focusNavigationScopeOf(*owner);
         if (isKeyboardFocusableShadowHost(*owner) && !isShadowHostDelegatesFocus(*owner)) {
             found = owner;
             break;
         }
-        found = findFocusableNodeRecursivelyBackward(currentScope, owner);
+        found = findFocusableElementRecursivelyBackward(currentScope, owner);
     }
     return findFocusableNodeDecendingDownIntoFrameDocument(WebFocusTypeBackward, found);
 }
 
-Node* FocusController::findFocusableNodeRecursively(WebFocusType type, const FocusNavigationScope& scope, Node* start)
+Element* FocusController::findFocusableElementRecursively(WebFocusType type, const FocusNavigationScope& scope, Node* start)
 {
     return (type == WebFocusTypeForward) ?
-        findFocusableNodeRecursivelyForward(scope, start) :
-        findFocusableNodeRecursivelyBackward(scope, start);
+        findFocusableElementRecursivelyForward(scope, start) :
+        findFocusableElementRecursivelyBackward(scope, start);
 }
 
-Node* FocusController::findFocusableNodeRecursivelyForward(const FocusNavigationScope& scope, Node* start)
+Element* FocusController::findFocusableElementRecursivelyForward(const FocusNavigationScope& scope, Node* start)
 {
     // Starting node is exclusive.
-    Node* found = findFocusableNode(WebFocusTypeForward, scope, start);
+    Element* found = findFocusableElement(WebFocusTypeForward, scope, start);
     if (!found)
         return nullptr;
     if (isShadowHostDelegatesFocus(*found)) {
         if (isShadowHostWithoutCustomFocusLogic(*found)) {
             FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*found);
-            Node* foundInInnerFocusScope = findFocusableNodeRecursivelyForward(innerScope, nullptr);
-            return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableNodeRecursivelyForward(scope, found);
+            Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
+            return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, found);
         }
         // Skip to the next node.
         if (!isNonFocusableFocusScopeOwner(*found))
-            found = findFocusableNodeRecursivelyForward(scope, found);
+            found = findFocusableElementRecursivelyForward(scope, found);
     }
     if (!found || !isNonFocusableFocusScopeOwner(*found))
         return found;
 
     // Now |found| is on a focusable scope owner (either shadow host or <shadow>)
     // Find inside the inward scope and return it if found. Otherwise continue searching in the same
     // scope.
     FocusNavigationScope innerScope = FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(*found);
-    Node* foundInInnerFocusScope = findFocusableNodeRecursivelyForward(innerScope, nullptr);
-    return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableNodeRecursivelyForward(scope, found);
+    Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
+    return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, found);
 }
 
-Node* FocusController::findFocusableNodeRecursivelyBackward(const FocusNavigationScope& scope, Node* start)
+Element* FocusController::findFocusableElementRecursivelyBackward(const FocusNavigationScope& scope, Node* start)
 {
     // Starting node is exclusive.
-    Node* found = findFocusableNode(WebFocusTypeBackward, scope, start);
+    Element* found = findFocusableElement(WebFocusTypeBackward, scope, start);
     if (!found)
         return nullptr;
 
     // Now |found| is on a focusable shadow host.
     // Find inside shadow backwards. If any focusable element is found, return it, otherwise return
     // the host itself.
     if (isKeyboardFocusableShadowHost(*found)) {
         FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*found);
-        Node* foundInInnerFocusScope = findFocusableNodeRecursivelyBackward(innerScope, nullptr);
+        Element* foundInInnerFocusScope = findFocusableElementRecursivelyBackward(innerScope, nullptr);
         if (foundInInnerFocusScope)
             return foundInInnerFocusScope;
         if (isShadowHostDelegatesFocus(*found))
-            found = findFocusableNodeRecursivelyBackward(scope, found);
+            found = findFocusableElementRecursivelyBackward(scope, found);
         return found;
     }
 
     // Now |found| is on a non focusable scope owner (either shadow host or <shadow>).
     // Find focusable node in decendant scope. If not found, find next focusable node within the
     // current scope.
     if (isNonFocusableFocusScopeOwner(*found)) {
         FocusNavigationScope innerScope = FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(*found);
-        Node* foundInInnerFocusScope = findFocusableNodeRecursivelyBackward(innerScope, nullptr);
-        return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableNodeRecursivelyBackward(scope, found);
+        Element* foundInInnerFocusScope = findFocusableElementRecursivelyBackward(innerScope, nullptr);
+        return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyBackward(scope, found);
     }
 
-    return found->isElementNode() && !isShadowHostDelegatesFocus(*found) ? found : findFocusableNodeRecursivelyBackward(scope, found);
+    return !isShadowHostDelegatesFocus(*found) ? found : findFocusableElementRecursivelyBackward(scope, found);
 }
 
 static Node* findNodeWithExactTabIndex(Node* start, int tabIndex, WebFocusType type)
 {
     // Search is inclusive of start
     for (Node* node = start; node; node = type == WebFocusTypeForward ? NodeTraversal::next(*node) : NodeTraversal::previous(*node)) {
         if (shouldVisit(*node) && adjustedTabIndex(*node) == tabIndex)
             return node;
     }
     return nullptr;
@@ skipping 92 matching lines @@
             return winner;
     }
 
     // There are no nodes before start with the same tabindex as start, so look for a node that:
     // 1) has the highest non-zero tabindex (that is less than start's tabindex), and
     // 2) comes last in the scope, if there's a tie.
     startingTabIndex = (start && startingTabIndex) ? startingTabIndex : std::numeric_limits<short>::max();
     return previousNodeWithLowerTabIndex(last, startingTabIndex);
 }
 
-Node* FocusController::findFocusableNode(WebFocusType type, Node& node)
+Element* FocusController::findFocusableElement(WebFocusType type, Node& node)
 {
     // FIXME: No spacial navigation code yet.
     ASSERT(type == WebFocusTypeForward || type == WebFocusTypeBackward);
-    return findFocusableNodeAcrossFocusScopes(type, FocusNavigationScope::focusNavigationScopeOf(node), &node);
+    Node* found = findFocusableNodeAcrossFocusScopes(type, FocusNavigationScope::focusNavigationScopeOf(node), &node);
+    ASSERT(!found || found->isElementNode());
+    return toElement(found);
 }
 
-Node* FocusController::findFocusableNode(WebFocusType type, const FocusNavigationScope& scope, Node* node)
+Element* FocusController::findFocusableElement(WebFocusType type, const FocusNavigationScope& scope, Node* node)
 {
-    return type == WebFocusTypeForward ? nextFocusableNode(scope, node) : previousFocusableNode(scope, node);
+    Node* found = (type == WebFocusTypeForward) ? nextFocusableNode(scope, node) : previousFocusableNode(scope, node);
+    ASSERT(!found || found->isElementNode());
+    return toElement(found);
 }
 
 static bool relinquishesEditingFocus(const Element& element)
 {
     ASSERT(element.hasEditableStyle());
     return element.document().frame() && element.rootEditableElement();
 }
 
 static void clearSelectionIfNeeded(LocalFrame* oldFocusedFrame, LocalFrame* newFocusedFrame, Node* newFocusedNode)
 {
@@ skipping 276 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink