Remaining Node to Element conversion in FocusController

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 45 matching lines @@
 #include "core/layout/HitTestResult.h"
 #include "core/page/SpatialNavigation.h"
 #include <limits>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
-inline bool isShadowInsertionPointFocusScopeOwner(Node& node)
+inline bool isShadowInsertionPointFocusScopeOwner(Element& element)
 {
-    return isActiveShadowInsertionPoint(node) && toHTMLShadowElement(node).olderShadowRoot();
+    return isActiveShadowInsertionPoint(element) && toHTMLShadowElement(element).olderShadowRoot();
 }
 
 class FocusNavigationScope {
     STACK_ALLOCATED();
 public:
     Node* rootNode() const;
     Element* owner() const;
     static FocusNavigationScope focusNavigationScopeOf(const Node&);
     static FocusNavigationScope ownedByNonFocusableFocusScopeOwner(Element&);
     static FocusNavigationScope ownedByShadowHost(const Element&);
     static FocusNavigationScope ownedByShadowInsertionPoint(HTMLShadowElement&);
     static FocusNavigationScope ownedByIFrame(const HTMLFrameOwnerElement&);
 
 private:
     explicit FocusNavigationScope(TreeScope*);
     RawPtrWillBeMember<TreeScope> m_rootTreeScope;
 };
 
-// FIXME: Some of Node* return values and Node* arguments should be Element*.
-
 FocusNavigationScope::FocusNavigationScope(TreeScope* treeScope)
     : m_rootTreeScope(treeScope)
 {
     ASSERT(treeScope);
 }
 
 Node* FocusNavigationScope::rootNode() const
 {
     return &m_rootTreeScope->rootNode();
 }
@@ skipping 97 matching lines @@
         focusedElement->setFocus(true);
         dispatchFocusEvent(*document, *focusedElement);
     }
 }
 
 inline bool hasCustomFocusLogic(const Element& element)
 {
     return element.isHTMLElement() && toHTMLElement(element).hasCustomFocusLogic();
 }
 
-inline bool isShadowHostWithoutCustomFocusLogic(const Node& node)
+inline bool isShadowHostWithoutCustomFocusLogic(const Element& element)
 {
-    if (!node.isElementNode())
-        return false;
-    const Element& element = toElement(node);
     return isShadowHost(element) && !hasCustomFocusLogic(element);
 }
 
 #if ENABLE(ASSERT)
 inline bool isNonFocusableShadowHost(const Node& node)
 {
-    return isShadowHostWithoutCustomFocusLogic(node) && !toElement(node).isFocusable();
+    if (!node.isElementNode())
+        return false;
+    const Element& element = toElement(node);
+    return isShadowHostWithoutCustomFocusLogic(element) && !element.isFocusable();
 }
 #endif
 
-inline bool isNonKeyboardFocusableShadowHost(const Node& node)
+inline bool isNonKeyboardFocusableShadowHost(const Element& element)
 {
-    return isShadowHostWithoutCustomFocusLogic(node) && !toElement(node).isKeyboardFocusable();
+    return isShadowHostWithoutCustomFocusLogic(element) && !element.isKeyboardFocusable();
 }
 
-inline bool isKeyboardFocusableShadowHost(const Node& node)
+inline bool isKeyboardFocusableShadowHost(const Element& element)
 {
-    return isShadowHostWithoutCustomFocusLogic(node) && toElement(node).isKeyboardFocusable();
+    return isShadowHostWithoutCustomFocusLogic(element) && element.isKeyboardFocusable();
 }
 
-inline bool isNonFocusableFocusScopeOwner(Node& node)
+inline bool isNonFocusableFocusScopeOwner(Element& element)
 {
-    return isNonKeyboardFocusableShadowHost(node) || isShadowInsertionPointFocusScopeOwner(node);
+    return isNonKeyboardFocusableShadowHost(element) || isShadowInsertionPointFocusScopeOwner(element);
 }
 
-inline bool isShadowHostDelegatesFocus(const Node& node)
+inline bool isShadowHostDelegatesFocus(const Element& element)
 {
-    return node.isElementNode() && toElement(node).shadowRoot() && toElement(node).shadowRoot()->delegatesFocus();
+    return element.shadowRoot() && element.shadowRoot()->delegatesFocus();
 }
 
 inline int adjustedTabIndex(Node& node)
 {
-    return isNonFocusableFocusScopeOwner(node) ? 0 : node.tabIndex();
+    return node.isElementNode() && isNonFocusableFocusScopeOwner(toElement(node)) ? 0 : node.tabIndex();
 }
 
 inline bool shouldVisit(Node& node)
 {
-    return (node.isElementNode() && toElement(node).isKeyboardFocusable()) || isNonFocusableFocusScopeOwner(node);
+    if (!node.isElementNode())
+        return false;
+    Element& element = toElement(node);
+    return element.isKeyboardFocusable() || isNonFocusableFocusScopeOwner(element);
 }
 
 Element* findElementWithExactTabIndex(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)) {
+    for (Node* node = start; node; node = type == WebFocusTypeForward ? ElementTraversal::next(*node) : ElementTraversal::previous(*node)) {
         if (shouldVisit(*node) && adjustedTabIndex(*node) == tabIndex)
             return toElement(node);
     }
     return nullptr;
 }
 
 Element* nextElementWithGreaterTabIndex(Node* start, int tabIndex)
 {
     // Search is inclusive of start
     int winningTabIndex = std::numeric_limits<short>::max() + 1;
     Node* winner = nullptr;
     for (Node& node : NodeTraversal::startsAt(start)) {
         int currentTabIndex = adjustedTabIndex(node);
         if (shouldVisit(node) && currentTabIndex > tabIndex && currentTabIndex < winningTabIndex) {
             winner = &node;
             winningTabIndex = currentTabIndex;
         }
     }
     ASSERT(!winner || winner->isElementNode());
     return toElement(winner);
 }
 
 Element* previousElementWithLowerTabIndex(Node* start, int tabIndex)
 {
     // Search is inclusive of start
     int winningTabIndex = 0;
     Node* winner = nullptr;
-    for (Node* node = start; node; node = NodeTraversal::previous(*node)) {
+    for (Node* node = start; node; node = ElementTraversal::previous(*node)) {
         int currentTabIndex = adjustedTabIndex(*node);
         if (shouldVisit(*node) && currentTabIndex < tabIndex && currentTabIndex > winningTabIndex) {
             winner = node;
             winningTabIndex = currentTabIndex;
         }
     }
     ASSERT(!winner || winner->isElementNode());
     return toElement(winner);
 }
 
 Element* nextFocusableElement(const FocusNavigationScope& scope, Node* start)
 {
     if (start) {
         int tabIndex = adjustedTabIndex(*start);
         // If a node is excluded from the normal tabbing cycle, the next focusable node is determined by tree order
         if (tabIndex < 0) {
             for (Node& node : NodeTraversal::startsAfter(*start)) {
                 if (shouldVisit(node) && adjustedTabIndex(node) >= 0)
                     return &toElement(node);
             }
         } else {
             // First try to find a node with the same tabindex as start that comes after start in the scope.
-            if (Element* winner = findElementWithExactTabIndex(NodeTraversal::next(*start), tabIndex, WebFocusTypeForward))
+            if (Element* winner = findElementWithExactTabIndex(ElementTraversal::next(*start), tabIndex, WebFocusTypeForward))
                 return winner;
         }
         if (!tabIndex) {
             // We've reached the last node in the document with a tabindex of 0. This is the end of the tabbing order.
             return nullptr;
         }
     }
 
     // Look for the first node in the scope that:
     // 1) has the lowest tabindex that is higher than start's tabindex (or 0, if start is null), and
@@ skipping 11 matching lines @@
     Node* last = nullptr;
     for (Node* node = scope.rootNode(); node; node = node->lastChild())
         last = node;
     ASSERT(last);
 
     // First try to find the last node in the scope that comes before start and has the same tabindex as start.
     // If start is null, find the last node in the scope with a tabindex of 0.
     Node* startingNode;
     int startingTabIndex;
     if (start) {
-        startingNode = NodeTraversal::previous(*start);
+        startingNode = ElementTraversal::previous(*start);
         startingTabIndex = adjustedTabIndex(*start);
     } else {
         startingNode = last;
         startingTabIndex = 0;
     }
 
     // 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* node = startingNode; node; node = NodeTraversal::previous(*node)) {
+        for (Node* node = startingNode; node; node = ElementTraversal::previous(*node)) {
             if (shouldVisit(*node) && adjustedTabIndex(*node) >= 0)
                 return toElement(node);
         }
     } else {
         if (Element* winner = findElementWithExactTabIndex(startingNode, startingTabIndex, WebFocusTypeBackward))
             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
@@ skipping 109 matching lines @@
         ASSERT(element != foundElement);
         element = foundElement;
     }
     return element;
 }
 
 Element* findFocusableElementAcrossFocusScopesForward(const FocusNavigationScope& scope, Node* currentNode)
 {
     ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
     Element* found;
-    if (currentNode && isShadowHostWithoutCustomFocusLogic(*currentNode)) {
+    if (currentNode && currentNode->isElementNode() && isShadowHostWithoutCustomFocusLogic(*toElement(currentNode))) {
         FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*toElement(currentNode));
         Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
         found = foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, currentNode);
     } else {
         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) {
@@ skipping 549 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink