Rename Slot.getAssingedNodes() -> Slot.assignedNodes()

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 94 matching lines @@
     : m_rootNode(treeScope.rootNode())
     , m_rootSlot(nullptr)
     , m_current(const_cast<Element*>(current))
 {
 }
 
 ScopedFocusNavigation::ScopedFocusNavigation(HTMLSlotElement& slot, const Element* current)
     : m_rootNode(nullptr)
     , m_rootSlot(&slot)
     , m_current(const_cast<Element*>(current))
-    , m_slotFallbackTraversal(slot.getAssignedNodes().isEmpty())
+    , m_slotFallbackTraversal(slot.assignedNodes().isEmpty())
 {
 }
 
 Element* ScopedFocusNavigation::currentElement() const
 {
     return m_current;
 }
 
 void ScopedFocusNavigation::setCurrentElement(Element* element)
 {
@@ skipping 35 matching lines @@
         m_current = ElementTraversal::previous(*m_current);
         while (m_current && (SlotScopedTraversal::isSlotScoped(*m_current) || ScopedFocusNavigation::isSlotFallbackScoped(*m_current)))
             m_current = ElementTraversal::previous(*m_current);
     }
 }
 
 void ScopedFocusNavigation::moveToFirst()
 {
     if (m_rootSlot) {
         if (!m_slotFallbackTraversal) {
-            HeapVector<Member<Node>> assignedNodes = m_rootSlot->getAssignedNodes();
+            HeapVector<Member<Node>> assignedNodes = m_rootSlot->assignedNodes();
             for (auto assignedNode : assignedNodes) {
                 if (assignedNode->isElementNode()) {
                     m_current = toElement(assignedNode);
                     break;
                 }
             }
         } else {
             Element* first = ElementTraversal::firstChild(*m_rootSlot);
             while (first && !ScopedFocusNavigation::isSlotFallbackScopedForThisSlot(*m_rootSlot, *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) || ScopedFocusNavigation::isSlotFallbackScoped(*first)))
             first = ElementTraversal::next(*first, m_rootNode);
         m_current = first;
     }
 
 }
 
 void ScopedFocusNavigation::moveToLast()
 {
     if (m_rootSlot) {
         if (!m_slotFallbackTraversal) {
-            HeapVector<Member<Node>> assignedNodes = m_rootSlot->getAssignedNodes();
+            HeapVector<Member<Node>> assignedNodes = m_rootSlot->assignedNodes();
             for (auto assignedNode = assignedNodes.rbegin(); assignedNode != assignedNodes.rend(); ++assignedNode) {
                 if ((*assignedNode)->isElementNode()) {
                     m_current = ElementTraversal::lastWithinOrSelf(*toElement(*assignedNode));
                     break;
                 }
             }
         } else {
             Element* last = ElementTraversal::lastWithin(*m_rootSlot);
             while (last && !ScopedFocusNavigation::isSlotFallbackScopedForThisSlot(*m_rootSlot, *last))
                 last = ElementTraversal::previous(*last, m_rootSlot);
@@ skipping 69 matching lines @@
 ScopedFocusNavigation ScopedFocusNavigation::ownedByHTMLSlotElement(const HTMLSlotElement& element)
 {
     return ScopedFocusNavigation(const_cast<HTMLSlotElement&>(element), nullptr);
 }
 
 HTMLSlotElement* ScopedFocusNavigation::findFallbackScopeOwnerSlot(const Element& element)
 {
     Element* parent = const_cast<Element*>(element.parentElement());
     while (parent) {
         if (isHTMLSlotElement(parent))
-            return toHTMLSlotElement(parent)->getAssignedNodes().isEmpty() ? toHTMLSlotElement(parent) : nullptr;
+            return toHTMLSlotElement(parent)->assignedNodes().isEmpty() ? toHTMLSlotElement(parent) : nullptr;
         parent = parent->parentElement();
     }
     return nullptr;
 }
 
 bool ScopedFocusNavigation::isSlotFallbackScoped(const Element& element)
 {
     return ScopedFocusNavigation::findFallbackScopeOwnerSlot(element);
 }
 
 bool ScopedFocusNavigation::isSlotFallbackScopedForThisSlot(const HTMLSlotElement& slot, const Element& current)
 {
     Element* parent = current.parentElement();
     while (parent) {
-        if (isHTMLSlotElement(parent) && toHTMLSlotElement(parent)->getAssignedNodes().isEmpty())
+        if (isHTMLSlotElement(parent) && toHTMLSlotElement(parent)->assignedNodes().isEmpty())
             return !SlotScopedTraversal::isSlotScoped(current) && toHTMLSlotElement(parent) == slot;
         parent = parent->parentElement();
     }
     return false;
 }
 
 inline void dispatchBlurEvent(const Document& document, Element& focusedElement)
 {
     focusedElement.dispatchBlurEvent(nullptr, WebFocusTypePage);
     if (focusedElement == document.focusedElement()) {
@@ skipping 993 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink