Implement ShadowRoot.delegatesFocus 1/4 (focus navigation)

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 213 matching lines @@
 static inline bool isKeyboardFocusableShadowHost(const Node& node)
 {
     return isShadowHostWithoutCustomFocusLogic(node) && toElement(node).isKeyboardFocusable();
 }
 
 static inline bool isNonFocusableFocusScopeOwner(Node& node)
 {
     return isNonKeyboardFocusableShadowHost(node) || isShadowInsertionPointFocusScopeOwner(node);
 }
 
+static inline bool isShadowHostDelegatesFocus(const Node& node)
+{
+    return node.isElementNode() && toElement(node).shadowRoot() && toElement(node).shadowRoot()->delegatesFocus();
+}
+
 static inline int adjustedTabIndex(Node& node)
 {
     return isNonFocusableFocusScopeOwner(node) ? 0 : node.tabIndex();
 }
 
 static inline bool shouldVisit(Node& node)
 {
     return (node.isElementNode() && toElement(node).isKeyboardFocusable()) || isNonFocusableFocusScopeOwner(node);
 }
 
@@ skipping 275 matching lines @@
     ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
     Node* found = findFocusableNodeRecursivelyBackward(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)) {
+        if (isKeyboardFocusableShadowHost(*owner) && !isShadowHostDelegatesFocus(*owner)) {
             found = owner;
             break;
         }
         found = findFocusableNodeRecursivelyBackward(currentScope, owner);
     }
     return findFocusableNodeDecendingDownIntoFrameDocument(WebFocusTypeBackward, found);
 }
 
 Node* FocusController::findFocusableNodeRecursively(WebFocusType type, const FocusNavigationScope& scope, Node* start)
 {
     return (type == WebFocusTypeForward) ?
         findFocusableNodeRecursivelyForward(scope, start) :
         findFocusableNodeRecursivelyBackward(scope, start);
 }
 
 Node* FocusController::findFocusableNodeRecursivelyForward(const FocusNavigationScope& scope, Node* start)
 {
     // Starting node is exclusive.
     Node* found = findFocusableNode(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);
+        }
+        // Skip to the next node.
+        if (!isNonFocusableFocusScopeOwner(*found))
+            found = findFocusableNodeRecursivelyForward(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);
 }
 
 Node* FocusController::findFocusableNodeRecursivelyBackward(const FocusNavigationScope& scope, Node* start)
 {
     // Starting node is exclusive.
     Node* found = findFocusableNode(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);
         if (foundInInnerFocusScope)
             return foundInInnerFocusScope;
+        if (isShadowHostDelegatesFocus(*found))
+            found = findFocusableNodeRecursivelyBackward(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);
     }
 
-    return found;
+    return found->isElementNode() && !isShadowHostDelegatesFocus(*found) ? found : findFocusableNodeRecursivelyBackward(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 398 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink