Do not use Node in FocusController, 3rd

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 54 matching lines @@
 namespace {
 
 inline bool isShadowInsertionPointFocusScopeOwner(Element& element)
 {
     return isActiveShadowInsertionPoint(element) && toHTMLShadowElement(element).olderShadowRoot();
 }
 
 class FocusNavigationScope {
     STACK_ALLOCATED();
 public:
-    Node* rootNode() const;
+    Element* firstElement() const;
+    Element* lastElement() const;
     Element* owner() const;
     static FocusNavigationScope focusNavigationScopeOf(const Element&);
     static FocusNavigationScope ownedByNonFocusableFocusScopeOwner(Element&);
     static FocusNavigationScope ownedByShadowHost(const Element&);
     static FocusNavigationScope ownedByShadowInsertionPoint(HTMLShadowElement&);
     static FocusNavigationScope ownedByIFrame(const HTMLFrameOwnerElement&);
 
 private:
     explicit FocusNavigationScope(TreeScope*);
+    ContainerNode& rootNode() const;
     RawPtrWillBeMember<TreeScope> m_rootTreeScope;
 };
 
 FocusNavigationScope::FocusNavigationScope(TreeScope* treeScope)
     : m_rootTreeScope(treeScope)
 {
     ASSERT(treeScope);
 }
 
-Node* FocusNavigationScope::rootNode() const
+ContainerNode& FocusNavigationScope::rootNode() const
 {
-    return &m_rootTreeScope->rootNode();
+    return m_rootTreeScope->rootNode();
+}
+
+Element* FocusNavigationScope::firstElement() const
+{
+    ContainerNode& root = m_rootTreeScope->rootNode();

[kochi, 2016/02/19 08:21:39]

nit: |m_rootTreeScope->| can be omitted.

[hayato, 2016/02/19 08:25:55]

Done.

+    return root.isElementNode() ? &toElement(root) : ElementTraversal::next(root);
+}
+
+Element* FocusNavigationScope::lastElement() const
+{
+    return ElementTraversal::lastWithin(rootNode());
 }
 
 Element* FocusNavigationScope::owner() const
 {
-    Node* root = rootNode();
-    if (root->isShadowRoot()) {
-        ShadowRoot* shadowRoot = toShadowRoot(root);
-        return shadowRoot->isYoungest() ? shadowRoot->host() : shadowRoot->shadowInsertionPointOfYoungerShadowRoot();
+    ContainerNode& 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())
+    if (Frame* frame = root.document().frame())
         return frame->deprecatedLocalOwner();
     return nullptr;
 }
 
 FocusNavigationScope FocusNavigationScope::focusNavigationScopeOf(const Element& element)
 {
     return FocusNavigationScope(&element.treeScope());
 }
 
 FocusNavigationScope FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(Element& element)
@@ skipping 78 matching lines @@
 {
     return element.isHTMLElement() && toHTMLElement(element).hasCustomFocusLogic();
 }
 
 inline bool isShadowHostWithoutCustomFocusLogic(const Element& element)
 {
     return isShadowHost(element) && !hasCustomFocusLogic(element);
 }
 
 #if ENABLE(ASSERT)
-inline bool isNonFocusableShadowHost(const Node& node)
+inline bool isNonFocusableShadowHost(const Element& element)
 {
-    if (!node.isElementNode())
-        return false;
-    const Element& element = toElement(node);
     return isShadowHostWithoutCustomFocusLogic(element) && !element.isFocusable();
 }
 #endif
 
 inline bool isNonKeyboardFocusableShadowHost(const Element& element)
 {
     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);
 }
 
 inline bool isShadowHostDelegatesFocus(const Element& element)
 {
     return element.authorShadowRoot() && element.authorShadowRoot()->delegatesFocus();
 }
 
-inline int adjustedTabIndex(Node& node)
+inline int adjustedTabIndex(Element& element)
 {
-    return node.isElementNode() && isNonFocusableFocusScopeOwner(toElement(node)) ? 0 : node.tabIndex();
+    return isNonFocusableFocusScopeOwner(element) ? 0 : element.tabIndex();
 }
 
-inline bool shouldVisit(Node& node)
+inline bool shouldVisit(Element& element)
 {
-    if (!node.isElementNode())
-        return false;
-    Element& element = toElement(node);
     return element.isKeyboardFocusable() || isNonFocusableFocusScopeOwner(element);
 }
 
-Element* findElementWithExactTabIndex(Node* start, int tabIndex, WebFocusType type)
+Element* findElementWithExactTabIndex(Element* 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 (shouldVisit(*node) && adjustedTabIndex(*node) == tabIndex)
-            return toElement(node);
+    for (Element* element = start; element; element = type == WebFocusTypeForward ? ElementTraversal::next(*element) : ElementTraversal::previous(*element)) {
+        if (shouldVisit(*element) && adjustedTabIndex(*element) == tabIndex)
+            return element;
     }
     return nullptr;
 }
 
-Element* nextElementWithGreaterTabIndex(Node* start, int tabIndex)
+Element* nextElementWithGreaterTabIndex(Element* 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;
+    Element* winner = nullptr;
+    for (Element& element : ElementTraversal::startsAt(start)) {
+        int currentTabIndex = adjustedTabIndex(element);
+        if (shouldVisit(element) && currentTabIndex > tabIndex && currentTabIndex < winningTabIndex) {
+            winner = &element;
             winningTabIndex = currentTabIndex;
         }
     }
-    ASSERT(!winner || winner->isElementNode());
-    return toElement(winner);
+    return winner;
 }
 
-Element* previousElementWithLowerTabIndex(Node* start, int tabIndex)
+Element* previousElementWithLowerTabIndex(Element* start, int tabIndex)
 {
     // Search is inclusive of start
     int winningTabIndex = 0;
-    Node* winner = nullptr;
-    for (Node* node = start; node; node = ElementTraversal::previous(*node)) {
-        int currentTabIndex = adjustedTabIndex(*node);
-        if (shouldVisit(*node) && currentTabIndex < tabIndex && currentTabIndex > winningTabIndex) {
-            winner = node;
+    Element* winner = nullptr;
+    for (Element* element = start; element; element = ElementTraversal::previous(*element)) {
+        int currentTabIndex = adjustedTabIndex(*element);
+        if (shouldVisit(*element) && currentTabIndex < tabIndex && currentTabIndex > winningTabIndex) {
+            winner = element;
             winningTabIndex = currentTabIndex;
         }
     }
-    ASSERT(!winner || winner->isElementNode());
-    return toElement(winner);
+    return winner;
 }
 
-Element* nextFocusableElement(const FocusNavigationScope& scope, Node* start)
+Element* nextFocusableElement(const FocusNavigationScope& scope, Element* 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 an element is excluded from the normal tabbing cycle, the next focusable element is determined by tree order
         if (tabIndex < 0) {
-            for (Node& node : NodeTraversal::startsAfter(*start)) {
-                if (shouldVisit(node) && adjustedTabIndex(node) >= 0)
-                    return &toElement(node);
+            for (Element& element : ElementTraversal::startsAfter(*start)) {
+                if (shouldVisit(element) && adjustedTabIndex(element) >= 0)
+                    return &element;
             }
         } else {
-            // First try to find a node with the same tabindex as start that comes after start in the scope.
+            // First try to find an element with the same tabindex as start that comes after start in the scope.
             if (Element* winner = findElementWithExactTabIndex(ElementTraversal::next(*start), 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.
+            // We've reached the last element 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:
+    // 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.
-    if (Element* winner = nextElementWithGreaterTabIndex(scope.rootNode(), start ? adjustedTabIndex(*start) : 0))
+    if (Element* winner = nextElementWithGreaterTabIndex(scope.firstElement(), 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);
+    // There are no elements with a tabindex greater than start's tabindex,
+    // so find the first element with a tabindex of 0.
+    return findElementWithExactTabIndex(scope.firstElement(), 0, WebFocusTypeForward);
 }
 
-Element* previousFocusableElement(const FocusNavigationScope& scope, Node* start)
+Element* previousFocusableElement(const FocusNavigationScope& scope, Element* start)
 {
-    Node* last = nullptr;
-    for (Node* node = scope.rootNode(); node; node = node->lastChild())
-        last = node;
-    ASSERT(last);
+    Element* lastElement = scope.lastElement();
 
-    // 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;
+    // 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.
+    Element* startElement;
+    int startTabIndex;
     if (start) {
-        startingNode = ElementTraversal::previous(*start);
-        startingTabIndex = adjustedTabIndex(*start);
+        startElement = ElementTraversal::previous(*start);
+        startTabIndex = adjustedTabIndex(*start);
     } else {
-        startingNode = last;
-        startingTabIndex = 0;
+        startElement = lastElement;
+        startTabIndex = 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)) {
-            if (shouldVisit(*node) && adjustedTabIndex(*node) >= 0)
-                return toElement(node);
+    // However, if an element is excluded from the normal tabbing cycle, the previous focusable element is determined by tree order
+    if (startTabIndex < 0) {
+        for (Element* element = startElement; element; element = ElementTraversal::previous(*element)) {
+            if (shouldVisit(*element) && adjustedTabIndex(*element) >= 0)
+                return element;
         }
     } else {
-        if (Element* winner = findElementWithExactTabIndex(startingNode, startingTabIndex, WebFocusTypeBackward))
+        if (Element* winner = findElementWithExactTabIndex(startElement, startTabIndex, WebFocusTypeBackward))
             return winner;
     }
 
-    // There are no nodes before start with the same tabindex as start, so look for a node that:
+    // There are no elements before start with the same tabindex as start, so look for an element that:
     // 1) has the highest non-zero tabindex (that is less than start's tabindex), and
     // 2) comes last in the scope, if there's a tie.
-    startingTabIndex = (start && startingTabIndex) ? startingTabIndex : std::numeric_limits<short>::max();
-    return previousElementWithLowerTabIndex(last, startingTabIndex);
+    startTabIndex = (start && startTabIndex) ? startTabIndex : std::numeric_limits<short>::max();
+    return previousElementWithLowerTabIndex(lastElement, startTabIndex);
 }
 
-// Searches through the given tree scope, starting from start node, for the next/previous
-// selectable element that comes after/before start node.
+// Searches through the given tree scope, starting from start element, for the next/previous
+// selectable element that comes after/before start element.
 // The order followed is as specified in the HTML spec[1], which is elements with tab indexes
 // first (from lowest to highest), and then elements without tab indexes (in document order).
 // The search algorithm also conforms the Shadow DOM spec[2], which inserts sequence in a shadow
 // tree into its host.
 //
-// @param start The node from which to start searching. The node after this will be focused.
+// @param start The element from which to start searching. The element after this will be focused.
 //        May be null.
-// @return The focus element that comes after/before start node.
+// @return The focus element that comes after/before start element.
 //
 // [1] https://html.spec.whatwg.org/multipage/interaction.html#sequential-focus-navigation
 // [2] https://w3c.github.io/webcomponents/spec/shadow/#focus-navigation
-inline Element* findFocusableElementInternal(WebFocusType type, const FocusNavigationScope& scope, Node* node)
+inline Element* findFocusableElementInternal(WebFocusType type, const FocusNavigationScope& scope, Element* element)
 {
-    Element* found = (type == WebFocusTypeForward) ? nextFocusableElement(scope, node) : previousFocusableElement(scope, node);
+    Element* found = (type == WebFocusTypeForward) ? nextFocusableElement(scope, element) : previousFocusableElement(scope, element);
     return found;
 }
 
-Element* findFocusableElementRecursivelyForward(const FocusNavigationScope& scope, Node* start)
+Element* findFocusableElementRecursivelyForward(const FocusNavigationScope& scope, Element* start)
 {
-    // Starting node is exclusive.
+    // Starting element is exclusive.
     Element* found = findFocusableElementInternal(WebFocusTypeForward, scope, start);
     while (found) {
         if (isShadowHostDelegatesFocus(*found)) {
-            // If tabindex is positive, find focusable node inside its shadow tree.
+            // If tabindex is positive, find focusable element inside its shadow tree.
             if (found->tabIndex() >= 0 && isShadowHostWithoutCustomFocusLogic(*found)) {
                 FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*found);
                 if (Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr))
                     return foundInInnerFocusScope;
             }
-            // Skip to the next node in the same scope.
+            // Skip to the next element 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>)
         // 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)
+Element* findFocusableElementRecursivelyBackward(const FocusNavigationScope& scope, Element* start)
 {
-    // Starting node is exclusive.
+    // Starting element 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>).
-        // Find focusable node in descendant scope. If not found, find next focusable node within the
+        // Find focusable element in descendant scope. If not found, find next focusable element 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;
         }
         if (!isShadowHostDelegatesFocus(*found))
             return found;
         found = findFocusableElementInternal(WebFocusTypeBackward, scope, found);
     }
     return nullptr;
 }
 
-Element* findFocusableElementRecursively(WebFocusType type, const FocusNavigationScope& scope, Node* start)
+Element* findFocusableElementRecursively(WebFocusType type, const FocusNavigationScope& scope, Element* start)
 {
     return (type == WebFocusTypeForward) ?
         findFocusableElementRecursivelyForward(scope, start) :
         findFocusableElementRecursivelyBackward(scope, start);
 }
 
 Element* findFocusableElementDescendingDownIntoFrameDocument(WebFocusType type, Element* element)
 {
     // The element we found might be a HTMLFrameOwnerElement, so descend down the tree until we find either:
     // 1) a focusable element, or
     // 2) the deepest-nested HTMLFrameOwnerElement.
     while (element && element->isFrameOwnerElement()) {
         HTMLFrameOwnerElement& owner = toHTMLFrameOwnerElement(*element);
         if (!owner.contentFrame() || !owner.contentFrame()->isLocalFrame())
             break;
         toLocalFrame(owner.contentFrame())->document()->updateLayoutIgnorePendingStylesheets();
         Element* foundElement = findFocusableElementRecursively(type, FocusNavigationScope::ownedByIFrame(owner), nullptr);
         if (!foundElement)
             break;
         ASSERT(element != foundElement);
         element = foundElement;
     }
     return element;
 }
 
-Element* findFocusableElementAcrossFocusScopesForward(const FocusNavigationScope& scope, Node* currentNode)
+Element* findFocusableElementAcrossFocusScopesForward(const FocusNavigationScope& scope, Element* current)
 {
-    ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
+    ASSERT(!current || !isNonFocusableShadowHost(*current));
     Element* found;
-    if (currentNode && currentNode->isElementNode() && isShadowHostWithoutCustomFocusLogic(*toElement(currentNode))) {
-        FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*toElement(currentNode));
+    if (current && isShadowHostWithoutCustomFocusLogic(*current)) {
+        FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*current);
         Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
-        found = foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, currentNode);
+        found = foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, current);
     } else {
-        found = findFocusableElementRecursivelyForward(scope, currentNode);
+        found = findFocusableElementRecursivelyForward(scope, current);
     }
 
-    // If there's no focusable node to advance to, move up the focus scopes until we find one.
+    // If there's no focusable element to advance to, move up the focus scopes until we find one.
     FocusNavigationScope currentScope = scope;
     while (!found) {
         Element* owner = currentScope.owner();
         if (!owner)
             break;
         currentScope = FocusNavigationScope::focusNavigationScopeOf(*owner);
         found = findFocusableElementRecursivelyForward(currentScope, owner);
     }
     return findFocusableElementDescendingDownIntoFrameDocument(WebFocusTypeForward, found);
 }
 
-Element* findFocusableElementAcrossFocusScopesBackward(const FocusNavigationScope& scope, Node* currentNode)
+Element* findFocusableElementAcrossFocusScopesBackward(const FocusNavigationScope& scope, Element* current)
 {
-    ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
-    Element* found = findFocusableElementRecursivelyBackward(scope, currentNode);
+    ASSERT(!current || !isNonFocusableShadowHost(*current));
+    Element* found = findFocusableElementRecursivelyBackward(scope, current);
 
-    // If there's no focusable node to advance to, move up the focus scopes until we find one.
+    // If there's no focusable element to advance to, move up the focus scopes until we find one.
     FocusNavigationScope currentScope = scope;
     while (!found) {
         Element* owner = currentScope.owner();
         if (!owner)
             break;
         currentScope = FocusNavigationScope::focusNavigationScopeOf(*owner);
         if (isKeyboardFocusableShadowHost(*owner) && !isShadowHostDelegatesFocus(*owner)) {
             found = owner;
             break;
         }
         found = findFocusableElementRecursivelyBackward(currentScope, owner);
     }
     return findFocusableElementDescendingDownIntoFrameDocument(WebFocusTypeBackward, found);
 }
 
-Element* findFocusableElementAcrossFocusScopes(WebFocusType type, const FocusNavigationScope& scope, Node* currentNode)
+Element* findFocusableElementAcrossFocusScopes(WebFocusType type, const FocusNavigationScope& scope, Element* current)
 {
     return (type == WebFocusTypeForward) ?
-        findFocusableElementAcrossFocusScopesForward(scope, currentNode) :
-        findFocusableElementAcrossFocusScopesBackward(scope, currentNode);
+        findFocusableElementAcrossFocusScopesForward(scope, current) :
+        findFocusableElementAcrossFocusScopesBackward(scope, current);
 }
 
 inline Element* adjustToElement(Node* node, WebFocusType type)
 {
     ASSERT(type == WebFocusTypeForward || type == WebFocusTypeBackward);
     if (!node)
         return nullptr;
     if (node->isElementNode())
         return toElement(node);
     return (type == WebFocusTypeForward) ? ElementTraversal::next(*node) : ElementTraversal::previous(*node);
@@ skipping 234 matching lines @@
         element = findFocusableElementRecursively(type, FocusNavigationScope::focusNavigationScopeOf(*toLocalFrame(m_page->mainFrame())->document()->documentElement()), nullptr);
         element = findFocusableElementDescendingDownIntoFrameDocument(type, element.get());
 
         if (!element)
             return false;
     }
 
     ASSERT(element);
 
     if (element == document->focusedElement()) {
-        // Focus wrapped around to the same node.
+        // Focus wrapped around to the same element.
         return true;
     }
 
     if (element->isFrameOwnerElement() && (!isHTMLPlugInElement(*element) || !element->isKeyboardFocusable())) {
         // We focus frames rather than frame owners.
         // FIXME: We should not focus frames that have no scrollbars, as focusing them isn't useful to the user.
         HTMLFrameOwnerElement* owner = toHTMLFrameOwnerElement(element);
         if (!owner->contentFrame())
             return false;
 
         document->clearFocusedElement();
         setFocusedFrame(owner->contentFrame());
 
         // If contentFrame is remote, continue the search for focusable
         // elements in that frame's process.
         // clearFocusedElement() fires events that might detach the
         // contentFrame, hence the need to null-check it again.
         if (owner->contentFrame() && owner->contentFrame()->isRemoteFrame())
             toRemoteFrame(owner->contentFrame())->advanceFocus(type, frame);
 
         return true;
     }
 
-    // FIXME: It would be nice to just be able to call setFocusedElement(node)
+    // FIXME: It would be nice to just be able to call setFocusedElement(element)
     // here, but we can't do that because some elements (e.g. HTMLInputElement
     // and HTMLTextAreaElement) do extra work in their focus() methods.
     Document& newDocument = element->document();
 
     if (&newDocument != document) {
-        // Focus is going away from this document, so clear the focused node.
+        // Focus is going away from this document, so clear the focused element.
         document->clearFocusedElement();
     }
 
     setFocusedFrame(newDocument.frame());
 
     if (caretBrowsing) {
         Position position = firstPositionInOrBeforeNode(element.get());
         VisibleSelection newSelection(position, position);
         frame->selection().setSelection(newSelection);
     }
@@ skipping 84 matching lines @@
 
     if (oldDocument && oldDocument != newDocument)
         oldDocument->clearFocusedElement();
 
     if (newFocusedFrame && !newFocusedFrame->page()) {
         setFocusedFrame(nullptr);
         return false;
     }
     setFocusedFrame(newFocusedFrame);
 
-    // Setting the focused node can result in losing our last reft to node when JS event handlers fire.
+    // Setting the focused element can result in losing our last reft to element when JS event handlers fire.
     RefPtrWillBeRawPtr<Element> protect = element;
     ALLOW_UNUSED_LOCAL(protect);
     if (newDocument) {
         bool successfullyFocused = newDocument->setFocusedElement(element, params);
         if (!successfullyFocused)
             return false;
     }
 
     return true;
 }
@@ skipping 203 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink