Change private API names and return type in FocusController

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 @@
 {
     return isActiveShadowInsertionPoint(node) && toHTMLShadowElement(node).olderShadowRoot();
 }
 
 class FocusNavigationScope {
     STACK_ALLOCATED();
 public:
     Node* rootNode() const;
     Element* owner() const;
     static FocusNavigationScope focusNavigationScopeOf(const Node&);
-    static FocusNavigationScope ownedByNonFocusableFocusScopeOwner(Node&);
-    static FocusNavigationScope ownedByShadowHost(const Node&);
+    static FocusNavigationScope ownedByNonFocusableFocusScopeOwner(Element&);
+    static FocusNavigationScope ownedByShadowHost(const Element&);
     static FocusNavigationScope ownedByShadowInsertionPoint(HTMLShadowElement&);
     static FocusNavigationScope ownedByIFrame(const HTMLFrameOwnerElement&);
 
 private:
     explicit FocusNavigationScope(TreeScope*);
     RawPtrWillBeMember<TreeScope> m_rootTreeScope;
 };
 
 // FIXME: Some of Node* return values and Node* arguments should be Element*.
 
@@ skipping 24 matching lines @@
 FocusNavigationScope FocusNavigationScope::focusNavigationScopeOf(const Node& node)
 {
     const Node* root = &node;
     for (const Node* n = &node; n; n = n->parentNode())
         root = n;
     // The result is not always a ShadowRoot nor a DocumentNode since
     // a starting node is in an orphaned tree in composed shadow tree.
     return FocusNavigationScope(&root->treeScope());
 }
 
-FocusNavigationScope FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(Node& node)
+FocusNavigationScope FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(Element& element)
 {
-    if (isShadowHost(node))
-        return FocusNavigationScope::ownedByShadowHost(node);
-    ASSERT(isShadowInsertionPointFocusScopeOwner(node));
-    return FocusNavigationScope::ownedByShadowInsertionPoint(toHTMLShadowElement(node));
+    if (isShadowHost(element))
+        return FocusNavigationScope::ownedByShadowHost(element);
+    ASSERT(isShadowInsertionPointFocusScopeOwner(element));
+    return FocusNavigationScope::ownedByShadowInsertionPoint(toHTMLShadowElement(element));
 }
 
-FocusNavigationScope FocusNavigationScope::ownedByShadowHost(const Node& node)
+FocusNavigationScope FocusNavigationScope::ownedByShadowHost(const Element& element)
 {
-    ASSERT(isShadowHost(node));
-    return FocusNavigationScope(toElement(node).shadow()->youngestShadowRoot());
+    ASSERT(isShadowHost(element));
+    return FocusNavigationScope(element.shadow()->youngestShadowRoot());
 }
 
 FocusNavigationScope FocusNavigationScope::ownedByIFrame(const HTMLFrameOwnerElement& frame)
 {
     ASSERT(frame.contentFrame());
     ASSERT(frame.contentFrame()->isLocalFrame());
     return FocusNavigationScope(toLocalFrame(frame.contentFrame())->document());
 }
 
 FocusNavigationScope FocusNavigationScope::ownedByShadowInsertionPoint(HTMLShadowElement& shadowInsertionPoint)
@@ skipping 15 matching lines @@
 static inline void dispatchFocusEvent(const Document& document, Element& focusedElement)
 {
     focusedElement.dispatchFocusEvent(0, WebFocusTypePage);
     if (focusedElement == document.focusedElement()) {
         focusedElement.dispatchFocusInEvent(EventTypeNames::focusin, nullptr, WebFocusTypePage);
         if (focusedElement == document.focusedElement())
             focusedElement.dispatchFocusInEvent(EventTypeNames::DOMFocusIn, nullptr, WebFocusTypePage);
     }
 }
 
-static inline void dispatchEventsOnWindowAndFocusedNode(Document* document, bool focused)
+static inline void dispatchEventsOnWindowAndFocusedElement(Document* document, bool focused)
 {
     ASSERT(document);
-    // If we have a focused node we should dispatch blur on it before we blur the window.
-    // If we have a focused node we should dispatch focus on it after we focus the window.
+    // If we have a focused element we should dispatch blur on it before we blur the window.
+    // If we have a focused element we should dispatch focus on it after we focus the window.
     // https://bugs.webkit.org/show_bug.cgi?id=27105
 
     if (document->focusedElement() && isHTMLPlugInElement(document->focusedElement()))
         toHTMLPlugInElement(document->focusedElement())->setPluginFocus(focused);
 
     // Do not fire events while modal dialogs are up.  See https://bugs.webkit.org/show_bug.cgi?id=33962
     if (Page* page = document->page()) {
         if (page->defersLoading())
             return;
     }
@@ skipping 156 matching lines @@
     if (!m_isFocused && focusedOrMainFrame()->isLocalFrame())
         toLocalFrame(focusedOrMainFrame())->eventHandler().stopAutoscroll();
 
     if (!m_focusedFrame)
         setFocusedFrame(m_page->mainFrame());
 
     // setFocusedFrame above might reject to update m_focusedFrame, or
     // m_focusedFrame might be changed by blur/focus event handlers.
     if (m_focusedFrame && m_focusedFrame->isLocalFrame() && toLocalFrame(m_focusedFrame.get())->view()) {
         toLocalFrame(m_focusedFrame.get())->selection().setFocused(focused);
-        dispatchEventsOnWindowAndFocusedNode(toLocalFrame(m_focusedFrame.get())->document(), focused);
+        dispatchEventsOnWindowAndFocusedElement(toLocalFrame(m_focusedFrame.get())->document(), focused);
     }
 }
 
-Node* FocusController::findFocusableNodeDecendingDownIntoFrameDocument(WebFocusType type, Node* node)
+Element* FocusController::findFocusableElementDescendingDownIntoFrameDocument(WebFocusType type, Element* element)
 {
-    // The node we found might be a HTMLFrameOwnerElement, so descend down the tree until we find either:
-    // 1) a focusable node, or
+    // 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 (node && node->isFrameOwnerElement()) {
-        HTMLFrameOwnerElement& owner = toHTMLFrameOwnerElement(*node);
+    while (element && element->isFrameOwnerElement()) {
+        HTMLFrameOwnerElement& owner = toHTMLFrameOwnerElement(*element);
         if (!owner.contentFrame() || !owner.contentFrame()->isLocalFrame())
             break;
         toLocalFrame(owner.contentFrame())->document()->updateLayoutIgnorePendingStylesheets();
         Element* foundElement = findFocusableElement(type, FocusNavigationScope::ownedByIFrame(owner), nullptr);
         if (!foundElement)
             break;
-        ASSERT(node != foundElement);
-        node = foundElement;
+        ASSERT(element != foundElement);
+        element = foundElement;
     }
-    return node;
+    return element;
 }
 
 bool FocusController::setInitialFocus(WebFocusType type)
 {
     bool didAdvanceFocus = advanceFocus(type, true);
 
     // If focus is being set initially, accessibility needs to be informed that system focus has moved
     // into the web area again, even if focus did not change within WebCore. PostNotification is called instead
     // of handleFocusedUIElementChanged, because this will send the notification even if the element is the same.
     if (focusedOrMainFrame()->isLocalFrame()) {
@@ skipping 35 matching lines @@
 
     Node* currentNode = document->focusedElement();
     // FIXME: Not quite correct when it comes to focus transitions leaving/entering the WebView itself
     bool caretBrowsing = frame->settings() && frame->settings()->caretBrowsingEnabled();
 
     if (caretBrowsing && !currentNode)
         currentNode = frame->selection().start().deprecatedNode();
 
     document->updateLayoutIgnorePendingStylesheets();
 
-    RefPtrWillBeRawPtr<Node> node = findFocusableNodeAcrossFocusScopes(type, FocusNavigationScope::focusNavigationScopeOf(currentNode ? *currentNode : *document), currentNode);
+    RefPtrWillBeRawPtr<Element> element = findFocusableElementAcrossFocusScopes(type, FocusNavigationScope::focusNavigationScopeOf(currentNode ? *currentNode : *document), currentNode);
 
-    if (!node) {
-        // We didn't find a node to focus, so we should try to pass focus to Chrome.
+    if (!element) {
+        // We didn't find an element to focus, so we should try to pass focus to Chrome.
         if (!initialFocus && m_page->chromeClient().canTakeFocus(type)) {
             document->setFocusedElement(nullptr);
             setFocusedFrame(nullptr);
             m_page->chromeClient().takeFocus(type);
             return true;
         }
 
         // Chrome doesn't want focus, so we should wrap focus.
         if (!m_page->mainFrame()->isLocalFrame())
             return false;
-        node = findFocusableElementRecursively(type, FocusNavigationScope::focusNavigationScopeOf(*m_page->deprecatedLocalMainFrame()->document()), nullptr);
-        node = findFocusableNodeDecendingDownIntoFrameDocument(type, node.get());
+        element = findFocusableElementRecursively(type, FocusNavigationScope::focusNavigationScopeOf(*m_page->deprecatedLocalMainFrame()->document()), nullptr);
+        element = findFocusableElementDescendingDownIntoFrameDocument(type, element.get());
 
-        if (!node)
+        if (!element)
             return false;
     }
 
-    ASSERT(node);
+    ASSERT(element);
 
-    if (node == document->focusedElement())
+    if (element == document->focusedElement())
         // Focus wrapped around to the same node.
         return true;
 
-    if (!node->isElementNode())
-        // FIXME: May need a way to focus a document here.
-        return false;
-
-    Element* element = toElement(node);
     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->setFocusedElement(nullptr);
         setFocusedFrame(owner->contentFrame());
         return true;
     }
 
     // FIXME: It would be nice to just be able to call setFocusedElement(node)
     // 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.
         document->setFocusedElement(nullptr);
     }
 
     setFocusedFrame(newDocument.frame());
 
     if (caretBrowsing) {
-        Position position = firstPositionInOrBeforeNode(element);
+        Position position = firstPositionInOrBeforeNode(element.get());
         VisibleSelection newSelection(position, position, DOWNSTREAM);
         frame->selection().setSelection(newSelection);
     }
 
     element->focus(false, type);
     return true;
 }
 
-Node* FocusController::findFocusableNodeAcrossFocusScopes(WebFocusType type, const FocusNavigationScope& scope, Node* currentNode)
+Element* FocusController::findFocusableElementAcrossFocusScopes(WebFocusType type, const FocusNavigationScope& scope, Node* currentNode)
 {
     return (type == WebFocusTypeForward) ?
-        findFocusableNodeAcrossFocusScopesForward(scope, currentNode) :
-        findFocusableNodeAcrossFocusScopesBackward(scope, currentNode);
+        findFocusableElementAcrossFocusScopesForward(scope, currentNode) :
+        findFocusableElementAcrossFocusScopesBackward(scope, currentNode);
 }
 
-Node* FocusController::findFocusableNodeAcrossFocusScopesForward(const FocusNavigationScope& scope, Node* currentNode)
+Element* FocusController::findFocusableElementAcrossFocusScopesForward(const FocusNavigationScope& scope, Node* currentNode)
 {
     ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
-    Node* found;
+    Element* found;
     if (currentNode && isShadowHostWithoutCustomFocusLogic(*currentNode)) {
-        FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*currentNode);
-        Node* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
+        FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*toElement(currentNode));
+        Element* foundInInnerFocusScope = findFocusableElementRecursivelyForward(innerScope, nullptr);
         found = foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableElementRecursivelyForward(scope, currentNode);
     } else {
         found = findFocusableElementRecursivelyForward(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();
+        Element* owner = currentScope.owner();
         if (!owner)
             break;
         currentScope = FocusNavigationScope::focusNavigationScopeOf(*owner);
         found = findFocusableElementRecursivelyForward(currentScope, owner);
     }
-    return findFocusableNodeDecendingDownIntoFrameDocument(WebFocusTypeForward, found);
+    return findFocusableElementDescendingDownIntoFrameDocument(WebFocusTypeForward, found);
 }
 
-Node* FocusController::findFocusableNodeAcrossFocusScopesBackward(const FocusNavigationScope& scope, Node* currentNode)
+Element* FocusController::findFocusableElementAcrossFocusScopesBackward(const FocusNavigationScope& scope, Node* currentNode)
 {
     ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
-    Node* found = findFocusableElementRecursivelyBackward(scope, currentNode);
+    Element* found = findFocusableElementRecursivelyBackward(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();
+        Element* owner = currentScope.owner();
         if (!owner)
             break;
         currentScope = FocusNavigationScope::focusNavigationScopeOf(*owner);
         if (isKeyboardFocusableShadowHost(*owner) && !isShadowHostDelegatesFocus(*owner)) {
             found = owner;
             break;
         }
         found = findFocusableElementRecursivelyBackward(currentScope, owner);
     }
-    return findFocusableNodeDecendingDownIntoFrameDocument(WebFocusTypeBackward, found);
+    return findFocusableElementDescendingDownIntoFrameDocument(WebFocusTypeBackward, found);
 }
 
 Element* FocusController::findFocusableElementRecursively(WebFocusType type, const FocusNavigationScope& scope, Node* start)
 {
     return (type == WebFocusTypeForward) ?
         findFocusableElementRecursivelyForward(scope, start) :
         findFocusableElementRecursivelyBackward(scope, start);
 }
 
 Element* FocusController::findFocusableElementRecursivelyForward(const FocusNavigationScope& scope, Node* start)
@@ skipping 37 matching lines @@
         FocusNavigationScope innerScope = FocusNavigationScope::ownedByShadowHost(*found);
         Element* foundInInnerFocusScope = findFocusableElementRecursivelyBackward(innerScope, nullptr);
         if (foundInInnerFocusScope)
             return foundInInnerFocusScope;
         if (isShadowHostDelegatesFocus(*found))
             found = findFocusableElementRecursivelyBackward(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
+    // Find focusable node in descendant 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);
 }
 
-static Node* findNodeWithExactTabIndex(Node* start, int tabIndex, WebFocusType type)
+static Element* findElementWithExactTabIndex(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 toElement(node);
     }
     return nullptr;
 }
 
-static Node* nextNodeWithGreaterTabIndex(Node* start, int tabIndex)
+static Element* nextElementWithGreaterTabIndex(Node* 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;
             winningTabIndex = currentTabIndex;
         }
     }
-
-    return winner;
+    ASSERT(!winner || winner->isElementNode());
+    return toElement(winner);
 }
 
-static Node* previousNodeWithLowerTabIndex(Node* start, int tabIndex)
+static Element* previousElementWithLowerTabIndex(Node* start, int tabIndex)
 {
     // Search is inclusive of start
     int winningTabIndex = 0;
     Node* winner = nullptr;
     for (Node* node = start; node; node = NodeTraversal::previous(*node)) {
         int currentTabIndex = adjustedTabIndex(*node);
         if (shouldVisit(*node) && currentTabIndex < tabIndex && currentTabIndex > winningTabIndex) {
             winner = node;
             winningTabIndex = currentTabIndex;
         }
     }
-    return winner;
+    ASSERT(!winner || winner->isElementNode());
+    return toElement(winner);
 }
 
-static Node* nextFocusableNode(const FocusNavigationScope& scope, Node* start)
+static Element* nextFocusableElement(const FocusNavigationScope& scope, Node* 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 (tabIndex < 0) {
             for (Node& node : NodeTraversal::startsAfter(*start)) {
                 if (shouldVisit(node) && adjustedTabIndex(node) >= 0)
-                    return &node;
+                    return &toElement(node);
             }
         } else {
             // First try to find a node with the same tabindex as start that comes after start in the scope.
-            if (Node* winner = findNodeWithExactTabIndex(NodeTraversal::next(*start), tabIndex, WebFocusTypeForward))
+            if (Element* winner = findElementWithExactTabIndex(NodeTraversal::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.
             return nullptr;
         }
     }
 
     // Look for the first node 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 (Node* winner = nextNodeWithGreaterTabIndex(scope.rootNode(), start ? adjustedTabIndex(*start) : 0))
+    if (Element* winner = nextElementWithGreaterTabIndex(scope.rootNode(), 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 findNodeWithExactTabIndex(scope.rootNode(), 0, WebFocusTypeForward);
+    return findElementWithExactTabIndex(scope.rootNode(), 0, WebFocusTypeForward);
 }
 
-static Node* previousFocusableNode(const FocusNavigationScope& scope, Node* start)
+static Element* previousFocusableElement(const FocusNavigationScope& scope, Node* start)
 {
     Node* last = nullptr;
     for (Node* node = scope.rootNode(); node; node = node->lastChild())
         last = node;
     ASSERT(last);
 
     // 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;
     if (start) {
         startingNode = NodeTraversal::previous(*start);
         startingTabIndex = adjustedTabIndex(*start);
     } else {
         startingNode = last;
         startingTabIndex = 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 = NodeTraversal::previous(*node)) {
             if (shouldVisit(*node) && adjustedTabIndex(*node) >= 0)
-                return node;
+                return toElement(node);
         }
     } else {
-        if (Node* winner = findNodeWithExactTabIndex(startingNode, startingTabIndex, WebFocusTypeBackward))
+        if (Element* winner = findElementWithExactTabIndex(startingNode, startingTabIndex, WebFocusTypeBackward))
             return winner;
     }
 
     // There are no nodes before start with the same tabindex as start, so look for a node 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 previousNodeWithLowerTabIndex(last, startingTabIndex);
+    return previousElementWithLowerTabIndex(last, startingTabIndex);
 }
 
 Element* FocusController::findFocusableElement(WebFocusType type, Node& node)
 {
     // FIXME: No spacial navigation code yet.
     ASSERT(type == WebFocusTypeForward || type == WebFocusTypeBackward);
-    Node* found = findFocusableNodeAcrossFocusScopes(type, FocusNavigationScope::focusNavigationScopeOf(node), &node);
-    ASSERT(!found || found->isElementNode());
-    return toElement(found);
+    Element* found = findFocusableElementAcrossFocusScopes(type, FocusNavigationScope::focusNavigationScopeOf(node), &node);
+    return found;
 }
 
 Element* FocusController::findFocusableElement(WebFocusType type, const FocusNavigationScope& scope, Node* node)
 {
-    Node* found = (type == WebFocusTypeForward) ? nextFocusableNode(scope, node) : previousFocusableNode(scope, node);
-    ASSERT(!found || found->isElementNode());
-    return toElement(found);
+    Element* found = (type == WebFocusTypeForward) ? nextFocusableElement(scope, node) : previousFocusableElement(scope, node);
+    return found;
 }
 
 static bool relinquishesEditingFocus(const Element& element)
 {
     ASSERT(element.hasEditableStyle());
     return element.document().frame() && element.rootEditableElement();
 }
 
-static void clearSelectionIfNeeded(LocalFrame* oldFocusedFrame, LocalFrame* newFocusedFrame, Node* newFocusedNode)
+static void clearSelectionIfNeeded(LocalFrame* oldFocusedFrame, LocalFrame* newFocusedFrame, Element* newFocusedElement)
 {
     if (!oldFocusedFrame || !newFocusedFrame)
         return;
 
     if (oldFocusedFrame->document() != newFocusedFrame->document())
         return;
 
     FrameSelection& selection = oldFocusedFrame->selection();
     if (selection.isNone())
         return;
 
     bool caretBrowsing = oldFocusedFrame->settings()->caretBrowsingEnabled();
     if (caretBrowsing)
         return;
 
     Node* selectionStartNode = selection.selection().start().deprecatedNode();
-    if (selectionStartNode == newFocusedNode || selectionStartNode->isDescendantOf(newFocusedNode))
+    if (selectionStartNode == newFocusedElement || selectionStartNode->isDescendantOf(newFocusedElement))
         return;
 
     if (!enclosingTextFormControl(selectionStartNode))
         return;
 
-    if (selectionStartNode->isInShadowTree() && selectionStartNode->shadowHost() == newFocusedNode)
+    if (selectionStartNode->isInShadowTree() && selectionStartNode->shadowHost() == newFocusedElement)
         return;
 
     selection.clear();
 }
 
 bool FocusController::setFocusedElement(Element* element, PassRefPtrWillBeRawPtr<Frame> newFocusedFrame, WebFocusType type)
 {
     RefPtrWillBeRawPtr<LocalFrame> oldFocusedFrame = toLocalFrame(focusedFrame());
     RefPtrWillBeRawPtr<Document> oldDocument = oldFocusedFrame ? oldFocusedFrame->document() : nullptr;
 
@@ skipping 244 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink