Convert HTMLFrameOwnerElement and FocusController to use Frame.

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 69 matching lines @@
     return &m_rootTreeScope->rootNode();
 }
 
 Element* FocusNavigationScope::owner() const
 {
     Node* root = rootNode();
     if (root->isShadowRoot()) {
         ShadowRoot* shadowRoot = toShadowRoot(root);
         return shadowRoot->isYoungest() ? shadowRoot->host() : shadowRoot->shadowInsertionPointOfYoungerShadowRoot();
     }
-    if (LocalFrame* frame = root->document().frame())
+    if (Frame* frame = root->document().frame())
         return frame->ownerElement();
     return 0;
 }
 
 FocusNavigationScope FocusNavigationScope::focusNavigationScopeOf(Node* node)
 {
     ASSERT(node);
     Node* root = node;
     for (Node* n = node; n; n = n->parentNode())
         root = n;
@@ skipping 123 matching lines @@
     , m_isChangingFocusedFrame(false)
     , m_containingWindowIsVisible(false)
 {
 }
 
 PassOwnPtr<FocusController> FocusController::create(Page* page)
 {
     return adoptPtr(new FocusController(page));
 }
 
-void FocusController::setFocusedFrame(PassRefPtr<LocalFrame> frame)
+void FocusController::setFocusedFrame(PassRefPtr<Frame> frame)
 {
     ASSERT(!frame || frame->page() == m_page);
     if (m_focusedFrame == frame || m_isChangingFocusedFrame)
         return;
 
     m_isChangingFocusedFrame = true;
 
-    RefPtr<LocalFrame> oldFrame = m_focusedFrame;
-    RefPtr<LocalFrame> newFrame = frame;
+    RefPtr<LocalFrame> oldFrame = (m_focusedFrame && m_focusedFrame->isLocalFrame()) ? toLocalFrame(m_focusedFrame.get()) : 0;

[eseidel, 2014/03/27 19:56:41]

Sometimes we really want a version of these "to" functions which returns null if
the is-check is false.

+    RefPtr<LocalFrame> newFrame = (frame && frame->isLocalFrame()) ? toLocalFrame(frame.get()) : 0;
 
-    m_focusedFrame = newFrame;
+    m_focusedFrame = frame.get();
 
     // Now that the frame is updated, fire events and update the selection focused states of both frames.
     if (oldFrame && oldFrame->view()) {
         oldFrame->selection().setFocused(false);
         oldFrame->domWindow()->dispatchEvent(Event::create(EventTypeNames::blur));
     }
 
     if (newFrame && newFrame->view() && isFocused()) {
         newFrame->selection().setFocused(true);
         newFrame->domWindow()->dispatchEvent(Event::create(EventTypeNames::focus));
     }
 
     m_isChangingFocusedFrame = false;
 
     m_page->chrome().client().focusedFrameChanged(newFrame.get());
 }
 
-LocalFrame* FocusController::focusedOrMainFrame() const
+Frame* FocusController::focusedOrMainFrame() const
 {
-    if (LocalFrame* frame = focusedFrame())
+    if (Frame* frame = focusedFrame())
         return frame;
     return m_page->mainFrame();
 }
 
 void FocusController::setFocused(bool focused)
 {
     if (isFocused() == focused)
         return;
 
     m_isFocused = focused;
 
-    if (!m_isFocused)
-        focusedOrMainFrame()->eventHandler().stopAutoscroll();
+    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->view()) {
-        m_focusedFrame->selection().setFocused(focused);
-        dispatchEventsOnWindowAndFocusedNode(m_focusedFrame->document(), focused);
+    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)
 {
     // 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);
@@ skipping 34 matching lines @@
         return advanceFocusDirectionally(type);
     default:
         ASSERT_NOT_REACHED();
     }
 
     return false;
 }
 
 bool FocusController::advanceFocusInDocumentOrder(FocusType type, bool initialFocus)
 {
-    LocalFrame* frame = focusedOrMainFrame();
+    // 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();
     // 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();
 
@@ skipping 265 matching lines @@
             if (Node* shadowAncestorNode = root->deprecatedShadowAncestorNode()) {
                 if (!shadowAncestorNode->hasTagName(inputTag) && !shadowAncestorNode->hasTagName(textareaTag))
                     return;
             }
         }
     }
 
     selection.clear();
 }
 
-bool FocusController::setFocusedElement(Element* element, PassRefPtr<LocalFrame> newFocusedFrame, FocusType type)
+bool FocusController::setFocusedElement(Element* element, PassRefPtr<Frame> newFocusedFrame, FocusType type)
 {
-    RefPtr<LocalFrame> oldFocusedFrame = focusedFrame();
+    RefPtr<LocalFrame> oldFocusedFrame = toLocalFrame(focusedFrame());
     RefPtr<Document> oldDocument = oldFocusedFrame ? oldFocusedFrame->document() : 0;
 
     Element* oldFocusedElement = oldDocument ? oldDocument->focusedElement() : 0;
     if (element && oldFocusedElement == element)
         return true;
 
     // FIXME: Might want to disable this check for caretBrowsing
     if (oldFocusedElement && oldFocusedElement->isRootEditableElement() && !relinquishesEditingFocus(oldFocusedElement))
         return false;
 
     m_page->chrome().client().willSetInputMethodState();
 
     RefPtr<Document> newDocument;
     if (element)
         newDocument = &element->document();
     else if (newFocusedFrame)
         newDocument = newFocusedFrame->document();
 
     if (newDocument && oldDocument == newDocument && newDocument->focusedElement() == element)
         return true;
 
-    clearSelectionIfNeeded(oldFocusedFrame.get(), newFocusedFrame.get(), element);
+    clearSelectionIfNeeded(oldFocusedFrame.get(), toLocalFrame(newFocusedFrame.get()), element);
 
     if (oldDocument && oldDocument != newDocument)
         oldDocument->setFocusedElement(nullptr);
 
     if (newFocusedFrame && !newFocusedFrame->page()) {
         setFocusedFrame(nullptr);
         return false;
     }
     setFocusedFrame(newFocusedFrame);
 
@@ skipping 11 matching lines @@
 void FocusController::setActive(bool active)
 {
     if (m_isActive == active)
         return;
 
     m_isActive = active;
 
     if (FrameView* view = m_page->mainFrame()->view())
         view->updateControlTints();
 
-    focusedOrMainFrame()->selection().pageActivationChanged();
+    toLocalFrame(focusedOrMainFrame())->selection().pageActivationChanged();
 }
 
 static void contentAreaDidShowOrHide(ScrollableArea* scrollableArea, bool didShow)
 {
     if (didShow)
         scrollableArea->contentAreaDidShow();
     else
         scrollableArea->contentAreaDidHide();
 }
 
@@ skipping 170 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)
 {
-    LocalFrame* curFrame = focusedOrMainFrame();
+    // 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;
 
     Element* focusedElement = focusedDocument->focusedElement();
     Node* container = focusedDocument;
 
     if (container->isDocumentNode())
@@ skipping 18 matching lines @@
         startingRect = nodeRectInAbsoluteCoordinates(container, true /* ignore border */);
         container = scrollableEnclosingBoxOrParentFrameForNodeInDirection(type, container);
         if (container && container->isDocumentNode())
             toDocument(container)->updateLayoutIgnorePendingStylesheets();
     } while (!consumed && container);
 
     return consumed;
 }
 
 } // namespace WebCore