Implement sequential focus navigation for OOPIF.

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 25 matching lines @@
 #include "core/dom/Range.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/EditingUtilities.h" // For firstPositionInOrBeforeNode
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
+#include "core/frame/RemoteFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLAreaElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/html/HTMLShadowElement.h"
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/input/EventHandler.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
@@ skipping 627 matching lines @@
             cache->handleInitialFocus();
     }
 
     return didAdvanceFocus;
 }
 
 bool FocusController::advanceFocus(WebFocusType type, bool initialFocus, InputDeviceCapabilities* sourceCapabilities)
 {
     switch (type) {
     case WebFocusTypeForward:
-    case WebFocusTypeBackward:
-        return advanceFocusInDocumentOrder(type, initialFocus, sourceCapabilities);
+    case WebFocusTypeBackward: {
+        // We should never hit this when a RemoteFrame is focused, since the key
+        // event that initiated focus advancement should've been routed to that
+        // frame's process from the beginning.
+        LocalFrame* startingFrame = toLocalFrame(focusedOrMainFrame());
+        return advanceFocusInDocumentOrder(startingFrame, nullptr, type, initialFocus, sourceCapabilities);
+    }
     case WebFocusTypeLeft:
     case WebFocusTypeRight:
     case WebFocusTypeUp:
     case WebFocusTypeDown:
         return advanceFocusDirectionally(type);
     default:
         ASSERT_NOT_REACHED();
     }
 
     return false;
 }
 
-bool FocusController::advanceFocusInDocumentOrder(WebFocusType type, bool initialFocus, InputDeviceCapabilities* sourceCapabilities)
+bool FocusController::advanceFocusAcrossFrames(WebFocusType type, RemoteFrame* from, LocalFrame* to, InputDeviceCapabilities* sourceCapabilities)
 {
-    // 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());
+    // If we are shifting focus from a child frame to its parent, the
+    // child frame has no more focusable elements, and we should continue
+    // looking for focusable elements in the parent, starting from the <iframe>
+    // element of the child frame.
+    Node* startingNode = nullptr;
+    if (from->tree().parent() == to) {
+        ASSERT(from->owner()->isLocal());
+        startingNode = toHTMLFrameOwnerElement(from->owner());
+    }
+
+    return advanceFocusInDocumentOrder(to, startingNode, type, false, sourceCapabilities);
+}
+
+bool FocusController::advanceFocusInDocumentOrder(LocalFrame* frame, Node* startingNode, WebFocusType type, bool initialFocus, InputDeviceCapabilities* sourceCapabilities)
+{
     ASSERT(frame);
     Document* document = frame->document();
 
-    Node* currentNode = document->focusedElement();
+    Node* currentNode = startingNode;
+    if (!currentNode)
+        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().anchorNode();
 
     document->updateLayoutIgnorePendingStylesheets();
 
     RefPtrWillBeRawPtr<Element> element = findFocusableElementAcrossFocusScopes(type, FocusNavigationScope::focusNavigationScopeOf(currentNode ? *currentNode : *document), currentNode);
 
     if (!element) {
+        // If there's a RemoteFrame on the ancestor chain, we need to continue
+        // searching for focusable elements there.
+        if (frame->localFrameRoot() != frame->tree().top()) {
+            document->clearFocusedElement();
+            toRemoteFrame(frame->localFrameRoot()->tree().parent())->advanceFocus(type, frame->localFrameRoot());
+            return true;
+        }
+
         // 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->clearFocusedElement();
             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;

[dcheng, 2015/12/04 23:11:01]

I think we should be able to remove this.

[alexmos, 2015/12/05 00:07:45]

Done.  Indeed, focus wrapping to Chrome should only ever happen from the main
frame's process.  Good catch!

         element = findFocusableElementRecursively(type, FocusNavigationScope::focusNavigationScopeOf(*m_page->deprecatedLocalMainFrame()->document()), nullptr);

[dcheng, 2015/12/04 23:11:01]

and we can just make this toLocalFrame(m_page->mainFrame()) or something.

[alexmos, 2015/12/05 00:07:45]

Done.

         element = findFocusableElementDescendingDownIntoFrameDocument(type, element.get());
 
         if (!element)
             return false;
     }
 
     ASSERT(element);
 
     if (element == document->focusedElement()) {
         // Focus wrapped around to the same node.
         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)
     // 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.
@@ skipping 313 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink