Propagate focus type to plugins

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 157 matching lines @@
             if (focusedElement == document->focusedElement())
                 focusedElement->dispatchFocusOutEvent(EventTypeNames::DOMFocusOut, nullptr);
         }
     }
 
     if (LocalDOMWindow* window = document->domWindow())
         window->dispatchEvent(Event::create(focused ? EventTypeNames::focus : EventTypeNames::blur));
     if (focused && document->focusedElement()) {
         RefPtrWillBeRawPtr<Element> focusedElement(document->focusedElement());
         focusedElement->setFocus(true);
-        focusedElement->dispatchFocusEvent(0, FocusTypePage);
+        focusedElement->dispatchFocusEvent(0, WebFocusTypePage);
         if (focusedElement == document->focusedElement()) {
-            document->focusedElement()->dispatchFocusInEvent(EventTypeNames::focusin, nullptr, FocusTypePage);
+            document->focusedElement()->dispatchFocusInEvent(EventTypeNames::focusin, nullptr, WebFocusTypePage);
             if (focusedElement == document->focusedElement())
-                document->focusedElement()->dispatchFocusInEvent(EventTypeNames::DOMFocusIn, nullptr, FocusTypePage);
+                document->focusedElement()->dispatchFocusInEvent(EventTypeNames::DOMFocusIn, nullptr, WebFocusTypePage);
         }
     }
 }
 
 static inline bool hasCustomFocusLogic(const Element& element)
 {
     return element.isHTMLElement() && toHTMLElement(element).hasCustomFocusLogic();
 }
 
 #if ENABLE(ASSERT)
@@ skipping 98 matching lines @@
                     focusedElement->dispatchFocusOutEvent(EventTypeNames::DOMFocusOut, nullptr);
             }
         }
     }
 
     RefPtrWillBeRawPtr<LocalFrame> newFocusedFrame = (frame && frame->isLocalFrame()) ? toLocalFrame(frame.get()) : nullptr;
     if (newFocusedFrame && newFocusedFrame->view()) {
         RefPtrWillBeRawPtr<Document> document = newFocusedFrame->document();
         Element* focusedElement = document ? document->focusedElement() : nullptr;
         if (focusedElement) {
-            focusedElement->dispatchFocusEvent(0, FocusTypePage);
+            focusedElement->dispatchFocusEvent(0, WebFocusTypePage);
             if (focusedElement == document->focusedElement()) {
-                document->focusedElement()->dispatchFocusInEvent(EventTypeNames::focusin, nullptr, FocusTypePage);
+                document->focusedElement()->dispatchFocusInEvent(EventTypeNames::focusin, nullptr, WebFocusTypePage);
                 if (focusedElement == document->focusedElement())
-                    document->focusedElement()->dispatchFocusInEvent(EventTypeNames::DOMFocusIn, nullptr, FocusTypePage);
+                    document->focusedElement()->dispatchFocusInEvent(EventTypeNames::DOMFocusIn, nullptr, WebFocusTypePage);
             }
         }
     }
 
     setFocusedFrame(frame);
 }
 
 Frame* FocusController::focusedOrMainFrame() const
 {
     if (Frame* frame = focusedFrame())
@@ skipping 23 matching lines @@
         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);
     }
 }
 
-Node* FocusController::findFocusableNodeDecendingDownIntoFrameDocument(FocusType type, Node* node)
+Node* FocusController::findFocusableNodeDecendingDownIntoFrameDocument(WebFocusType 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())
             break;
         toLocalFrame(owner.contentFrame())->document()->updateLayoutIgnorePendingStylesheets();
         Node* foundNode = findFocusableNode(type, FocusNavigationScope::ownedByIFrame(owner), nullptr);
         if (!foundNode)
             break;
         ASSERT(node != foundNode);
         node = foundNode;
     }
     return node;
 }
 
-bool FocusController::setInitialFocus(FocusType type)
+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()) {
         Document* document = toLocalFrame(focusedOrMainFrame())->document();
         if (AXObjectCache* cache = document->existingAXObjectCache())
             cache->handleInitialFocus();
     }
 
     return didAdvanceFocus;
 }
 
-bool FocusController::advanceFocus(FocusType type, bool initialFocus)
+bool FocusController::advanceFocus(WebFocusType type, bool initialFocus)
 {
     switch (type) {
-    case FocusTypeForward:
-    case FocusTypeBackward:
+    case WebFocusTypeForward:
+    case WebFocusTypeBackward:
         return advanceFocusInDocumentOrder(type, initialFocus);
-    case FocusTypeLeft:
-    case FocusTypeRight:
-    case FocusTypeUp:
-    case FocusTypeDown:
+    case WebFocusTypeLeft:
+    case WebFocusTypeRight:
+    case WebFocusTypeUp:
+    case WebFocusTypeDown:
         return advanceFocusDirectionally(type);
     default:
         ASSERT_NOT_REACHED();
     }
 
     return false;
 }
 
-bool FocusController::advanceFocusInDocumentOrder(FocusType type, bool initialFocus)
+bool FocusController::advanceFocusInDocumentOrder(WebFocusType type, bool initialFocus)
 {
     // FIXME: Focus advancement won't work with externally rendered frames until after
     // inter-frame focus control is moved out of Blink.
     if (!focusedOrMainFrame()->isLocalFrame())
         return false;
     LocalFrame* frame = toLocalFrame(focusedOrMainFrame());
     ASSERT(frame);
     Document* document = frame->document();
 
     Node* currentNode = document->focusedElement();
@@ skipping 64 matching lines @@
     if (caretBrowsing) {
         Position position = firstPositionInOrBeforeNode(element);
         VisibleSelection newSelection(position, position, DOWNSTREAM);
         frame->selection().setSelection(newSelection);
     }
 
     element->focus(false, type);
     return true;
 }
 
-Node* FocusController::findFocusableNodeAcrossFocusScope(FocusType type, const FocusNavigationScope& scope, Node* currentNode)
+Node* FocusController::findFocusableNodeAcrossFocusScope(WebFocusType type, const FocusNavigationScope& scope, Node* currentNode)
 {
     ASSERT(!currentNode || !isNonFocusableShadowHost(*currentNode));
     Node* found;
-    if (currentNode && type == FocusTypeForward && isKeyboardFocusableShadowHost(*currentNode)) {
+    if (currentNode && type == WebFocusTypeForward && 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.
     FocusNavigationScope currentScope = scope;
     while (!found) {
         Node* owner = currentScope.owner();
         if (!owner)
             break;
         currentScope = FocusNavigationScope::focusNavigationScopeOf(*owner);
-        if (type == FocusTypeBackward && isKeyboardFocusableShadowHost(*owner)) {
+        if (type == WebFocusTypeBackward && isKeyboardFocusableShadowHost(*owner)) {
             found = owner;
             break;
         }
         found = findFocusableNodeRecursively(type, currentScope, owner);
     }
     found = findFocusableNodeDecendingDownIntoFrameDocument(type, found);
     return found;
 }
 
-Node* FocusController::findFocusableNodeRecursively(FocusType type, const FocusNavigationScope& scope, Node* start)
+Node* FocusController::findFocusableNodeRecursively(WebFocusType type, const FocusNavigationScope& scope, Node* start)
 {
     // Starting node is exclusive.
     Node* foundOrNull = findFocusableNode(type, scope, start);
     if (!foundOrNull)
         return nullptr;
     Node& found = *foundOrNull;
-    if (type == FocusTypeForward) {
+    if (type == WebFocusTypeForward) {
         if (!isNonFocusableFocusScopeOwner(found))
             return &found;
         Node* foundInInnerFocusScope = findFocusableNodeRecursively(type, FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(found), nullptr);
         return foundInInnerFocusScope ? foundInInnerFocusScope : findFocusableNodeRecursively(type, scope, &found);
     }
-    ASSERT(type == FocusTypeBackward);
+    ASSERT(type == WebFocusTypeBackward);
     if (isKeyboardFocusableShadowHost(found)) {
         Node* foundInInnerFocusScope = findFocusableNodeRecursively(type, FocusNavigationScope::ownedByShadowHost(found), nullptr);
         return foundInInnerFocusScope ? foundInInnerFocusScope : &found;
     }
     if (isNonFocusableFocusScopeOwner(found)) {
         Node* foundInInnerFocusScope = findFocusableNodeRecursively(type, FocusNavigationScope::ownedByNonFocusableFocusScopeOwner(found), nullptr);
         return foundInInnerFocusScope ? foundInInnerFocusScope :findFocusableNodeRecursively(type, scope, &found);
     }
     return &found;
 }
 
-Node* FocusController::findFocusableNode(FocusType type, const FocusNavigationScope& scope, Node* node)
+Node* FocusController::findFocusableNode(WebFocusType type, const FocusNavigationScope& scope, Node* node)
 {
-    return type == FocusTypeForward ? nextFocusableNode(scope, node) : previousFocusableNode(scope, node);
+    return type == WebFocusTypeForward ? nextFocusableNode(scope, node) : previousFocusableNode(scope, node);
 }
 
-Node* FocusController::findNodeWithExactTabIndex(Node* start, int tabIndex, FocusType type)
+Node* FocusController::findNodeWithExactTabIndex(Node* start, int tabIndex, WebFocusType type)
 {
     // Search is inclusive of start
-    for (Node* node = start; node; node = type == FocusTypeForward ? NodeTraversal::next(*node) : NodeTraversal::previous(*node)) {
+    for (Node* node = start; node; node = type == WebFocusTypeForward ? NodeTraversal::next(*node) : NodeTraversal::previous(*node)) {
         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;
@@ skipping 29 matching lines @@
     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;
             }
         } 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))
+            if (Node* winner = findNodeWithExactTabIndex(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))
         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);
+    return findNodeWithExactTabIndex(scope.rootNode(), 0, WebFocusTypeForward);
 }
 
 Node* FocusController::previousFocusableNode(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;
         }
     } else {
-        if (Node* winner = findNodeWithExactTabIndex(startingNode, startingTabIndex, FocusTypeBackward))
+        if (Node* winner = findNodeWithExactTabIndex(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);
 }
 
@@ skipping 25 matching lines @@
 
     if (!enclosingTextFormControl(selectionStartNode))
         return;
 
     if (selectionStartNode->isInShadowTree() && selectionStartNode->shadowHost() == newFocusedNode)
         return;
 
     selection.clear();
 }
 
-bool FocusController::setFocusedElement(Element* element, PassRefPtrWillBeRawPtr<Frame> newFocusedFrame, FocusType type)
+bool FocusController::setFocusedElement(Element* element, PassRefPtrWillBeRawPtr<Frame> newFocusedFrame, WebFocusType 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))
@@ skipping 44 matching lines @@
     if (frame->isLocalFrame()) {
         // Invalidate all custom scrollbars because they support the CSS
         // window-active attribute. This should be applied to the entire page so
         // we invalidate from the root FrameView instead of just the focused.
         if (FrameView* view = toLocalFrame(frame)->localFrameRoot()->document()->view())
             view->invalidateAllCustomScrollbarsOnActiveChanged();
         toLocalFrame(frame)->selection().pageActivationChanged();
     }
 }
 
-static void updateFocusCandidateIfNeeded(FocusType type, const FocusCandidate& current, FocusCandidate& candidate, FocusCandidate& closest)
+static void updateFocusCandidateIfNeeded(WebFocusType type, const FocusCandidate& current, FocusCandidate& candidate, FocusCandidate& closest)
 {
     ASSERT(candidate.visibleNode->isElementNode());
     ASSERT(candidate.visibleNode->renderer());
 
     // Ignore iframes that don't have a src attribute
     if (frameOwnerElement(candidate) && (!frameOwnerElement(candidate)->contentFrame() || candidate.rect.isEmpty()))
         return;
 
     // Ignore off screen child nodes of containers that do not scroll (overflow:hidden)
     if (candidate.isOffscreen && !canBeScrolledIntoView(type, candidate))
@@ skipping 31 matching lines @@
     if (candidate.alignment == closest.alignment) {
         if (candidate.distance < closest.distance)
             closest = candidate;
         return;
     }
 
     if (candidate.alignment > closest.alignment)
         closest = candidate;
 }
 
-void FocusController::findFocusCandidateInContainer(Node& container, const LayoutRect& startingRect, FocusType type, FocusCandidate& closest)
+void FocusController::findFocusCandidateInContainer(Node& container, const LayoutRect& startingRect, WebFocusType type, FocusCandidate& closest)
 {
     Element* focusedElement = (focusedFrame() && toLocalFrame(focusedFrame())->document()) ? toLocalFrame(focusedFrame())->document()->focusedElement() : nullptr;
 
     Element* element = ElementTraversal::firstWithin(container);
     FocusCandidate current;
     current.rect = startingRect;
     current.focusableNode = focusedElement;
     current.visibleNode = focusedElement;
 
     for (; element; element = (element->isFrameOwnerElement() || canScrollInDirection(element, type))
         ? ElementTraversal::nextSkippingChildren(*element, &container)
         : ElementTraversal::next(*element, &container)) {
         if (element == focusedElement)
             continue;
 
         if (!element->isKeyboardFocusable() && !element->isFrameOwnerElement() && !canScrollInDirection(element, type))
             continue;
 
         FocusCandidate candidate = FocusCandidate(element, type);
         if (candidate.isNull())
             continue;
 
         candidate.enclosingScrollableBox = &container;
         updateFocusCandidateIfNeeded(type, current, candidate, closest);
     }
 }
 
-bool FocusController::advanceFocusDirectionallyInContainer(Node* container, const LayoutRect& startingRect, FocusType type)
+bool FocusController::advanceFocusDirectionallyInContainer(Node* container, const LayoutRect& startingRect, WebFocusType type)
 {
     if (!container)
         return false;
 
     LayoutRect newStartingRect = startingRect;
 
     if (startingRect.isEmpty())
         newStartingRect = virtualRectForDirection(type, nodeRectInAbsoluteCoordinates(container));
 
     // Find the closest node within current container in the direction of the navigation.
@@ skipping 49 matching lines @@
     }
 
     // We found a new focus node, navigate to it.
     Element* element = toElement(focusCandidate.focusableNode);
     ASSERT(element);
 
     element->focus(false, type);
     return true;
 }
 
-bool FocusController::advanceFocusDirectionally(FocusType type)
+bool FocusController::advanceFocusDirectionally(WebFocusType type)
 {
     // FIXME: Directional focus changes don't yet work with RemoteFrames.
     if (!focusedOrMainFrame()->isLocalFrame())
         return false;
     LocalFrame* curFrame = toLocalFrame(focusedOrMainFrame());
     ASSERT(curFrame);
 
     Document* focusedDocument = curFrame->document();
     if (!focusedDocument)
         return false;
@@ skipping 29 matching lines @@
     return consumed;
 }
 
 void FocusController::trace(Visitor* visitor)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink