Support slots' fallback contents in focus navigation

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 73 matching lines @@
     static ScopedFocusNavigation createFor(const Element&);
     static ScopedFocusNavigation createForDocument(Document&);
     static ScopedFocusNavigation ownedByNonFocusableFocusScopeOwner(Element&);
     static ScopedFocusNavigation ownedByShadowHost(const Element&);
     static ScopedFocusNavigation ownedByShadowInsertionPoint(HTMLShadowElement&);
     static ScopedFocusNavigation ownedByHTMLSlotElement(const HTMLSlotElement&);
     static ScopedFocusNavigation ownedByIFrame(const HTMLFrameOwnerElement&);
 
 private:
     ScopedFocusNavigation(TreeScope&, const Element*);
-    ScopedFocusNavigation(HTMLSlotElement&, const Element*);
+    ScopedFocusNavigation(HTMLSlotElement&, const Element*, bool);

[kochi, 2016/03/30 06:28:34]

Can the third boolean argument be removed?
If the value is always initialized slotElement.getAssignedNodes().isEmpty(),
how about doing it in this constructor?

BTW, in Blink's style preference, a boolean parameter is discouraged and an enum
constant is preferred for readability unless the function is single-parameter
function (e.g. setFooFlag(bool) is okay, setFoo(Foo*, bool) is not good).

[yuzuchan, 2016/03/31 07:03:46]

Gotcha! Thank you :) 

     RawPtrWillBeMember<ContainerNode> m_rootNode;
     RawPtrWillBeMember<HTMLSlotElement> m_rootSlot;
     RawPtrWillBeMember<Element> m_current;
+    bool m_slotFallbackTraversal;
 };
 
 ScopedFocusNavigation::ScopedFocusNavigation(TreeScope& treeScope, const Element* current)
     : m_rootNode(treeScope.rootNode())
     , m_rootSlot(nullptr)
     , m_current(const_cast<Element*>(current))
+    , m_slotFallbackTraversal(false)
 {
 }
 
-ScopedFocusNavigation::ScopedFocusNavigation(HTMLSlotElement& slot, const Element* current)
+ScopedFocusNavigation::ScopedFocusNavigation(HTMLSlotElement& slot, const Element* current, bool isFallbackScoped)
     : m_rootNode(nullptr)
     , m_rootSlot(&slot)
     , m_current(const_cast<Element*>(current))
+    , m_slotFallbackTraversal(isFallbackScoped)
 {
 }
 
 Element* ScopedFocusNavigation::currentElement() const
 {
     return m_current;
 }
 
 void ScopedFocusNavigation::setCurrentElement(Element* element)
 {
     m_current = element;
 }
 
 void ScopedFocusNavigation::moveToNext()
 {
     ASSERT(m_current);
     if (m_rootSlot) {
-        m_current = SlotScopedTraversal::next(*m_current);
+        if (m_slotFallbackTraversal) {
+            m_current = ElementTraversal::next(*m_current, m_rootSlot);
+            while (m_current && SlotScopedTraversal::isSlotScoped(*m_current))
+                m_current = ElementTraversal::next(*m_current);
+        } else {
+            m_current = SlotScopedTraversal::next(*m_current);
+        }
     } else {
         m_current = ElementTraversal::next(*m_current);
-        while (m_current && SlotScopedTraversal::isSlotScoped(*m_current))
+        while (m_current && (SlotScopedTraversal::isSlotScoped(*m_current) || SlotScopedTraversal::isSlotFallbackScoped(*m_current)))
             m_current = ElementTraversal::next(*m_current);
     }
 }
 
 void ScopedFocusNavigation::moveToPrevious()
 {
     ASSERT(m_current);
     if (m_rootSlot) {
-        m_current = SlotScopedTraversal::previous(*m_current);
+        if (m_slotFallbackTraversal) {
+            m_current = ElementTraversal::previous(*m_current, m_rootSlot);
+            if (m_current == m_rootSlot)
+                m_current = nullptr;
+            while (m_current && SlotScopedTraversal::isSlotScoped(*m_current))
+                m_current = ElementTraversal::previous(*m_current);
+        } else {
+            m_current = SlotScopedTraversal::previous(*m_current);
+        }
     } else {
         m_current = ElementTraversal::previous(*m_current);
-        while (m_current && SlotScopedTraversal::isSlotScoped(*m_current))
+        while (m_current && (SlotScopedTraversal::isSlotScoped(*m_current) || SlotScopedTraversal::isSlotFallbackScoped(*m_current)))
             m_current = ElementTraversal::previous(*m_current);
     }
 }
 
 void ScopedFocusNavigation::moveToFirst()
 {
     if (m_rootSlot) {
-        if (!m_rootSlot->getAssignedNodes().isEmpty()) {
+        if (!m_slotFallbackTraversal) {
             WillBeHeapVector<RefPtrWillBeMember<Node>> assignedNodes = m_rootSlot->getAssignedNodes();
             for (auto assignedNode : assignedNodes) {
                 if (assignedNode->isElementNode()) {
                     m_current = toElement(assignedNode);
                     break;
                 }
             }
         } else {
-            m_current = nullptr;
+            Element* first = ElementTraversal::firstChild(*m_rootSlot);
+            while (first && SlotScopedTraversal::isSlotScoped(*first))
+                first = ElementTraversal::next(*first, m_rootSlot);
+            m_current = first;
         }
     } else {
         Element* first = m_rootNode->isElementNode() ? &toElement(*m_rootNode) : ElementTraversal::next(*m_rootNode);
-        while (first && SlotScopedTraversal::isSlotScoped(*first))
+        while (first && (SlotScopedTraversal::isSlotScoped(*first) || SlotScopedTraversal::isSlotFallbackScoped(*first)))
             first = ElementTraversal::next(*first, m_rootNode);
         m_current = first;
     }
+
 }
 
 void ScopedFocusNavigation::moveToLast()
 {
     if (m_rootSlot) {
-        if (!m_rootSlot->getAssignedNodes().isEmpty()) {
+        if (!m_slotFallbackTraversal) {
             WillBeHeapVector<RefPtrWillBeMember<Node>> assignedNodes = m_rootSlot->getAssignedNodes();
             for (auto assignedNode = assignedNodes.rbegin(); assignedNode != assignedNodes.rend(); ++assignedNode) {
                 if ((*assignedNode)->isElementNode()) {
                     m_current = ElementTraversal::lastWithinOrSelf(*toElement(*assignedNode));
                     break;
                 }
             }
         } else {
-            m_current = nullptr;
+            Element* last = ElementTraversal::lastWithin(*m_rootSlot);
+            while (last && SlotScopedTraversal::isSlotScoped(*last))
+                last = ElementTraversal::previous(*last, m_rootSlot);
+            m_current = last;
         }
     } else {
         Element* last = ElementTraversal::lastWithin(*m_rootNode);
-        while (last && SlotScopedTraversal::isSlotScoped(*last))
+        while (last && (SlotScopedTraversal::isSlotScoped(*last) || SlotScopedTraversal::isSlotFallbackScoped(*last)))
             last = ElementTraversal::previous(*last, m_rootNode);
         m_current = last;
     }
 }
 
 Element* ScopedFocusNavigation::owner() const
 {
     if (m_rootSlot)
         return m_rootSlot;
+    ASSERT(m_rootNode);
     if (m_rootNode->isShadowRoot()) {
         ShadowRoot& shadowRoot = toShadowRoot(*m_rootNode);
         return shadowRoot.isYoungest() ? shadowRoot.host() : shadowRoot.shadowInsertionPointOfYoungerShadowRoot();
     }
     // FIXME: Figure out the right thing for OOPI here.
     if (Frame* frame = m_rootNode->document().frame())
         return frame->deprecatedLocalOwner();
     return nullptr;
 }
 
 ScopedFocusNavigation ScopedFocusNavigation::createFor(const Element& current)
 {
     if (SlotScopedTraversal::isSlotScoped(current))
-        return ScopedFocusNavigation(*SlotScopedTraversal::findScopeOwnerSlot(current), &current);
+        return ScopedFocusNavigation(*SlotScopedTraversal::findScopeOwnerSlot(current), &current, false);
+    if (SlotScopedTraversal::isSlotFallbackScoped(current))
+        return ScopedFocusNavigation(*SlotScopedTraversal::findFallbackScopeOwnerSlot(current), &current, true);
     return ScopedFocusNavigation(current.treeScope(), &current);
 }
 
 ScopedFocusNavigation ScopedFocusNavigation::createForDocument(Document& document)
 {
     return ScopedFocusNavigation(document, nullptr);
 }
 
 ScopedFocusNavigation ScopedFocusNavigation::ownedByNonFocusableFocusScopeOwner(Element& element)
 {
@@ skipping 20 matching lines @@
 }
 
 ScopedFocusNavigation ScopedFocusNavigation::ownedByShadowInsertionPoint(HTMLShadowElement& shadowInsertionPoint)
 {
     ASSERT(isShadowInsertionPointFocusScopeOwner(shadowInsertionPoint));
     return ScopedFocusNavigation(*shadowInsertionPoint.olderShadowRoot(), nullptr);
 }
 
 ScopedFocusNavigation ScopedFocusNavigation::ownedByHTMLSlotElement(const HTMLSlotElement& element)
 {
-    return ScopedFocusNavigation(const_cast<HTMLSlotElement&>(element), nullptr);
+    return ScopedFocusNavigation(const_cast<HTMLSlotElement&>(element), nullptr, element.getAssignedNodes().isEmpty());
 }
 
 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 154 matching lines @@
         }
     }
 
     // Look for the first element 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.
     scope.moveToFirst();
     if (Element* winner = nextElementWithGreaterTabIndex(scope, current ? adjustedTabIndex(*current) : 0)) {
         return winner;
     }
-
     // There are no elements with a tabindex greater than start's tabindex,
     // so find the first element with a tabindex of 0.
     scope.moveToFirst();
     return findElementWithExactTabIndex(scope, 0, WebFocusTypeForward);
 }
 
 Element* previousFocusableElement(ScopedFocusNavigation& scope)
 {
     // First try to find the last element in the scope that comes before start and has the same tabindex as start.
     // If start is null, find the last element in the scope with a tabindex of 0.
@@ skipping 821 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink