Skip the whole shadow tree when its tabindex is -1.

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 536 matching lines @@
         findFocusableElementRecursivelyBackward(scope, start);
 }
 
 Element* FocusController::findFocusableElementRecursivelyForward(const FocusNavigationScope& scope, Node* start)
 {
     // Starting node is exclusive.
     Element* found = findFocusableElement(WebFocusTypeForward, scope, start);
     if (!found)
         return nullptr;
     if (isShadowHostDelegatesFocus(*found)) {
-        if (isShadowHostWithoutCustomFocusLogic(*found)) {
+        // If tabindex is positive, find focusable node inside its shadow tree.
+        if (found->tabIndex() >= 0 && isShadowHostWithoutCustomFocusLogic(*found)) {
             FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*found);
-            Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
-            return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, found);
+            if (Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr))
+                return foundInInnerFocusScope;
         }
-        // Skip to the next node.
-        if (!isNonFocusableFocusScopeOwner(*found))

[kochi, 2015/06/17 07:11:49]

In the previous CL[1], I added this line (563) but this code was wrong.

Lines 557-564 are executed when |found| is a shadow host and its
|delegatesFocus|
is true.  It also implies |found| is not a UA shadow root (as no one uses
|delegatesFocus| so far), thus on line 557 isShadowHostWithoutCustomFocusLogic()
returned always true, and lines 563-564 were never executed.

[1]:
https://codereview.chromium.org/1174893002/diff/40001/Source/core/page/FocusC...

-            found = findFocusableElementRecursivelyForward(scope, found);
+        // Skip to the next node in the same scope.
+        found = findFocusableElementRecursivelyForward(scope, found);
     }
     if (!found || !isNonFocusableFocusScopeOwner(*found))
         return found;
 
-    // Now |found| is on a focusable scope owner (either shadow host or <shadow>)
+    // Now |found| is on a non focusable scope owner (either shadow host or <shadow>)

[kochi, 2015/06/17 07:11:49]

The comment was wrong ;(

     // Find inside the inward scope and return it if found. Otherwise continue searching in the same
     // scope.
     FocusNavigationScope innerScope = FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(*found);
-    Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
-    return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, found);
+    if (Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr))
+        return foundInInnerFocusScope;
+    return findFocusableElementRecursivelyForward(scope, found);

[kochi, 2015/06/17 07:11:50]

This chunk does not change the logic, but aligned style with lines 559-561.
It can be extracted to a function, but this is small and I keep them.

 }
 
 Element* FocusController::findFocusableElementRecursivelyBackward(const FocusNavigationScope& scope, Node* start)
 {
     // Starting node is exclusive.
     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);
         Element* foundInInnerFocusScope = findFocusableElementRecursivelyBackward(innerScope, nullptr);
         if (foundInInnerFocusScope)
             return foundInInnerFocusScope;
         if (isShadowHostDelegatesFocus(*found))
             found = findFocusableElementRecursivelyBackward(scope, found);
         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)
+        return findFocusableElementRecursivelyBackward(scope, 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);
         Element* foundInInnerFocusScope = findFocusableElementRecursivelyBackward(innerScope, nullptr);
         return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyBackward(scope, found);
     }
 
     return !isShadowHostDelegatesFocus(*found) ? found : findFocusableElementRecursivelyBackward(scope, found);
@@ skipping 412 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink