Change Page::m_mainFrame to be a 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 425 matching lines @@
     m_inspectorSettingsMap = adoptPtr(new SettingsMap);
 }
 
 WebViewImpl::~WebViewImpl()
 {
     ASSERT(!m_page);
 }
 
 WebLocalFrameImpl* WebViewImpl::mainFrameImpl()
 {
-    return m_page ? WebLocalFrameImpl::fromFrame(m_page->mainFrame()) : 0;
+    return m_page && m_page->mainFrame()->isLocalFrame() ? WebLocalFrameImpl::fromFrame(m_page->deprecatedLocalMainFrame()) : 0;
 }
 
 bool WebViewImpl::tabKeyCyclesThroughElements() const
 {
     ASSERT(m_page);
     return m_page->tabKeyCyclesThroughElements();
 }
 
 void WebViewImpl::setTabKeyCyclesThroughElements(bool value)
 {
@@ skipping 21 matching lines @@
         ASSERT(!m_selectPopup);
         ASSERT(!m_pagePopup);
     }
 
     m_lastMouseDownPoint = WebPoint(event.x, event.y);
 
     // Take capture on a mouse down on a plugin so we can send it mouse events.
     // If the hit node is a plugin but a scrollbar is over it don't start mouse
     // capture because it will interfere with the scrollbar receiving events.
     IntPoint point(event.x, event.y);
-    if (event.button == WebMouseEvent::ButtonLeft && !m_page->mainFrame()->view()->scrollbarAtPoint(point)) {
-        point = m_page->mainFrame()->view()->windowToContents(point);
-        HitTestResult result(m_page->mainFrame()->eventHandler().hitTestResultAtPoint(point));
+    if (event.button == WebMouseEvent::ButtonLeft && m_page->mainFrame()->isLocalFrame() && !m_page->deprecatedLocalMainFrame()->view()->scrollbarAtPoint(point)) {
+        point = m_page->deprecatedLocalMainFrame()->view()->windowToContents(point);
+        HitTestResult result(m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(point));
         Node* hitNode = result.innerNonSharedNode();
 
         if (!result.scrollbar() && hitNode && hitNode->renderer() && hitNode->renderer()->isEmbeddedObject()) {
             m_mouseCaptureNode = hitNode;
             TRACE_EVENT_ASYNC_BEGIN0("input", "capturing mouse", this);
         }
     }
 
     PageWidgetEventHandler::handleMouseDown(mainFrame, event);
 
@@ skipping 89 matching lines @@
         syntheticWheel.deltaY = delta.height;
         syntheticWheel.wheelTicksX = delta.width / tickDivisor;
         syntheticWheel.wheelTicksY = delta.height / tickDivisor;
         syntheticWheel.hasPreciseScrollingDeltas = true;
         syntheticWheel.x = m_positionOnFlingStart.x;
         syntheticWheel.y = m_positionOnFlingStart.y;
         syntheticWheel.globalX = m_globalPositionOnFlingStart.x;
         syntheticWheel.globalY = m_globalPositionOnFlingStart.y;
         syntheticWheel.modifiers = m_flingModifier;
 
-        if (m_page && m_page->mainFrame() && m_page->mainFrame()->view())
-            return handleMouseWheel(*m_page->mainFrame(), syntheticWheel);
+        if (m_page && m_page->mainFrame() && m_page->mainFrame()->isLocalFrame() && m_page->deprecatedLocalMainFrame()->view())
+            return handleMouseWheel(*m_page->deprecatedLocalMainFrame(), syntheticWheel);
     } else {
         WebGestureEvent syntheticGestureEvent;
 
         syntheticGestureEvent.type = WebInputEvent::GestureScrollUpdateWithoutPropagation;
         syntheticGestureEvent.data.scrollUpdate.deltaX = delta.width;
         syntheticGestureEvent.data.scrollUpdate.deltaY = delta.height;
         syntheticGestureEvent.x = m_positionOnFlingStart.x;
         syntheticGestureEvent.y = m_positionOnFlingStart.y;
         syntheticGestureEvent.globalX = m_globalPositionOnFlingStart.x;
         syntheticGestureEvent.globalY = m_globalPositionOnFlingStart.y;
         syntheticGestureEvent.modifiers = m_flingModifier;
         syntheticGestureEvent.sourceDevice = WebGestureDeviceTouchscreen;
 
-        if (m_page && m_page->mainFrame() && m_page->mainFrame()->view())
+        if (m_page && m_page->mainFrame() && m_page->mainFrame()->isLocalFrame() && m_page->deprecatedLocalMainFrame()->view())
             return handleGestureEvent(syntheticGestureEvent);
     }
     return false;
 }
 
 bool WebViewImpl::handleGestureEvent(const WebGestureEvent& event)
 {
     bool eventSwallowed = false;
     bool eventCancelled = false; // for disambiguation
 
@@ skipping 538 matching lines @@
     if (!node || !node->renderer())
         return false;
 
     ECursor cursor = node->renderer()->style()->cursor();
     return cursor == CURSOR_POINTER
         || (cursor == CURSOR_AUTO && frame->eventHandler().useHandCursor(node, node->isLink()));
 }
 
 Node* WebViewImpl::bestTapNode(const PlatformGestureEvent& tapEvent)
 {
-    if (!m_page || !m_page->mainFrame())
+    if (!m_page || !m_page->mainFrame() || !m_page->mainFrame()->isLocalFrame())
         return 0;
 
     Node* bestTouchNode = 0;
 
     IntPoint touchEventLocation(tapEvent.position());
-    m_page->mainFrame()->eventHandler().adjustGesturePosition(tapEvent, touchEventLocation);
+    m_page->deprecatedLocalMainFrame()->eventHandler().adjustGesturePosition(tapEvent, touchEventLocation);
 
-    IntPoint hitTestPoint = m_page->mainFrame()->view()->windowToContents(touchEventLocation);
-    HitTestResult result = m_page->mainFrame()->eventHandler().hitTestResultAtPoint(hitTestPoint, HitTestRequest::TouchEvent | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);
+    IntPoint hitTestPoint = m_page->deprecatedLocalMainFrame()->view()->windowToContents(touchEventLocation);
+    HitTestResult result = m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(hitTestPoint, HitTestRequest::TouchEvent | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);
     bestTouchNode = result.targetNode();
 
     // We might hit something like an image map that has no renderer on it
     // Walk up the tree until we have a node with an attached renderer
     while (bestTouchNode && !bestTouchNode->renderer())
         bestTouchNode = bestTouchNode->parentNode();
 
     // Check if we're in the subtree of a node with a hand cursor
     // this is the heuristic we use to determine if we show a highlight on tap
-    while (bestTouchNode && !invokesHandCursor(bestTouchNode, m_page->mainFrame()))
+    while (bestTouchNode && !invokesHandCursor(bestTouchNode, m_page->deprecatedLocalMainFrame()))
         bestTouchNode = bestTouchNode->parentNode();
 
     if (!bestTouchNode)
         return 0;
 
     // We should pick the largest enclosing node with hand cursor set.
-    while (bestTouchNode->parentNode() && invokesHandCursor(bestTouchNode->parentNode(), m_page->mainFrame()))
+    while (bestTouchNode->parentNode() && invokesHandCursor(bestTouchNode->parentNode(), toLocalFrame(m_page->mainFrame())))
         bestTouchNode = bestTouchNode->parentNode();
 
     return bestTouchNode;
 }
 
 void WebViewImpl::enableTapHighlightAtPoint(const PlatformGestureEvent& tapEvent)
 {
     Node* touchNode = bestTapNode(tapEvent);
 
     WillBeHeapVector<RawPtrWillBeMember<Node> > highlightNodes;
@@ skipping 322 matching lines @@
     return static_cast<WebViewImpl*>(page->chrome().client().webView());
 }
 
 // WebWidget ------------------------------------------------------------------
 
 void WebViewImpl::close()
 {
     if (m_page) {
         // Initiate shutdown for the entire frameset.  This will cause a lot of
         // notifications to be sent.
-        if (m_page->mainFrame())
-            m_page->mainFrame()->loader().frameDetached();
+        // FIXME: This is redundant with willBeDestroyed()... is this really
+        // needed?
+        if (m_page->mainFrame()->isLocalFrame())
+            m_page->deprecatedLocalMainFrame()->loader().frameDetached();
 
         m_page->willBeDestroyed();
         m_page.clear();
     }
 
     // Should happen after m_page.clear().
     if (m_devToolsAgent)
         m_devToolsAgent.clear();
 
     // Reset the delegate to prevent notifications being sent as we're being
@@ skipping 185 matching lines @@
 }
 
 #if OS(ANDROID)
 void WebViewImpl::paintCompositedDeprecated(WebCanvas* canvas, const WebRect& rect)
 {
     // Note: This method exists on OS(ANDROID) and will hopefully be
     //       removed once the link disambiguation feature renders using
     //       the compositor.
     ASSERT(isAcceleratedCompositingActive());
 
-    FrameView* view = page()->mainFrame()->view();
+    FrameView* view = page()->deprecatedLocalMainFrame()->view();
     PaintBehavior oldPaintBehavior = view->paintBehavior();
     view->setPaintBehavior(oldPaintBehavior | PaintBehaviorFlattenCompositingLayers);
 
     PageWidgetDelegate::paint(m_page.get(), pageOverlays(), canvas, rect, isTransparent() ? PageWidgetDelegate::Translucent : PageWidgetDelegate::Opaque);
 
     view->setPaintBehavior(oldPaintBehavior);
 }
 #endif
 
 void WebViewImpl::compositeAndReadbackAsync(WebCompositeAndReadbackAsyncCallback* callback)
 {
     ASSERT(isAcceleratedCompositingActive());
     m_layerTreeView->compositeAndReadbackAsync(callback);
 }
 
 bool WebViewImpl::isTrackingRepaints() const
 {
     if (!page())
         return false;
-    FrameView* view = page()->mainFrame()->view();
+    if (!page()->mainFrame()->isLocalFrame())
+        return false;
+    FrameView* view = page()->deprecatedLocalMainFrame()->view();
     return view->isTrackingPaintInvalidations();
 }
 
 void WebViewImpl::themeChanged()
 {
     if (!page())
         return;
-    FrameView* view = page()->mainFrame()->view();
+    if (!page()->mainFrame()->isLocalFrame())
+        return;
+    FrameView* view = page()->deprecatedLocalMainFrame()->view();
 
     WebRect damagedRect(0, 0, m_size.width, m_size.height);
     view->invalidateRect(damagedRect);
 }
 
 void WebViewImpl::enterFullScreenForElement(WebCore::Element* element)
 {
     m_fullscreenController->enterFullScreenForElement(element);
 }
 
@@ skipping 171 matching lines @@
             }
         }
         m_imeAcceptEvents = true;
     } else {
         hidePopups();
 
         // Clear focus on the currently focused frame if any.
         if (!m_page)
             return;
 
-        LocalFrame* frame = m_page->mainFrame();
+        LocalFrame* frame = m_page->mainFrame() && m_page->mainFrame()->isLocalFrame()
+            ? m_page->deprecatedLocalMainFrame() : 0;
         if (!frame)
             return;
 
         RefPtr<Frame> focusedFrame = m_page->focusController().focusedFrame();
         if (focusedFrame && focusedFrame->isLocalFrame()) {
             // Finish an ongoing composition to delete the composition node.
             if (toLocalFrame(focusedFrame.get())->inputMethodController().hasComposition()) {
                 if (m_autofillClient)
                     m_autofillClient->setIgnoreTextChanges(true);
 
@@ skipping 366 matching lines @@
 }
 
 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();
+    if (!m_page->mainFrame()->isLocalFrame())
+        return m_baseBackgroundColor;
+    FrameView* view = m_page->deprecatedLocalMainFrame()->view();
     return view->documentBackgroundColor().rgb();
 }
 
 bool WebViewImpl::caretOrSelectionRange(size_t* location, size_t* length)
 {
     const LocalFrame* focused = toLocalFrame(focusedWebCoreFrame());
     if (!focused)
         return false;
 
     PlainTextRange selectionOffsets = focused->inputMethodController().getSelectionOffsets();
@@ skipping 86 matching lines @@
 WebSettings* WebViewImpl::settings()
 {
     return settingsImpl();
 }
 
 WebString WebViewImpl::pageEncoding() const
 {
     if (!m_page)
         return WebString();
 
-    // FIXME: Is this check needed?
-    if (!m_page->mainFrame()->document()->loader())
+    if (!m_page->mainFrame()->isLocalFrame())
         return WebString();
 
-    return m_page->mainFrame()->document()->encodingName();
+    // FIXME: Is this check needed?
+    if (!m_page->deprecatedLocalMainFrame()->document()->loader())
+        return WebString();
+
+    return m_page->deprecatedLocalMainFrame()->document()->encodingName();
 }
 
 void WebViewImpl::setPageEncoding(const WebString& encodingName)
 {
     if (!m_page)
         return;
 
+    if (!m_page->mainFrame()->isLocalFrame())
+        return;
+
     // Only change override encoding, don't change default encoding.
     // Note that the new encoding must be 0 if it isn't supposed to be set.
     AtomicString newEncodingName;
     if (!encodingName.isEmpty())
         newEncodingName = encodingName;
-    m_page->mainFrame()->loader().reload(NormalReload, KURL(), newEncodingName);
+    m_page->deprecatedLocalMainFrame()->loader().reload(NormalReload, KURL(), newEncodingName);
 }
 
 WebFrame* WebViewImpl::mainFrame()
 {
+    // FIXME: This should be updated so it can return both WebLocalFrames and
+    // WebRemoteFrames. Right now, it only returns WebLocalFrames.
     return mainFrameImpl();
 }
 
 WebFrame* WebViewImpl::findFrameByName(
     const WebString& name, WebFrame* relativeToFrame)
 {
     // FIXME: Either this should only deal with WebLocalFrames or it should move to WebFrame.
     if (!relativeToFrame)
         relativeToFrame = mainFrame();
     Frame* frame = toWebLocalFrameImpl(relativeToFrame)->frame();
@@ skipping 56 matching lines @@
     // 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())
         localFrame->selection().clear();
 }
 
 void WebViewImpl::scrollFocusedNodeIntoRect(const WebRect& rect)
 {
-    LocalFrame* frame = page()->mainFrame();
+    LocalFrame* frame = page()->mainFrame() && page()->mainFrame()->isLocalFrame()
+        ? page()->deprecatedLocalMainFrame() : 0;
     Element* element = focusedElement();
     if (!frame || !frame->view() || !element)
         return;
 
     if (!m_webSettings->autoZoomFocusedNodeToLegibleScale()) {
         frame->view()->scrollElementToRect(element, IntRect(rect.x, rect.y, rect.width, rect.height));
         return;
     }
 
     float scale;
@@ skipping 309 matching lines @@
         constraints.maximumScale = m_pageScaleConstraintsSet.defaultConstraints().maximumScale;
     } else {
         constraints.minimumScale = -1;
         constraints.maximumScale = -1;
     }
     setUserAgentPageScaleConstraints(constraints);
 }
 
 void WebViewImpl::refreshPageScaleFactorAfterLayout()
 {
-    if (!mainFrame() || !page() || !page()->mainFrame() || !page()->mainFrame()->view())
+    if (!mainFrame() || !page() || !page()->mainFrame() || !page()->mainFrame()->isLocalFrame() || !page()->deprecatedLocalMainFrame()->view())
         return;
-    FrameView* view = page()->mainFrame()->view();
+    FrameView* view = page()->deprecatedLocalMainFrame()->view();
 
     updatePageDefinedViewportConstraints(mainFrameImpl()->frame()->document()->viewportDescription());
     m_pageScaleConstraintsSet.computeFinalConstraints();
 
     if (settings()->shrinksViewportContentToFit() && !m_fixedLayoutSizeLock) {
         int verticalScrollbarWidth = 0;
         if (view->verticalScrollbar() && !view->verticalScrollbar()->isOverlayScrollbar())
             verticalScrollbarWidth = view->verticalScrollbar()->width();
         m_pageScaleConstraintsSet.adjustFinalConstraintsToContentsSize(contentsSize(), verticalScrollbarWidth);
     }
@@ skipping 11 matching lines @@
     updateLayerTreeViewport();
 
     // Relayout immediately to avoid violating the rule that needsLayout()
     // isn't set at the end of a layout.
     if (view->needsLayout())
         view->layout();
 }
 
 void WebViewImpl::updatePageDefinedViewportConstraints(const ViewportDescription& description)
 {
-    if (!settings()->viewportEnabled() || !page() || (!m_size.width && !m_size.height))
+    if (!settings()->viewportEnabled() || !page() || (!m_size.width && !m_size.height) || !page()->mainFrame()->isLocalFrame())
         return;
 
-    Document* document = page()->mainFrame()->document();
+    Document* document = page()->deprecatedLocalMainFrame()->document();
 
     if (settingsImpl()->useExpandedHeuristicsForGpuRasterization()) {
         m_matchesHeuristicsForGpuRasterization = description.maxWidth == Length(DeviceWidth)
             && description.minZoom == 1.0
             && description.minZoomIsExplicit;
     } else {
         m_matchesHeuristicsForGpuRasterization = description.maxWidth == Length(DeviceWidth)
             && description.minZoom == 1.0
             && description.minZoomIsExplicit
             && description.zoom == 1.0
@@ skipping 33 matching lines @@
     m_pageScaleConstraintsSet.adjustForAndroidWebViewQuirks(adjustedDescription, defaultMinWidth.intValue(), deviceScaleFactor(), settingsImpl()->supportDeprecatedTargetDensityDPI(), page()->settings().wideViewportQuirkEnabled(), page()->settings().useWideViewport(), page()->settings().loadWithOverviewMode(), settingsImpl()->viewportMetaNonUserScalableQuirk());
     float newInitialScale = m_pageScaleConstraintsSet.pageDefinedConstraints().initialScale;
     if (oldInitialScale != newInitialScale && newInitialScale != -1) {
         m_pageScaleConstraintsSet.setNeedsReset(true);
         if (mainFrameImpl() && mainFrameImpl()->frameView())
             mainFrameImpl()->frameView()->setNeedsLayout();
     }
 
     updateMainFrameLayoutSize();
 
-    if (LocalFrame* frame = page()->mainFrame()) {
+    if (LocalFrame* frame = page()->deprecatedLocalMainFrame()) {
         if (FastTextAutosizer* textAutosizer = frame->document()->fastTextAutosizer())
             textAutosizer->updatePageInfoInAllFrames();
     }
 }
 
 void WebViewImpl::updateMainFrameLayoutSize()
 {
     if (m_fixedLayoutSizeLock || m_shouldAutoResize || !mainFrameImpl())
         return;
 
     RefPtr<FrameView> view = mainFrameImpl()->frameView();
     if (!view)
         return;
 
     WebSize layoutSize = m_size;
 
     if (settings()->viewportEnabled()) {
         layoutSize = flooredIntSize(m_pageScaleConstraintsSet.pageDefinedConstraints().layoutSize);
 
         bool textAutosizingEnabled = page()->settings().textAutosizingEnabled();
         if (textAutosizingEnabled && layoutSize.width != view->layoutSize().width()) {
-            if (TextAutosizer* textAutosizer = page()->mainFrame()->document()->textAutosizer())
+            if (TextAutosizer* textAutosizer = page()->deprecatedLocalMainFrame()->document()->textAutosizer())
                 textAutosizer->recalculateMultipliers();
         }
     }
 
     view->setLayoutSize(layoutSize);
 }
 
 IntSize WebViewImpl::contentsSize() const
 {
-    RenderView* root = page()->mainFrame()->contentRenderer();
+    if (!page()->mainFrame()->isLocalFrame())
+        return IntSize();
+    RenderView* root = page()->deprecatedLocalMainFrame()->contentRenderer();
     if (!root)
         return IntSize();
     return root->documentRect().size();
 }
 
 WebSize WebViewImpl::contentsPreferredMinimumSize()
 {
-    Document* document = m_page->mainFrame()->document();
+    Document* document = m_page->mainFrame()->isLocalFrame() ? m_page->deprecatedLocalMainFrame()->document() : 0;
     if (!document || !document->renderView() || !document->documentElement())
         return WebSize();
 
     layout();
     FontCachePurgePreventer fontCachePurgePreventer; // Required by minPreferredLogicalWidth().
     IntSize preferredMinimumSize(document->renderView()->minPreferredLogicalWidth(), document->documentElement()->scrollHeight());
     preferredMinimumSize.scale(zoomLevelToZoomFactor(zoomLevel()));
     return preferredMinimumSize;
 }
 
 float WebViewImpl::minimumPageScaleFactor() const
 {
     return m_pageScaleConstraintsSet.finalConstraints().minimumScale;
 }
 
 float WebViewImpl::maximumPageScaleFactor() const
 {
     return m_pageScaleConstraintsSet.finalConstraints().maximumScale;
 }
 
 void WebViewImpl::resetScrollAndScaleState()
 {
     // TODO: This is done by the pinchViewport().reset() call below and can be removed when
     // the new pinch path is the only one.
     setPageScaleFactor(1);
     updateMainFrameScrollPosition(IntPoint(), true);
     page()->frameHost().pinchViewport().reset();
 
+    if (!page()->mainFrame()->isLocalFrame())
+        return;
+
     // Clear out the values for the current history item. This will prevent the history item from clobbering the
     // value determined during page scale initialization, which may be less than 1.
-    page()->mainFrame()->loader().clearScrollPositionAndViewState();
+    page()->deprecatedLocalMainFrame()->loader().clearScrollPositionAndViewState();
     m_pageScaleConstraintsSet.setNeedsReset(true);
 
     // Clobber saved scales and scroll offsets.
-    if (FrameView* view = page()->mainFrame()->document()->view())
+    if (FrameView* view = page()->deprecatedLocalMainFrame()->document()->view())
         view->cacheCurrentScrollPosition();
 }
 
 void WebViewImpl::setFixedLayoutSize(const WebSize& layoutSize)
 {
-    if (!page())
+    if (!page() || !page()->mainFrame()->isLocalFrame())
         return;
 
-    LocalFrame* frame = page()->mainFrame();
+    LocalFrame* frame = page()->deprecatedLocalMainFrame();
     if (!frame)
         return;
 
     RefPtr<FrameView> view = frame->view();
     if (!view)
         return;
 
     m_fixedLayoutSizeLock = layoutSize.width || layoutSize.height;
 
     if (m_fixedLayoutSizeLock)
@@ skipping 77 matching lines @@
         // There isn't actually an image at these coordinates.  Might be because
         // the window scrolled while the context menu was open or because the page
         // changed itself between when we thought there was an image here and when
         // we actually tried to retreive the image.
         //
         // FIXME: implement a cache of the most recent HitTestResult to avoid having
         //        to do two hit tests.
         return;
     }
 
-    m_page->mainFrame()->editor().copyImage(result);
+    m_page->deprecatedLocalMainFrame()->editor().copyImage(result);
 }
 
 void WebViewImpl::saveImageAt(const WebPoint& point)
 {
     if (!m_page)
         return;
 
     KURL url = hitTestResultForWindowPos(point).absoluteImageURL();
 
     if (url.isEmpty())
         return;
 
     ResourceRequest request(url);
-    m_page->mainFrame()->loader().client()->loadURLExternally(
+    m_page->deprecatedLocalMainFrame()->loader().client()->loadURLExternally(
         request, NavigationPolicyDownloadTo, WebString());
 }
 
 void WebViewImpl::dragSourceEndedAt(
     const WebPoint& clientPoint,
     const WebPoint& screenPoint,
     WebDragOperation operation)
 {
     PlatformMouseEvent pme(clientPoint,
                            screenPoint,
                            LeftButton, PlatformEvent::MouseMoved, 0, false, false, false,
                            false, 0);
-    m_page->mainFrame()->eventHandler().dragSourceEndedAt(pme,
+    m_page->deprecatedLocalMainFrame()->eventHandler().dragSourceEndedAt(pme,
         static_cast<DragOperation>(operation));
 }
 
 void WebViewImpl::dragSourceSystemDragEnded()
 {
     // It's possible for us to get this callback while not doing a drag if
     // it's from a previous page that got unloaded.
     if (m_doingDragAndDrop) {
         m_page->dragController().dragEnded();
         m_doingDragAndDrop = false;
@@ skipping 162 matching lines @@
     if (point.x == -1 || point.y == -1) {
         m_page->inspectorController().inspect(0);
     } else {
         HitTestRequest::HitTestRequestType hitType = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::AllowChildFrameContent;
         HitTestRequest request(hitType);
 
         WebMouseEvent dummyEvent;
         dummyEvent.type = WebInputEvent::MouseDown;
         dummyEvent.x = point.x;
         dummyEvent.y = point.y;
-        IntPoint transformedPoint = PlatformMouseEventBuilder(m_page->mainFrame()->view(), dummyEvent).position();
-        HitTestResult result(m_page->mainFrame()->view()->windowToContents(transformedPoint));
-        m_page->mainFrame()->contentRenderer()->hitTest(request, result);
+        IntPoint transformedPoint = PlatformMouseEventBuilder(m_page->deprecatedLocalMainFrame()->view(), dummyEvent).position();
+        HitTestResult result(m_page->deprecatedLocalMainFrame()->view()->windowToContents(transformedPoint));
+        m_page->deprecatedLocalMainFrame()->contentRenderer()->hitTest(request, result);
         Node* node = result.innerNode();
-        if (!node && m_page->mainFrame()->document())
-            node = m_page->mainFrame()->document()->documentElement();
+        if (!node && m_page->deprecatedLocalMainFrame()->document())
+            node = m_page->deprecatedLocalMainFrame()->document()->documentElement();
         m_page->inspectorController().inspect(node);
     }
 }
 
 WebString WebViewImpl::inspectorSettings() const
 {
     return m_inspectorSettings;
 }
 
 void WebViewImpl::setInspectorSettings(const WebString& settings)
@@ skipping 112 matching lines @@
 
 void WebViewImpl::setBaseBackgroundColor(WebColor color)
 {
     layout();
 
     if (m_baseBackgroundColor == color)
         return;
 
     m_baseBackgroundColor = color;
 
-    if (m_page->mainFrame())
-        m_page->mainFrame()->view()->setBaseBackgroundColor(color);
+    if (m_page->mainFrame() && m_page->mainFrame()->isLocalFrame())
+        m_page->deprecatedLocalMainFrame()->view()->setBaseBackgroundColor(color);
 
     updateLayerTreeBackgroundColor();
 }
 
 void WebViewImpl::setIsActive(bool active)
 {
     if (page())
         page()->focusController().setActive(active);
 }
 
@@ skipping 50 matching lines @@
     m_linkHighlights.clear();
     endActiveFlingAnimation();
     m_userGestureObserved = false;
 }
 
 void WebViewImpl::willInsertBody(WebLocalFrameImpl* webframe)
 {
     if (webframe != mainFrameImpl())
         return;
 
+    if (!m_page->mainFrame()->isLocalFrame())
+        return;
+
     // If we get to the <body> tag and we have no pending stylesheet and import load, we
     // can be fairly confident we'll have something sensible to paint soon and
     // can turn off deferred commits.
-    if (m_page->mainFrame()->document()->isRenderingReady())
+    if (m_page->deprecatedLocalMainFrame()->document()->isRenderingReady())
         resumeTreeViewCommits();
 }
 
 void WebViewImpl::resumeTreeViewCommits()
 {
     if (m_layerTreeViewCommitsDeferred) {
         if (m_layerTreeView)
             m_layerTreeView->setDeferCommits(false);
         m_layerTreeViewCommitsDeferred = false;
     }
@@ skipping 86 matching lines @@
 {
     if (m_pageOverlays && m_pageOverlays->remove(overlay) && m_pageOverlays->empty())
         m_pageOverlays = nullptr;
 }
 
 void WebViewImpl::setOverlayLayer(WebCore::GraphicsLayer* layer)
 {
     if (!m_rootGraphicsLayer)
         return;
 
+    if (!m_page->mainFrame()->isLocalFrame())
+        return;
+
     if (pinchVirtualViewportEnabled()) {
-        m_page->mainFrame()->view()->renderView()->compositor()->setOverlayLayer(layer);
+        m_page->deprecatedLocalMainFrame()->view()->renderView()->compositor()->setOverlayLayer(layer);
         return;
     }
 
     // FIXME(bokan): This path goes away after virtual viewport pinch is enabled everywhere.
     if (!m_rootTransformLayer)
-        m_rootTransformLayer = m_page->mainFrame()->view()->renderView()->compositor()->ensureRootTransformLayer();
+        m_rootTransformLayer = m_page->deprecatedLocalMainFrame()->view()->renderView()->compositor()->ensureRootTransformLayer();
 
     if (m_rootTransformLayer) {
         if (layer->parent() != m_rootTransformLayer)
             m_rootTransformLayer->addChild(layer);
     }
 }
 
 Element* WebViewImpl::focusedElement() const
 {
     Frame* frame = m_page->focusController().focusedFrame();
     if (!frame || !frame->isLocalFrame())
         return 0;
 
     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);
+    if (!m_page->mainFrame()->isLocalFrame())
+        return HitTestResult();
+    IntPoint docPoint(m_page->deprecatedLocalMainFrame()->view()->windowToContents(pos));
+    return m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(docPoint, HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);
 }
 
 void WebViewImpl::setTabsToLinks(bool enable)
 {
     m_tabsToLinks = enable;
 }
 
 bool WebViewImpl::tabsToLinks() const
 {
     return m_tabsToLinks;
@@ skipping 77 matching lines @@
 
 WebCore::GraphicsLayerFactory* WebViewImpl::graphicsLayerFactory() const
 {
     return m_graphicsLayerFactory.get();
 }
 
 WebCore::RenderLayerCompositor* WebViewImpl::compositor() const
 {
     if (!page()
         || !page()->mainFrame()
-        || !page()->mainFrame()->document()
-        || !page()->mainFrame()->document()->renderView())
+        || !page()->mainFrame()->isLocalFrame()
+        || !page()->deprecatedLocalMainFrame()->document()
+        || !page()->deprecatedLocalMainFrame()->document()->renderView())
         return 0;
-    return page()->mainFrame()->document()->renderView()->compositor();
+    return page()->deprecatedLocalMainFrame()->document()->renderView()->compositor();
 }
 
 void WebViewImpl::registerForAnimations(WebLayer* layer)
 {
     if (m_layerTreeView)
         m_layerTreeView->registerForAnimations(layer);
 }
 
 WebCore::GraphicsLayer* WebViewImpl::rootGraphicsLayer()
 {
@@ skipping 70 matching lines @@
             // FIXME: It appears that only unittests, <webview> and android webview
             // printing can hit this code. We should make them not hit this code and
             // then delete this else clause and allowsBrokenNullLayerTreeView.
             // crbug.com/322276 and crbug.com/364716.
             ASSERT(m_client->allowsBrokenNullLayerTreeView());
             m_isAcceleratedCompositingActive = false;
             m_page->settings().setAcceleratedCompositingEnabled(false);
             m_page->updateAcceleratedCompositingSettings();
         }
     }
-    if (page())
-        page()->mainFrame()->view()->setClipsRepaints(!m_isAcceleratedCompositingActive);
+    if (page() && page()->mainFrame()->isLocalFrame())
+        page()->deprecatedLocalMainFrame()->view()->setClipsRepaints(!m_isAcceleratedCompositingActive);
 }
 
 void WebViewImpl::updateMainFrameScrollPosition(const IntPoint& scrollPosition, bool programmaticScroll)
 {
-    FrameView* frameView = page()->mainFrame()->view();
+    if (!page()->mainFrame()->isLocalFrame())
+        return;
+
+    FrameView* frameView = page()->deprecatedLocalMainFrame()->view();
     if (!frameView)
         return;
 
     if (frameView->scrollPosition() == scrollPosition)
         return;
 
     bool oldProgrammaticScroll = frameView->inProgrammaticScroll();
     frameView->setInProgrammaticScroll(programmaticScroll);
     frameView->notifyScrollPositionChanged(scrollPosition);
     frameView->setInProgrammaticScroll(oldProgrammaticScroll);
@@ skipping 61 matching lines @@
 
 void WebViewImpl::updateRootLayerTransform()
 {
     // If we don't have a root graphics layer, we won't bother trying to find
     // or update the transform layer.
     if (!m_rootGraphicsLayer)
         return;
 
     // FIXME(bokan): m_rootTransformLayer is always set here in pinch virtual viewport. This can go away once
     // that's default everywhere.
-    if (!m_rootTransformLayer)
-        m_rootTransformLayer = m_page->mainFrame()->view()->renderView()->compositor()->ensureRootTransformLayer();
+    if (!m_rootTransformLayer && m_page->mainFrame()->isLocalFrame())
+        m_rootTransformLayer = m_page->deprecatedLocalMainFrame()->view()->renderView()->compositor()->ensureRootTransformLayer();
 
     if (m_rootTransformLayer) {
         WebCore::TransformationMatrix transform;
         transform.translate(m_rootLayerOffset.width, m_rootLayerOffset.height);
         transform = transform.scale(m_rootLayerScale);
         m_rootTransformLayer->setTransform(transform);
     }
 }
 
 bool WebViewImpl::detectContentOnTouch(const WebPoint& position)
@@ skipping 90 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