Consider slots as a focus scope

third_party/WebKit/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 10 matching lines @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/page/FocusController.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/AXObjectCache.h"
+#include "core/dom/AssignedNodeTraversal.h"
+#include "core/dom/CombinedNodeTraversal.h"
+#include "core/dom/ContainerNode.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
-#include "core/dom/NodeTraversal.h"
 #include "core/dom/Range.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/EditingUtilities.h" // For firstPositionInOrBeforeNode
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameClient.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/RemoteFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLAreaElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/html/HTMLShadowElement.h"
+#include "core/html/HTMLSlotElement.h"
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/input/EventHandler.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/layout/HitTestResult.h"
 #include "core/page/SpatialNavigation.h"
 #include <limits>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
 inline bool isShadowInsertionPointFocusScopeOwner(Element& element)
 {
     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 ownedByHTMLSlotElement(HTMLSlotElement&);
     static FocusNavigationScope ownedByIFrame(const HTMLFrameOwnerElement&);
 
 private:
     explicit FocusNavigationScope(TreeScope*);
+    explicit FocusNavigationScope(HTMLSlotElement*);
     RawPtrWillBeMember<TreeScope> m_rootTreeScope;
+    RawPtrWillBeMember<HTMLSlotElement> m_rootSlot;
 };
 
 FocusNavigationScope::FocusNavigationScope(TreeScope* treeScope)
     : m_rootTreeScope(treeScope)
 {
     ASSERT(treeScope);
 }
 
+FocusNavigationScope::FocusNavigationScope(HTMLSlotElement* slot)
+    : m_rootSlot(slot)
+{
+    ASSERT(slot);
+}
+
 Node* FocusNavigationScope::rootNode() const
 {
+    if (m_rootSlot)
+        return m_rootSlot;
     return &m_rootTreeScope->rootNode();
 }
 
 Element* FocusNavigationScope::owner() const
 {
+    if (m_rootSlot)
+        return m_rootSlot;
     Node* root = rootNode();
     if (root->isShadowRoot()) {
         ShadowRoot* shadowRoot = toShadowRoot(root);
         return shadowRoot->isYoungest() ? shadowRoot->host() : shadowRoot->shadowInsertionPointOfYoungerShadowRoot();
     }
     // FIXME: Figure out the right thing for OOPI here.
     if (Frame* frame = root->document().frame())
         return frame->deprecatedLocalOwner();
     return nullptr;
 }
 
 FocusNavigationScope FocusNavigationScope::focusNavigationScopeOf(const Node& node)
 {
+    if (AssignedNodeTraversal::isInAssignedScope(node))
+        return FocusNavigationScope(AssignedNodeTraversal::slot(node));
     return FocusNavigationScope(&node.treeScope());
 }
 
 FocusNavigationScope FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(Element& element)
 {
     if (isShadowHost(element))
         return FocusNavigationScope::ownedByShadowHost(element);
-    ASSERT(isShadowInsertionPointFocusScopeOwner(element));
-    return FocusNavigationScope::ownedByShadowInsertionPoint(toHTMLShadowElement(element));
+    if (isShadowInsertionPointFocusScopeOwner(element))
+        return FocusNavigationScope::ownedByShadowInsertionPoint(toHTMLShadowElement(element));
+    ASSERT(isHTMLSlotElement(element));
+        return FocusNavigationScope::ownedByHTMLSlotElement(toHTMLSlotElement(element));
 }
 
 FocusNavigationScope FocusNavigationScope::ownedByShadowHost(const Element& element)
 {
     ASSERT(isShadowHost(element));
     return FocusNavigationScope(&element.shadow()->youngestShadowRoot());
 }
 
 FocusNavigationScope FocusNavigationScope::ownedByIFrame(const HTMLFrameOwnerElement& frame)
 {
     ASSERT(frame.contentFrame());
     ASSERT(frame.contentFrame()->isLocalFrame());
     return FocusNavigationScope(toLocalFrame(frame.contentFrame())->document());
 }
 
 FocusNavigationScope FocusNavigationScope::ownedByShadowInsertionPoint(HTMLShadowElement& shadowInsertionPoint)
 {
     ASSERT(isShadowInsertionPointFocusScopeOwner(shadowInsertionPoint));
     return FocusNavigationScope(shadowInsertionPoint.olderShadowRoot());
 }
 
+FocusNavigationScope FocusNavigationScope::ownedByHTMLSlotElement(HTMLSlotElement& element)
+{
+    return FocusNavigationScope(&element);
+}
+
 inline void dispatchBlurEvent(const Document& document, Element& focusedElement)
 {
     focusedElement.dispatchBlurEvent(nullptr, WebFocusTypePage);
     if (focusedElement == document.focusedElement()) {
         focusedElement.dispatchFocusOutEvent(EventTypeNames::focusout, nullptr);
         if (focusedElement == document.focusedElement())
             focusedElement.dispatchFocusOutEvent(EventTypeNames::DOMFocusOut, nullptr);
     }
 }
 
@@ skipping 63 matching lines @@
     return isShadowHostWithoutCustomFocusLogic(element) && !element.isKeyboardFocusable();
 }
 
 inline bool isKeyboardFocusableShadowHost(const Element& element)
 {
     return isShadowHostWithoutCustomFocusLogic(element) && element.isKeyboardFocusable();
 }
 
 inline bool isNonFocusableFocusScopeOwner(Element& element)
 {
-    return isNonKeyboardFocusableShadowHost(element) || isShadowInsertionPointFocusScopeOwner(element);
+    return isNonKeyboardFocusableShadowHost(element) || isShadowInsertionPointFocusScopeOwner(element) || isHTMLSlotElement(element);
 }
 
 inline bool isShadowHostDelegatesFocus(const Element& element)
 {
     return element.authorShadowRoot() && element.authorShadowRoot()->delegatesFocus();
 }
 
 inline int adjustedTabIndex(Node& node)
 {
     return node.isElementNode() && isNonFocusableFocusScopeOwner(toElement(node)) ? 0 : node.tabIndex();
 }
 
 inline bool shouldVisit(Node& 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 ? ElementTraversal::next(*node) : ElementTraversal::previous(*node)) {
+    if (!start)
+        return nullptr;
+    CombinedNodeTraversal* traversal = new CombinedNodeTraversal(*start);
+    for (Node* node = start; node; node = type == WebFocusTypeForward ? traversal->next() : traversal->previous()) {
         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;
+    if (!start)
+        return nullptr;
+
+    CombinedNodeTraversal* traversal = new CombinedNodeTraversal(*start);
+    for (Node* node = start; node; node = traversal->next()) {
+        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 = ElementTraversal::previous(*node)) {
+    CombinedNodeTraversal* traversal = new CombinedNodeTraversal(*start);
+    for (Node* node = start; node; node = traversal->previous()) {
         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);
+            CombinedNodeTraversal* traversal = new CombinedNodeTraversal(*start);
+            for (Node* node = traversal->next(); node; node = traversal->next()) {
+                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(ElementTraversal::next(*start), tabIndex, WebFocusTypeForward))
+            CombinedNodeTraversal* traversal = new CombinedNodeTraversal(*start);
+            if (Element* winner = findElementWithExactTabIndex(traversal->next(), 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
     // 2) comes first in the scope, if there's a tie.
-    if (Element* winner = nextElementWithGreaterTabIndex(scope.rootNode(), start ? adjustedTabIndex(*start) : 0))
+    if (isHTMLSlotElement(scope.rootNode())) {
+        if (Element* winner = nextElementWithGreaterTabIndex(toHTMLSlotElement(scope.rootNode())->getAssignedNodes()[0].get(), start ? adjustedTabIndex(*start) : 0))
+            return winner;
+        return findElementWithExactTabIndex(toHTMLSlotElement(scope.rootNode())->getAssignedNodes()[0].get(), 0, WebFocusTypeForward);
+    }
+
+    if (Element* winner = nextElementWithGreaterTabIndex(scope.rootNode(), start ? adjustedTabIndex(*start) : 0)) {
         return winner;
-
+    }
     // There are no nodes with a tabindex greater than start's tabindex,
     // so find the first node with a tabindex of 0.
     return findElementWithExactTabIndex(scope.rootNode(), 0, WebFocusTypeForward);
 }
 
 Element* previousFocusableElement(const FocusNavigationScope& scope, Node* start)
 {
     Node* last = nullptr;
-    for (Node* node = scope.rootNode(); node; node = node->lastChild())
-        last = node;
+    if (isHTMLSlotElement(scope.rootNode()) && !toHTMLSlotElement(scope.rootNode())->getAssignedNodes().isEmpty()) {
+        last = toHTMLSlotElement(scope.rootNode())->getAssignedNodes().last().get();
+    } else {
+        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 = ElementTraversal::previous(*start);
+        CombinedNodeTraversal* traversal = new CombinedNodeTraversal(*start);
+        startingNode = traversal->previous();
         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 = ElementTraversal::previous(*node)) {
+        CombinedNodeTraversal* traversal = new CombinedNodeTraversal(*startingNode);
+        for (Node* node = startingNode; node; node = traversal->previous()) {
             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 33 matching lines @@
                 if (Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr))
                     return foundInInnerFocusScope;
             }
             // Skip to the next node in the same scope.
             found = findFocusableElementInternal(WebFocusTypeForward, scope, found);
             continue;
         }
         if (!isNonFocusableFocusScopeOwner(*found))
             return found;
 
-        // Now |found| is on a non focusable scope owner (either shadow host or <shadow>)
+        // Now |found| is on a non focusable scope owner (either shadow host or <shadow> or slot)
         // Find inside the inward scope and return it if found. Otherwise continue searching in the same
         // scope.
         FocusNavigationScope innerScope = FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(*found);
         if (Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr))
             return foundInInnerFocusScope;
 
         found = findFocusableElementInternal(WebFocusTypeForward, scope, found);
     }
     return nullptr;
 }
 
 Element* findFocusableElementRecursivelyBackward(const FocusNavigationScope& scope, Node* start)
 {
     // Starting node is exclusive.
     Element* found = findFocusableElementInternal(WebFocusTypeBackward, scope, start);
+
     while (found) {
         // 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);
             Element* foundInInnerFocusScope = findFocusableElementRecursivelyBackward(innerScope, nullptr);
             if (foundInInnerFocusScope)
                 return foundInInnerFocusScope;
             if (isShadowHostDelegatesFocus(*found)) {
                 found = findFocusableElementInternal(WebFocusTypeBackward, scope, found);
                 continue;
             }
             return found;
         }
 
         // If delegatesFocus is true and tabindex is negative, skip the whole shadow tree under the
         // shadow host.
         if (isShadowHostDelegatesFocus(*found) && found->tabIndex() < 0) {
             found = findFocusableElementInternal(WebFocusTypeBackward, scope, found);
             continue;
         }
 
-        // Now |found| is on a non focusable scope owner (either shadow host or <shadow>).
+        // Now |found| is on a non focusable scope owner (either shadow host or <shadow> or slot).
         // Find focusable node in descendant scope. If not found, find next focusable node within the
         // current scope.
         if (isNonFocusableFocusScopeOwner(*found)) {
             FocusNavigationScope innerScope = FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(*found);
             Element* foundInInnerFocusScope = findFocusableElementRecursivelyBackward(innerScope, nullptr);
             if (foundInInnerFocusScope)
                 return foundInInnerFocusScope;
             found = findFocusableElementInternal(WebFocusTypeBackward, scope, found);
             continue;
         }
@@ skipping 670 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink