Make some arguments of FocusController functions references.

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 76 matching lines @@
     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())
         return frame->deprecatedLocalOwner();
     return nullptr;
 }
 
-FocusNavigationScope FocusNavigationScope::focusNavigationScopeOf(Node* node)
+FocusNavigationScope FocusNavigationScope::focusNavigationScopeOf(Node& node)
 {
-    ASSERT(node);
-    Node* root = node;
-    for (Node* n = node; n; n = n->parentNode())
+    Node* root = &node;
+    for (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(Node& node)
 {
-    ASSERT(node);
     if (isShadowHost(node))
         return FocusNavigationScope::ownedByShadowHost(node);
-    ASSERT(isShadowInsertionPointFocusScopeOwner(*node));
+    ASSERT(isShadowInsertionPointFocusScopeOwner(node));
     return FocusNavigationScope::ownedByShadowInsertionPoint(toHTMLShadowElement(node));
 }
 
-FocusNavigationScope FocusNavigationScope::ownedByShadowHost(Node* node)
+FocusNavigationScope FocusNavigationScope::ownedByShadowHost(Node& node)
 {
     ASSERT(isShadowHost(node));
-    return FocusNavigationScope(toElement(node)->shadow()->youngestShadowRoot());
+    return FocusNavigationScope(toElement(node).shadow()->youngestShadowRoot());
 }
 
-FocusNavigationScope FocusNavigationScope::ownedByIFrame(HTMLFrameOwnerElement* frame)
+FocusNavigationScope FocusNavigationScope::ownedByIFrame(HTMLFrameOwnerElement& frame)
 {
-    ASSERT(frame && frame->contentFrame() && frame->contentFrame()->isLocalFrame());
-    return FocusNavigationScope(toLocalFrame(frame->contentFrame())->document());
+    ASSERT(frame.contentFrame());
+    ASSERT(frame.contentFrame()->isLocalFrame());
+    return FocusNavigationScope(toLocalFrame(frame.contentFrame())->document());
 }
 
-FocusNavigationScope FocusNavigationScope::ownedByShadowInsertionPoint(HTMLShadowElement* shadowInsertionPoint)
+FocusNavigationScope FocusNavigationScope::ownedByShadowInsertionPoint(HTMLShadowElement& shadowInsertionPoint)
 {
-    ASSERT(isShadowInsertionPointFocusScopeOwner(*shadowInsertionPoint));
-    return FocusNavigationScope(shadowInsertionPoint->olderShadowRoot());
+    ASSERT(isShadowInsertionPointFocusScopeOwner(shadowInsertionPoint));
+    return FocusNavigationScope(shadowInsertionPoint.olderShadowRoot());
 }
 
 static inline void dispatchEventsOnWindowAndFocusedNode(Document* document, bool focused)
 {
     // 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.
     // https://bugs.webkit.org/show_bug.cgi?id=27105
 
     // Do not fire events while modal dialogs are up.  See https://bugs.webkit.org/show_bug.cgi?id=33962
     if (Page* page = document->page()) {
@@ skipping 19 matching lines @@
         focusedElement->setFocus(true);
         focusedElement->dispatchFocusEvent(0, FocusTypePage);
         if (focusedElement == document->focusedElement()) {
             document->focusedElement()->dispatchFocusInEvent(EventTypeNames::focusin, nullptr, FocusTypePage);
             if (focusedElement == document->focusedElement())
                 document->focusedElement()->dispatchFocusInEvent(EventTypeNames::DOMFocusIn, nullptr, FocusTypePage);
         }
     }
 }
 
-static inline bool hasCustomFocusLogic(Element* element)
+static inline bool hasCustomFocusLogic(const Element& element)
 {
-    return element->isHTMLElement() && toHTMLElement(element)->hasCustomFocusLogic();
+    return element.isHTMLElement() && toHTMLElement(element).hasCustomFocusLogic();
 }
 
 #if ENABLE(ASSERT)
-static inline bool isNonFocusableShadowHost(Node* node)
+static inline bool isNonFocusableShadowHost(const Node& node)
 {
-    ASSERT(node);
-    if (!node->isElementNode())
+    if (!node.isElementNode())
         return false;
-    Element* element = toElement(node);
-    return !element->isFocusable() && isShadowHost(element) && !hasCustomFocusLogic(element);
+    const Element& element = toElement(node);
+    return !element.isFocusable() && isShadowHost(element) && !hasCustomFocusLogic(element);
 }
 #endif
 
-static inline bool isNonKeyboardFocusableShadowHost(Node* node)
+static inline bool isNonKeyboardFocusableShadowHost(const Node& node)
 {
-    ASSERT(node);
-    if (!node->isElementNode())
+    if (!node.isElementNode())
         return false;
-    Element* element = toElement(node);
-    return !element->isKeyboardFocusable() && isShadowHost(element) && !hasCustomFocusLogic(element);
+    const Element& element = toElement(node);
+    return !element.isKeyboardFocusable() && isShadowHost(element) && !hasCustomFocusLogic(element);
 }
 
-static inline bool isKeyboardFocusableShadowHost(Node* node)
+static inline bool isKeyboardFocusableShadowHost(const Node& node)
 {
-    ASSERT(node);
-    if (!node->isElementNode())
+    if (!node.isElementNode())
         return false;
-    Element* element = toElement(node);
-    return element->isKeyboardFocusable() && isShadowHost(element) && !hasCustomFocusLogic(element);
+    const Element& element = toElement(node);
+    return element.isKeyboardFocusable() && isShadowHost(element) && !hasCustomFocusLogic(element);
 }
 
-static inline bool isNonFocusableFocusScopeOwner(Node* node)
+static inline bool isNonFocusableFocusScopeOwner(Node& node)
 {
-    ASSERT(node);
-    return isNonKeyboardFocusableShadowHost(node) || isShadowInsertionPointFocusScopeOwner(*node);
+    return isNonKeyboardFocusableShadowHost(node) || isShadowInsertionPointFocusScopeOwner(node);
 }
 
-static inline int adjustedTabIndex(Node* node)
+static inline int adjustedTabIndex(Node& node)
 {
-    ASSERT(node);
-    return isNonFocusableFocusScopeOwner(node) ? 0 : node->tabIndex();
+    return isNonFocusableFocusScopeOwner(node) ? 0 : node.tabIndex();
 }
 
-static inline bool shouldVisit(Node* node)
+static inline bool shouldVisit(Node& node)
 {
-    ASSERT(node);
-    return (node->isElementNode() && toElement(node)->isKeyboardFocusable()) || isNonFocusableFocusScopeOwner(node);
+    return (node.isElementNode() && toElement(node).isKeyboardFocusable()) || isNonFocusableFocusScopeOwner(node);
 }
 
 FocusController::FocusController(Page* page)
     : m_page(page)
     , m_isActive(false)
     , m_isFocused(false)
     , m_isChangingFocusedFrame(false)
 {
 }
 
@@ skipping 104 matching lines @@
         dispatchEventsOnWindowAndFocusedNode(toLocalFrame(m_focusedFrame.get())->document(), focused);
     }
 }
 
 Node* FocusController::findFocusableNodeDecendingDownIntoFrameDocument(FocusType type, Node* node)
 {
     // The node we found might be a HTMLFrameOwnerElement, so descend down the tree until we find either:
     // 1) a focusable node, or
     // 2) the deepest-nested HTMLFrameOwnerElement.
     while (node && node->isFrameOwnerElement()) {
-        HTMLFrameOwnerElement* owner = toHTMLFrameOwnerElement(node);
-        if (!owner->contentFrame() || !owner->contentFrame()->isLocalFrame())
+        HTMLFrameOwnerElement& owner = toHTMLFrameOwnerElement(*node);
+        if (!owner.contentFrame() || !owner.contentFrame()->isLocalFrame())
             break;
         Node* foundNode = findFocusableNode(type, FocusNavigationScope::ownedByIFrame(owner), nullptr);
         if (!foundNode)
             break;
         ASSERT(node != foundNode);
         node = foundNode;
     }
     return node;
 }
 
@@ skipping 43 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 = findFocusableNodeAcrossFocusScope(type, FocusNavigationScope::focusNavigationScopeOf(currentNode ? currentNode : document), currentNode);
+    RefPtrWillBeRawPtr<Node> node = findFocusableNodeAcrossFocusScope(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 (!initialFocus && m_page->chrome().canTakeFocus(type)) {
             document->setFocusedElement(nullptr);
             setFocusedFrame(nullptr);
             m_page->chrome().takeFocus(type);
             return true;
         }
 
         // Chrome doesn't want focus, so we should wrap focus.
         if (!m_page->mainFrame()->isLocalFrame())
             return false;
-        node = findFocusableNodeRecursively(type, FocusNavigationScope::focusNavigationScopeOf(m_page->deprecatedLocalMainFrame()->document()), nullptr);
+        node = findFocusableNodeRecursively(type, FocusNavigationScope::focusNavigationScopeOf(*m_page->deprecatedLocalMainFrame()->document()), nullptr);
         node = findFocusableNodeDecendingDownIntoFrameDocument(type, node.get());
 
         if (!node)
             return false;
     }
 
     ASSERT(node);
 
     if (node == document->focusedElement())
         // Focus wrapped around to the same node.
@@ skipping 33 matching lines @@
         VisibleSelection newSelection(position, position, DOWNSTREAM);
         frame->selection().setSelection(newSelection);
     }
 
     element->focus(false, type);
     return true;
 }
 
 Node* FocusController::findFocusableNodeAcrossFocusScope(FocusType type, FocusNavigationScope scope, Node* currentNode)
 {
-    ASSERT(!currentNode || !isNonFocusableShadowHost(currentNode));
+    ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
     Node* found;
-    if (currentNode && type == FocusTypeForward && isKeyboardFocusableShadowHost(currentNode)) {
-        Node* foundInInnerFocusScope = findFocusableNodeRecursively(type, FocusNavigationScope::ownedByShadowHost(currentNode), nullptr);
+    if (currentNode && type == FocusTypeForward && isKeyboardFocusableShadowHost(*currentNode)) {
+        Node* foundInInnerFocusScope = findFocusableNodeRecursively(type, FocusNavigationScope::ownedByShadowHost(*currentNode), nullptr);
         found = foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableNodeRecursively(type, scope, currentNode);
     } else {
         found = findFocusableNodeRecursively(type, scope, currentNode);
     }
 
     // If there's no focusable node to advance to, move up the focus scopes until we find one.
     while (!found) {
         Node* owner = scope.owner();
         if (!owner)
             break;
-        scope = FocusNavigationScope::focusNavigationScopeOf(owner);
-        if (type == FocusTypeBackward && isKeyboardFocusableShadowHost(owner)) {
+        scope = FocusNavigationScope::focusNavigationScopeOf(*owner);
+        if (type == FocusTypeBackward && isKeyboardFocusableShadowHost(*owner)) {
             found = owner;
             break;
         }
         found = findFocusableNodeRecursively(type, scope, owner);
     }
     found = findFocusableNodeDecendingDownIntoFrameDocument(type, found);
     return found;
 }
 
 Node* FocusController::findFocusableNodeRecursively(FocusType type, FocusNavigationScope scope, Node* start)
 {
     // Starting node is exclusive.
-    Node* found = findFocusableNode(type, scope, start);
-    if (!found)
+    Node* foundOrNull = findFocusableNode(type, scope, start);
+    if (!foundOrNull)
         return nullptr;
+    Node& found = *foundOrNull;
     if (type == FocusTypeForward) {
         if (!isNonFocusableFocusScopeOwner(found))
-            return found;
+            return &found;
         Node* foundInInnerFocusScope = findFocusableNodeRecursively(type, FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(found), nullptr);
-        return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableNodeRecursively(type, scope, found);
+        return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableNodeRecursively(type, scope, &found);
     }
     ASSERT(type == FocusTypeBackward);
     if (isKeyboardFocusableShadowHost(found)) {
         Node* foundInInnerFocusScope = findFocusableNodeRecursively(type, FocusNavigationScope::ownedByShadowHost(found), nullptr);
-        return foundInInnerFocusScope ? foundInInnerFocusScope : found;
+        return foundInInnerFocusScope ? foundInInnerFocusScope : &found;
     }
     if (isNonFocusableFocusScopeOwner(found)) {
         Node* foundInInnerFocusScope = findFocusableNodeRecursively(type, FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(found), nullptr);
-        return foundInInnerFocusScope ? foundInInnerFocusScope :findFocusableNodeRecursively(type, scope, found);
+        return foundInInnerFocusScope ? foundInInnerFocusScope :findFocusableNodeRecursively(type, scope, &found);
     }
-    return found;
+    return &found;
 }
 
 Node* FocusController::findFocusableNode(FocusType type, FocusNavigationScope scope, Node* node)
 {
     return type == FocusTypeForward ? nextFocusableNode(scope, node) : previousFocusableNode(scope, node);
 }
 
 Node* FocusController::findNodeWithExactTabIndex(Node* start, int tabIndex, FocusType type)
 {
     // Search is inclusive of start
     for (Node* node = start; node; node = type == FocusTypeForward ? NodeTraversal::next(*node) : NodeTraversal::previous(*node)) {
-        if (shouldVisit(node) && adjustedTabIndex(node) == tabIndex)
+        if (shouldVisit(*node) && adjustedTabIndex(*node) == tabIndex)
             return node;
     }
     return nullptr;
 }
 
 static Node* nextNodeWithGreaterTabIndex(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) {
+        int currentTabIndex = adjustedTabIndex(node);
+        if (shouldVisit(node) && currentTabIndex > tabIndex && currentTabIndex < winningTabIndex) {
             winner = &node;
             winningTabIndex = currentTabIndex;
         }
     }
 
     return winner;
 }
 
 static Node* previousNodeWithLowerTabIndex(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) {
+        int currentTabIndex = adjustedTabIndex(*node);
+        if (shouldVisit(*node) && currentTabIndex < tabIndex && currentTabIndex > winningTabIndex) {
             winner = node;
             winningTabIndex = currentTabIndex;
         }
     }
     return winner;
 }
 
 Node* FocusController::nextFocusableNode(FocusNavigationScope scope, Node* start)
 {
     if (start) {
-        int tabIndex = adjustedTabIndex(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)
+                if (shouldVisit(node) && adjustedTabIndex(node) >= 0)
                     return &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, FocusTypeForward))
                 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 (Node* winner = nextNodeWithGreaterTabIndex(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, FocusTypeForward);
 }
 
 Node* FocusController::previousFocusableNode(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);
+        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)
+            if (shouldVisit(*node) && adjustedTabIndex(*node) >= 0)
                 return node;
         }
     } else {
         if (Node* winner = findNodeWithExactTabIndex(startingNode, startingTabIndex, FocusTypeBackward))
             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);
 }
 
-static bool relinquishesEditingFocus(Node *node)
+static bool relinquishesEditingFocus(const Element& element)
 {
-    ASSERT(node);
-    ASSERT(node->hasEditableStyle());
-    return node->document().frame() && node->rootEditableElement();
+    ASSERT(element.hasEditableStyle());
+    return element.document().frame() && element.rootEditableElement();
 }
 
 static void clearSelectionIfNeeded(LocalFrame* oldFocusedFrame, LocalFrame* newFocusedFrame, Node* newFocusedNode)
 {
     if (!oldFocusedFrame || !newFocusedFrame)
         return;
 
     if (oldFocusedFrame->document() != newFocusedFrame->document())
         return;
 
@@ skipping 21 matching lines @@
 bool FocusController::setFocusedElement(Element* element, PassRefPtrWillBeRawPtr<Frame> newFocusedFrame, FocusType type)
 {
     RefPtrWillBeRawPtr<LocalFrame> oldFocusedFrame = toLocalFrame(focusedFrame());
     RefPtrWillBeRawPtr<Document> oldDocument = oldFocusedFrame ? oldFocusedFrame->document() : nullptr;
 
     Element* oldFocusedElement = oldDocument ? oldDocument->focusedElement() : nullptr;
     if (element && oldFocusedElement == element)
         return true;
 
     // FIXME: Might want to disable this check for caretBrowsing
-    if (oldFocusedElement && oldFocusedElement->isRootEditableElement() && !relinquishesEditingFocus(oldFocusedElement))
+    if (oldFocusedElement && oldFocusedElement->isRootEditableElement() && !relinquishesEditingFocus(*oldFocusedElement))
         return false;
 
     m_page->chrome().client().willSetInputMethodState();
 
     RefPtrWillBeRawPtr<Document> newDocument = nullptr;
     if (element)
         newDocument = &element->document();
     else if (newFocusedFrame && newFocusedFrame->isLocalFrame())
         newDocument = toLocalFrame(newFocusedFrame.get())->document();
 
@@ skipping 228 matching lines @@
     return consumed;
 }
 
 void FocusController::trace(Visitor* visitor)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink