Convert HTMLFrameOwnerElement and FocusController to use Frame.

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 500 matching lines @@
 {
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return;
 
     m_page->contextMenuController().clearContextMenu();
 
     PlatformMouseEventBuilder pme(mainFrameImpl()->frameView(), event);
 
     // Find the right target frame. See issue 1186900.
     HitTestResult result = hitTestResultForWindowPos(pme.position());
-    LocalFrame* targetFrame;
+    Frame* targetFrame;
     if (result.innerNonSharedNode())
         targetFrame = result.innerNonSharedNode()->document().frame();
     else
         targetFrame = m_page->focusController().focusedOrMainFrame();
 
+    if (!targetFrame->isLocalFrame())
+        return;
+
+    LocalFrame* targetLocalFrame = toLocalFrame(targetFrame);
+
 #if OS(WIN)
-    targetFrame->view()->setCursor(pointerCursor());
+    targetLocalFrame->view()->setCursor(pointerCursor());
 #endif
 
     m_contextMenuAllowed = true;
-    targetFrame->eventHandler().sendContextMenuEvent(pme);
+    targetLocalFrame->eventHandler().sendContextMenuEvent(pme);
     m_contextMenuAllowed = false;
     // Actually showing the context menu is handled by the ContextMenuClient
     // implementation...
 }
 
 void WebViewImpl::handleMouseUp(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     PageWidgetEventHandler::handleMouseUp(mainFrame, event);
 
 #if OS(WIN)
@@ skipping 320 matching lines @@
         return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
     if (m_pagePopup) {
         m_pagePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
         // We need to ignore the next Char event after this otherwise pressing
         // enter when selecting an item in the popup will go to the page.
         if (WebInputEvent::RawKeyDown == event.type)
             m_suppressNextKeypressEvent = true;
         return true;
     }
 
-    RefPtr<LocalFrame> frame = focusedWebCoreFrame();
+    // TODO(kenrb): Handle the remote frame case. Possibly move eventHandler() to Frame?
+    RefPtr<LocalFrame> frame = toLocalFrame(focusedWebCoreFrame());
     if (!frame)
         return false;
 
 #if !OS(MACOSX)
     const WebInputEvent::Type contextMenuTriggeringEventType =
 #if OS(WIN)
         WebInputEvent::KeyUp;
 #else
         WebInputEvent::RawKeyDown;
 #endif
@@ skipping 34 matching lines @@
     bool suppress = m_suppressNextKeypressEvent;
     m_suppressNextKeypressEvent = false;
 
     // If there is a select popup, it should be the one processing the event,
     // not the page.
     if (m_selectPopup)
         return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
     if (m_pagePopup)
         return m_pagePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
 
-    LocalFrame* frame = focusedWebCoreFrame();
+    LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
     if (!frame)
         return suppress;
 
     EventHandler& handler = frame->eventHandler();
 
     PlatformKeyboardEventBuilder evt(event);
     if (!evt.isCharacterKey())
         return true;
 
     // Accesskeys are triggered by char events and can't be suppressed.
@@ skipping 324 matching lines @@
 {
     // The contextMenuController() holds onto the last context menu that was
     // popped up on the page until a new one is created. We need to clear
     // this menu before propagating the event through the DOM so that we can
     // detect if we create a new menu for this event, since we won't create
     // a new menu if the DOM swallows the event and the defaultEventHandler does
     // not run.
     page()->contextMenuController().clearContextMenu();
 
     m_contextMenuAllowed = true;
-    LocalFrame* focusedFrame = page()->focusController().focusedOrMainFrame();
-    bool handled = focusedFrame->eventHandler().sendContextMenuEventForKey();
+    Frame* focusedFrame = page()->focusController().focusedOrMainFrame();
+    if (!focusedFrame->isLocalFrame())
+        return false;
+    bool handled = toLocalFrame(focusedFrame)->eventHandler().sendContextMenuEventForKey();
     m_contextMenuAllowed = false;
     return handled;
 }
 #endif
 
 bool WebViewImpl::keyEventDefault(const WebKeyboardEvent& event)
 {
-    LocalFrame* frame = focusedWebCoreFrame();
+    LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());

[dcheng, 2014/03/17 18:17:44]

Hmm... is focusedWebCoreFrame() eventually going to return LocalFrame once
'process focus tracking' is in Chrome?

[kenrb, 2014/03/18 20:01:19]

I don't know. There might be reasons to return focused RemoteFrames sometimes,
but this code should not be reachable when a RemoteFrame has focus.

     if (!frame)
         return false;
 
     switch (event.type) {
     case WebInputEvent::Char:
         if (event.windowsKeyCode == VKEY_SPACE) {
             int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR : VKEY_NEXT);
             return scrollViewWithKeyboard(keyCode, event.modifiers);
         }
         break;
@@ skipping 92 matching lines @@
 }
 
 void WebViewImpl::hideSelectPopup()
 {
     if (m_selectPopup)
         m_selectPopup->hidePopup();
 }
 
 bool WebViewImpl::bubblingScroll(ScrollDirection scrollDirection, ScrollGranularity scrollGranularity)
 {
-    LocalFrame* frame = focusedWebCoreFrame();
+    LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
     if (!frame)
         return false;
 
     return frame->eventHandler().bubblingScroll(scrollDirection, scrollGranularity);
 }
 
 void WebViewImpl::popupOpened(PopupContainer* popupContainer)
 {
     ASSERT(!m_selectPopup);
     m_selectPopup = popupContainer;
@@ skipping 32 matching lines @@
 {
     ASSERT(popup);
     WebPagePopupImpl* popupImpl = toWebPagePopupImpl(popup);
     ASSERT(m_pagePopup.get() == popupImpl);
     if (m_pagePopup.get() != popupImpl)
         return;
     m_pagePopup->closePopup();
     m_pagePopup = nullptr;
 }
 
-LocalFrame* WebViewImpl::focusedWebCoreFrame() const
+Frame* WebViewImpl::focusedWebCoreFrame() const
 {
     return m_page ? m_page->focusController().focusedOrMainFrame() : 0;
 }
 
 WebViewImpl* WebViewImpl::fromPage(Page* page)
 {
     if (!page)
         return 0;
     return static_cast<WebViewImpl*>(page->chrome().client().webView());
 }
@@ skipping 359 matching lines @@
 {
     TRACE_EVENT_ASYNC_END0("input", "capturing mouse", this);
     m_mouseCaptureNode = nullptr;
 }
 
 void WebViewImpl::setFocus(bool enable)
 {
     m_page->focusController().setFocused(enable);
     if (enable) {
         m_page->focusController().setActive(true);
-        RefPtr<LocalFrame> focusedFrame = m_page->focusController().focusedFrame();
-        if (focusedFrame) {
-            Element* element = focusedFrame->document()->focusedElement();
-            if (element && focusedFrame->selection().selection().isNone()) {
+        RefPtr<Frame> focusedFrame = m_page->focusController().focusedFrame();
+        if (focusedFrame && focusedFrame->isLocalFrame()) {
+            LocalFrame* localFrame = toLocalFrame(focusedFrame.get());
+            Element* element = localFrame->document()->focusedElement();
+            if (element && localFrame->selection().selection().isNone()) {
                 // If the selection was cleared while the WebView was not
                 // focused, then the focus element shows with a focus ring but
                 // no caret and does respond to keyboard inputs.
                 if (element->isTextFormControl()) {
                     element->updateFocusAppearance(true);
                 } else if (element->isContentEditable()) {
                     // updateFocusAppearance() selects all the text of
                     // contentseditable DIVs. So we set the selection explicitly
                     // instead. Note that this has the side effect of moving the
                     // caret back to the beginning of the text.
                     Position position(element, 0, Position::PositionIsOffsetInAnchor);
-                    focusedFrame->selection().setSelection(VisibleSelection(position, SEL_DEFAULT_AFFINITY));
+                    localFrame->selection().setSelection(VisibleSelection(position, SEL_DEFAULT_AFFINITY));
                 }
             }
         }
         m_imeAcceptEvents = true;
     } else {
         hidePopups();
 
         // Clear focus on the currently focused frame if any.
         if (!m_page)
             return;
 
         LocalFrame* frame = m_page->mainFrame();
         if (!frame)
             return;
 
-        RefPtr<LocalFrame> focusedFrame = m_page->focusController().focusedFrame();
-        if (focusedFrame) {
+        RefPtr<Frame> focusedFrame = m_page->focusController().focusedFrame();
+        if (focusedFrame && focusedFrame->isLocalFrame()) {
             // Finish an ongoing composition to delete the composition node.
-            if (focusedFrame->inputMethodController().hasComposition()) {
+            if (toLocalFrame(focusedFrame.get())->inputMethodController().hasComposition()) {
                 if (m_autofillClient)
                     m_autofillClient->setIgnoreTextChanges(true);
 
-                focusedFrame->inputMethodController().confirmComposition();
+                toLocalFrame(focusedFrame.get())->inputMethodController().confirmComposition();
 
                 if (m_autofillClient)
                     m_autofillClient->setIgnoreTextChanges(false);
             }
             m_imeAcceptEvents = false;
         }
     }
 }
 
 bool WebViewImpl::setComposition(
     const WebString& text,
     const WebVector<WebCompositionUnderline>& underlines,
     int selectionStart,
     int selectionEnd)
 {
-    LocalFrame* focused = focusedWebCoreFrame();
+    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused || !m_imeAcceptEvents)
         return false;
 
     if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
         return plugin->setComposition(text, underlines, selectionStart, selectionEnd);
 
     // The input focus has been moved to another WebWidget object.
     // We should use this |editor| object only to complete the ongoing
     // composition.
     InputMethodController& inputMethodController = focused->inputMethodController();
@@ skipping 45 matching lines @@
     return confirmComposition(WebString(), selectionBehavior);
 }
 
 bool WebViewImpl::confirmComposition(const WebString& text)
 {
     return confirmComposition(text, DoNotKeepSelection);
 }
 
 bool WebViewImpl::confirmComposition(const WebString& text, ConfirmCompositionBehavior selectionBehavior)
 {
-    LocalFrame* focused = focusedWebCoreFrame();
+    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused || !m_imeAcceptEvents)
         return false;
 
     if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused))
         return plugin->confirmComposition(text, selectionBehavior);
 
     return focused->inputMethodController().confirmCompositionOrInsertText(text, selectionBehavior == KeepSelection ? InputMethodController::KeepSelection : InputMethodController::DoNotKeepSelection);
 }
 
 bool WebViewImpl::compositionRange(size_t* location, size_t* length)
 {
-    LocalFrame* focused = focusedWebCoreFrame();
+    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused || !m_imeAcceptEvents)
         return false;
 
     RefPtr<Range> range = focused->inputMethodController().compositionRange();
     if (!range)
         return false;
 
     Element* editable = focused->selection().rootEditableElementOrDocumentElement();
     ASSERT(editable);
     PlainTextRange plainTextRange(PlainTextRange::create(*editable, *range.get()));
     if (plainTextRange.isNull())
         return false;
     *location = plainTextRange.start();
     *length = plainTextRange.length();
     return true;
 }
 
 WebTextInputInfo WebViewImpl::textInputInfo()
 {
     WebTextInputInfo info;
 
-    LocalFrame* focused = focusedWebCoreFrame();
+    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return info;
 
     FrameSelection& selection = focused->selection();
     Node* node = selection.selection().rootEditableElement();
     if (!node)
         return info;
 
     info.inputMode = inputModeOfFocusedElement();
 
@@ skipping 105 matching lines @@
     if (element->hasTagName(HTMLNames::textareaTag)) {
         const HTMLTextAreaElement* textarea = toHTMLTextAreaElement(element);
         return textarea->fastGetAttribute(HTMLNames::inputmodeAttr).lower();
     }
 
     return WebString();
 }
 
 bool WebViewImpl::selectionBounds(WebRect& anchor, WebRect& focus) const
 {
-    const LocalFrame* frame = focusedWebCoreFrame();
+    const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
     if (!frame)
         return false;
     FrameSelection& selection = frame->selection();
 
     if (selection.isCaret()) {
         anchor = focus = selection.absoluteCaretBounds();
     } else {
         RefPtr<Range> selectedRange = selection.toNormalizedRange();
         if (!selectedRange)
             return false;
@@ skipping 23 matching lines @@
     if (!selection.selection().isBaseFirst())
         std::swap(anchor, focus);
     return true;
 }
 
 InputMethodContext* WebViewImpl::inputMethodContext()
 {
     if (!m_imeAcceptEvents)
         return 0;
 
-    LocalFrame* focusedFrame = focusedWebCoreFrame();
+    LocalFrame* focusedFrame = toLocalFrame(focusedWebCoreFrame());
     if (!focusedFrame)
         return 0;
 
     Element* target = focusedFrame->document()->focusedElement();
     if (target && target->hasInputMethodContext())
         return &target->inputMethodContext();
 
     return 0;
 }
 
@@ skipping 18 matching lines @@
 }
 
 void WebViewImpl::didHideCandidateWindow()
 {
     if (InputMethodContext* context = inputMethodContext())
         context->dispatchCandidateWindowHideEvent();
 }
 
 bool WebViewImpl::selectionTextDirection(WebTextDirection& start, WebTextDirection& end) const
 {
-    const LocalFrame* frame = focusedWebCoreFrame();
+    const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
     if (!frame)
         return false;
     FrameSelection& selection = frame->selection();
     if (!selection.toNormalizedRange())
         return false;
     start = selection.start().primaryDirection() == RTL ? WebTextDirectionRightToLeft : WebTextDirectionLeftToRight;
     end = selection.end().primaryDirection() == RTL ? WebTextDirectionRightToLeft : WebTextDirectionLeftToRight;
     return true;
 }
 
 bool WebViewImpl::isSelectionAnchorFirst() const
 {
-    if (const LocalFrame* frame = focusedWebCoreFrame())
+    if (const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame()))
         return frame->selection().selection().isBaseFirst();
     return false;
 }
 
 bool WebViewImpl::setEditableSelectionOffsets(int start, int end)
 {
-    const LocalFrame* focused = focusedWebCoreFrame();
+    const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return false;
     return focused->inputMethodController().setEditableSelectionOffsets(PlainTextRange(start, end));
 }
 
 bool WebViewImpl::setCompositionFromExistingText(int compositionStart, int compositionEnd, const WebVector<WebCompositionUnderline>& underlines)
 {
-    const LocalFrame* focused = focusedWebCoreFrame();
+    const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return false;
 
     if (!focused->editor().canEdit())
         return false;
 
     InputMethodController& inputMethodController = focused->inputMethodController();
     inputMethodController.cancelComposition();
 
     if (compositionStart == compositionEnd)
         return true;
 
     inputMethodController.setCompositionFromExistingText(CompositionUnderlineVectorBuilder(underlines), compositionStart, compositionEnd);
 
     return true;
 }
 
 WebVector<WebCompositionUnderline> WebViewImpl::compositionUnderlines() const
 {
-    const LocalFrame* focused = focusedWebCoreFrame();
+    const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return WebVector<WebCompositionUnderline>();
     const Vector<CompositionUnderline>& underlines = focused->inputMethodController().customCompositionUnderlines();
     WebVector<WebCompositionUnderline> results(underlines.size());
     for (size_t index = 0; index < underlines.size(); ++index) {
         CompositionUnderline underline = underlines[index];
         results[index] = WebCompositionUnderline(underline.startOffset, underline.endOffset, static_cast<WebColor>(underline.color.rgb()), underline.thick);
     }
     return results;
 }
 
 void WebViewImpl::extendSelectionAndDelete(int before, int after)
 {
-    LocalFrame* focused = focusedWebCoreFrame();
+    LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return;
     if (WebPlugin* plugin = focusedPluginIfInputMethodSupported(focused)) {
         plugin->extendSelectionAndDelete(before, after);
         return;
     }
     focused->inputMethodController().extendSelectionAndDelete(before, after);
 }
 
 bool WebViewImpl::isSelectionEditable() const
 {
-    if (const LocalFrame* frame = focusedWebCoreFrame())
+    if (const LocalFrame* frame = toLocalFrame(focusedWebCoreFrame()))
         return frame->selection().isContentEditable();
     return false;
 }
 
 WebColor WebViewImpl::backgroundColor() const
 {
     if (isTransparent())
         return Color::transparent;
     if (!m_page)
         return m_baseBackgroundColor;
     if (!m_page->mainFrame())
         return m_baseBackgroundColor;
     FrameView* view = m_page->mainFrame()->view();
     return view->documentBackgroundColor().rgb();
 }
 
 bool WebViewImpl::caretOrSelectionRange(size_t* location, size_t* length)
 {
-    const LocalFrame* focused = focusedWebCoreFrame();
+    const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return false;
 
     PlainTextRange selectionOffsets = focused->inputMethodController().getSelectionOffsets();
     if (selectionOffsets.isNull())
         return false;
 
     *location = selectionOffsets.start();
     *length = selectionOffsets.length();
     return true;
 }
 
 void WebViewImpl::setTextDirection(WebTextDirection direction)
 {
     // The Editor::setBaseWritingDirection() function checks if we can change
     // the text direction of the selected node and updates its DOM "dir"
     // attribute and its CSS "direction" property.
     // So, we just call the function as Safari does.
-    const LocalFrame* focused = focusedWebCoreFrame();
+    const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return;
 
     Editor& editor = focused->editor();
     if (!editor.canEdit())
         return;
 
     switch (direction) {
     case WebTextDirectionDefault:
         editor.setBaseWritingDirection(NaturalWritingDirection);
@@ skipping 116 matching lines @@
 {
     if (!relativeToFrame)
         relativeToFrame = mainFrame();
     LocalFrame* frame = toWebFrameImpl(relativeToFrame)->frame();
     frame = frame->tree().find(name);
     return WebFrameImpl::fromFrame(frame);
 }
 
 WebFrame* WebViewImpl::focusedFrame()
 {
-    return WebFrameImpl::fromFrame(focusedWebCoreFrame());
+    return WebFrameImpl::fromFrame(toLocalFrame(focusedWebCoreFrame()));
 }
 
 void WebViewImpl::setFocusedFrame(WebFrame* frame)
 {
     if (!frame) {
         // Clears the focused frame if any.
-        if (LocalFrame* focusedFrame = focusedWebCoreFrame())
-            focusedFrame->selection().setFocused(false);
+        Frame* focusedFrame = focusedWebCoreFrame();
+        if (focusedFrame && focusedFrame->isLocalFrame())
+            toLocalFrame(focusedFrame)->selection().setFocused(false);
         return;
     }
     LocalFrame* webcoreFrame = toWebFrameImpl(frame)->frame();
     webcoreFrame->page()->focusController().setFocusedFrame(webcoreFrame);
 }
 
 void WebViewImpl::setInitialFocus(bool reverse)
 {
     if (!m_page)
         return;
-    LocalFrame* frame = page()->focusController().focusedOrMainFrame();
-    if (Document* document = frame->document())
-        document->setFocusedElement(nullptr);
+    Frame* frame = page()->focusController().focusedOrMainFrame();
+    if (frame->isLocalFrame()) {
+        if (Document* document = toLocalFrame(frame)->document())
+            document->setFocusedElement(nullptr);
+    }
     page()->focusController().setInitialFocus(reverse ? FocusTypeBackward : FocusTypeForward);
 }
 
 void WebViewImpl::clearFocusedElement()
 {
-    RefPtr<LocalFrame> frame = focusedWebCoreFrame();
-    if (!frame)
+    RefPtr<Frame> frame = focusedWebCoreFrame();
+    if (!frame || !frame->isLocalFrame())
         return;
 
-    RefPtr<Document> document = frame->document();
+    LocalFrame* localFrame = toLocalFrame(frame.get());
+
+    RefPtr<Document> document = localFrame->document();
     if (!document)
         return;
 
     RefPtr<Element> oldFocusedElement = document->focusedElement();
 
     // Clear the focused node.
     document->setFocusedElement(nullptr);
 
     if (!oldFocusedElement)
         return;
 
     // If a text field has focus, we need to make sure the selection controller
     // knows to remove selection from it. Otherwise, the text field is still
     // processing keyboard events even though focus has been moved to the page and
     // keystrokes get eaten as a result.
     if (oldFocusedElement->isContentEditable() || oldFocusedElement->isTextFormControl())
-        frame->selection().clear();
+        localFrame->selection().clear();
 }
 
 void WebViewImpl::scrollFocusedNodeIntoView()
 {
     if (Element* element = focusedElement())
         element->scrollIntoViewIfNeeded(true);
 }
 
 void WebViewImpl::scrollFocusedNodeIntoRect(const WebRect& rect)
 {
@@ skipping 814 matching lines @@
     m_page->contextMenuController().clearContextMenu();
 }
 
 void WebViewImpl::showContextMenu()
 {
     if (!page())
         return;
 
     page()->contextMenuController().clearContextMenu();
     m_contextMenuAllowed = true;
-    if (LocalFrame* focusedFrame = page()->focusController().focusedOrMainFrame())
+    if (LocalFrame* focusedFrame = toLocalFrame(page()->focusController().focusedOrMainFrame()))
         focusedFrame->eventHandler().sendContextMenuEventForKey();
     m_contextMenuAllowed = false;
 }
 
 WebString WebViewImpl::getSmartClipData(WebRect rect)
 {
-    LocalFrame* frame = focusedWebCoreFrame();
+    LocalFrame* frame = toLocalFrame(focusedWebCoreFrame());
     if (!frame)
         return WebString();
     return WebCore::SmartClip(frame).dataForRect(rect).toString();
 }
 
 void WebViewImpl::hidePopups()
 {
     hideSelectPopup();
     if (m_pagePopup)
         closePagePopup(m_pagePopup.get());
@@ skipping 212 matching lines @@
 
 NotificationPresenterImpl* WebViewImpl::notificationPresenterImpl()
 {
     if (!m_notificationPresenter.isInitialized() && m_client)
         m_notificationPresenter.initialize(m_client->notificationPresenter());
     return &m_notificationPresenter;
 }
 
 Element* WebViewImpl::focusedElement() const
 {
-    LocalFrame* frame = m_page->focusController().focusedFrame();
-    if (!frame)
+    Frame* frame = m_page->focusController().focusedFrame();
+    if (!frame || !frame->isLocalFrame())
         return 0;
 
-    Document* document = frame->document();
+    Document* document = toLocalFrame(frame)->document();
     if (!document)
         return 0;
 
     return document->focusedElement();
 }
 
 HitTestResult WebViewImpl::hitTestResultForWindowPos(const IntPoint& pos)
 {
     IntPoint docPoint(m_page->mainFrame()->view()->windowToContents(pos));
     return m_page->mainFrame()->eventHandler().hitTestResultAtPoint(docPoint, HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);
@@ skipping 390 matching lines @@
     const PageScaleConstraints& constraints = m_pageScaleConstraintsSet.pageDefinedConstraints();
 
     if (!mainFrameImpl() || !mainFrameImpl()->frameView())
         return false;
 
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 } // namespace blink