Change Page::m_mainFrame to be a Frame.

Source/core/page/scrolling/ScrollingCoordinator.cpp

 /*
  * Copyright (C) 2011 Apple 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:
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 81 matching lines @@
     , m_lastMainThreadScrollingReasons(0)
 {
 }
 
 ScrollingCoordinator::~ScrollingCoordinator()
 {
 }
 
 bool ScrollingCoordinator::touchHitTestingEnabled() const
 {
-    RenderView* contentRenderer = m_page->mainFrame()->contentRenderer();
-    Settings* settings = m_page->mainFrame()->document()->settings();
+    if (!m_page->mainFrame()->isLocalFrame())
+        return false;
+    RenderView* contentRenderer = toLocalFrame(m_page->mainFrame())->contentRenderer();
+    Settings* settings = m_page->mainFrame()->settings();
     return RuntimeEnabledFeatures::touchEnabled() && settings->compositorTouchHitTesting() && contentRenderer && contentRenderer->usesCompositing();
 }
 
 void ScrollingCoordinator::setShouldHandleScrollGestureOnMainThreadRegion(const Region& region)
 {
-    if (WebLayer* scrollLayer = toWebLayer(m_page->mainFrame()->view()->layerForScrolling())) {
+    if (!m_page->mainFrame()->isLocalFrame())
+        return;
+    if (WebLayer* scrollLayer = toWebLayer(toLocalFrame(m_page->mainFrame())->view()->layerForScrolling())) {
         Vector<IntRect> rects = region.rects();
         WebVector<WebRect> webRects(rects.size());
         for (size_t i = 0; i < rects.size(); ++i)
             webRects[i] = rects[i];
         scrollLayer->setNonFastScrollableRegion(webRects);
     }
 }
 
 void ScrollingCoordinator::notifyLayoutUpdated()
 {
     m_scrollGestureRegionIsDirty = true;
     m_touchEventTargetRectsAreDirty = true;
     m_shouldScrollOnMainThreadDirty = true;
 }
 
 void ScrollingCoordinator::updateAfterCompositingChangeIfNeeded()
 {
+    // FIXME: This function has a lot of dependencies on main frame always being
+    // local, so just early return if that's not the case.
+    if (!m_page->mainFrame()->isLocalFrame())
+        return;
+
     if (!shouldUpdateAfterCompositingChange())
         return;
 
     TRACE_EVENT0("input", "ScrollingCoordinator::updateAfterCompositingChangeIfNeeded");
 
     if (m_scrollGestureRegionIsDirty) {
         // Compute the region of the page where we can't handle scroll gestures and mousewheel events
         // on the impl thread. This currently includes:
         // 1. All scrollable areas, such as subframes, overflow divs and list boxes, whose composited
         // scrolling are not enabled. We need to do this even if the frame view whose layout was updated
         // is not the main frame.
         // 2. Resize control areas, e.g. the small rect at the right bottom of div/textarea/iframe when
         // CSS property "resize" is enabled.
         // 3. Plugin areas.
-        Region shouldHandleScrollGestureOnMainThreadRegion = computeShouldHandleScrollGestureOnMainThreadRegion(m_page->mainFrame(), IntPoint());
+        Region shouldHandleScrollGestureOnMainThreadRegion = computeShouldHandleScrollGestureOnMainThreadRegion(toLocalFrame(m_page->mainFrame()), IntPoint());
         setShouldHandleScrollGestureOnMainThreadRegion(shouldHandleScrollGestureOnMainThreadRegion);
         m_scrollGestureRegionIsDirty = false;
     }
 
     if (m_touchEventTargetRectsAreDirty) {
         updateTouchEventTargetRectsIfNeeded();
         m_touchEventTargetRectsAreDirty = false;
     }
 
-    FrameView* frameView = m_page->mainFrame()->view();
+    FrameView* frameView = toLocalFrame(m_page->mainFrame())->view();
     bool frameIsScrollable = frameView && frameView->isScrollable();
     if (m_shouldScrollOnMainThreadDirty || m_wasFrameScrollable != frameIsScrollable) {
         setShouldUpdateScrollLayerPositionOnMainThread(mainThreadScrollingReasons());
         m_shouldScrollOnMainThreadDirty = false;
     }
     m_wasFrameScrollable = frameIsScrollable;
 
     // The mainFrame view doesn't get included in the FrameTree below, so we
     // update its size separately.
     if (WebLayer* scrollingWebLayer = frameView ? toWebLayer(frameView->layerForScrolling()) : 0) {
         scrollingWebLayer->setBounds(frameView->contentsSize());
         // If there is a fullscreen element, set the scroll clip layer to 0 so main frame won't scroll.
-        Document* mainFrameDocument = m_page->mainFrame()->document();
+        Document* mainFrameDocument = toLocalFrame(m_page->mainFrame())->document();
         Element* fullscreenElement = FullscreenElementStack::fullscreenElementFrom(*mainFrameDocument);
         if (fullscreenElement && fullscreenElement != mainFrameDocument->documentElement())
             scrollingWebLayer->setScrollClipLayer(0);
         else
             scrollingWebLayer->setScrollClipLayer(toWebLayer(frameView->layerForContainer()));
     }
 
     const FrameTree& tree = m_page->mainFrame()->tree();
     for (const Frame* child = tree.firstChild(); child; child = child->tree().nextSibling()) {
         if (!child->isLocalFrame())
@@ skipping 141 matching lines @@
 
     if (scrollbarGraphicsLayer) {
         Scrollbar* scrollbar = orientation == HorizontalScrollbar ? scrollableArea->horizontalScrollbar() : scrollableArea->verticalScrollbar();
         if (scrollbar->isCustomScrollbar()) {
             detachScrollbarLayer(scrollbarGraphicsLayer);
             return;
         }
 
         WebScrollbarLayer* scrollbarLayer = getWebScrollbarLayer(scrollableArea, orientation);
         if (!scrollbarLayer) {
-            Settings* settings = m_page->mainFrame()->document()->settings();
+            Settings* settings = m_page->mainFrame()->settings();
 
             OwnPtr<WebScrollbarLayer> webScrollbarLayer;
             if (settings->useSolidColorScrollbars()) {
                 ASSERT(RuntimeEnabledFeatures::overlayScrollbarsEnabled());
                 webScrollbarLayer = createSolidColorScrollbarLayer(orientation, scrollbar->theme()->thumbThickness(scrollbar), scrollbar->theme()->trackPosition(scrollbar), scrollableArea->shouldPlaceVerticalScrollbarOnLeft());
             } else {
                 webScrollbarLayer = createScrollbarLayer(scrollbar);
             }
             scrollbarLayer = addWebScrollbarLayer(scrollableArea, orientation, webScrollbarLayer.release());
         }
@@ skipping 266 matching lines @@
 
     // Ensure we have an entry for each composited layer that previously had rects (so that old
     // ones will get cleared out). Note that ideally we'd track this on GraphicsLayer instead of
     // RenderLayer, but we have no good hook into the lifetime of a GraphicsLayer.
     for (HashSet<const RenderLayer*>::iterator it = oldLayersWithTouchRects.begin(); it != oldLayersWithTouchRects.end(); ++it) {
         if (!layerRects.contains(*it))
             layerRects.add(*it, Vector<LayoutRect>());
     }
 
     GraphicsLayerHitTestRects graphicsLayerRects;
-    projectRectsToGraphicsLayerSpace(m_page->mainFrame(), layerRects, graphicsLayerRects);
+    projectRectsToGraphicsLayerSpace(toLocalFrame(m_page->mainFrame()), layerRects, graphicsLayerRects);
 
     for (GraphicsLayerHitTestRects::const_iterator iter = graphicsLayerRects.begin(); iter != graphicsLayerRects.end(); ++iter) {
         const GraphicsLayer* graphicsLayer = iter->key;
         WebVector<WebRect> webRects(iter->value.size());
         for (size_t i = 0; i < iter->value.size(); ++i)
             webRects[i] = enclosingIntRect(iter->value[i]);
         graphicsLayer->platformLayer()->setTouchEventHandlerRegion(webRects);
     }
 }
 
 void ScrollingCoordinator::touchEventTargetRectsDidChange()
 {
     if (!touchHitTestingEnabled())
         return;
 
     // Wait until after layout to update.
-    if (!m_page->mainFrame()->view() || m_page->mainFrame()->view()->needsLayout())
+    if (!toLocalFrame(m_page->mainFrame())->view() || toLocalFrame(m_page->mainFrame())->view()->needsLayout())
         return;
 
     // FIXME: scheduleAnimation() is just a method of forcing the compositor to realize that it
     // needs to commit here. We should expose a cleaner API for this.
-    RenderView* renderView = m_page->mainFrame()->contentRenderer();
+    RenderView* renderView = toLocalFrame(m_page->mainFrame())->contentRenderer();
     if (renderView && renderView->compositor() && renderView->compositor()->staleInCompositingMode())
-        m_page->mainFrame()->view()->scheduleAnimation();
+        toLocalFrame(m_page->mainFrame())->view()->scheduleAnimation();
 
     m_touchEventTargetRectsAreDirty = true;
 }
 
 void ScrollingCoordinator::updateScrollParentForGraphicsLayer(GraphicsLayer* child, RenderLayer* parent)
 {
     WebLayer* scrollParentWebLayer = 0;
     if (parent && parent->hasCompositedLayerMapping())
         scrollParentWebLayer = toWebLayer(parent->compositedLayerMapping()->parentForSublayers());
 
@@ skipping 11 matching lines @@
 
 void ScrollingCoordinator::willDestroyRenderLayer(RenderLayer* layer)
 {
     m_layersWithTouchRects.remove(layer);
 }
 
 void ScrollingCoordinator::updateHaveWheelEventHandlers()
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
-    if (!m_page->mainFrame()->view())
+    if (!m_page->mainFrame()->isLocalFrame() || !toLocalFrame(m_page->mainFrame())->view())
         return;
 
-    if (WebLayer* scrollLayer = toWebLayer(m_page->mainFrame()->view()->layerForScrolling())) {
+    if (WebLayer* scrollLayer = toWebLayer(toLocalFrame(m_page->mainFrame())->view()->layerForScrolling())) {
         bool haveHandlers = m_page->frameHost().eventHandlerRegistry().hasEventHandlers(EventHandlerRegistry::WheelEvent);
         scrollLayer->setHaveWheelEventHandlers(haveHandlers);
     }
 }
 
 void ScrollingCoordinator::updateHaveScrollEventHandlers()
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
-    if (!m_page->mainFrame()->view())
+    if (!m_page->mainFrame()->isLocalFrame() || !toLocalFrame(m_page->mainFrame())->view())
         return;
 
     // Currently the compositor only cares whether there are scroll handlers anywhere on the page
     // instead on a per-layer basis. We therefore only update this information for the root
     // scrolling layer.
-    if (WebLayer* scrollLayer = toWebLayer(m_page->mainFrame()->view()->layerForScrolling())) {
+    if (WebLayer* scrollLayer = toWebLayer(toLocalFrame(m_page->mainFrame())->view()->layerForScrolling())) {
         bool haveHandlers = m_page->frameHost().eventHandlerRegistry().hasEventHandlers(EventHandlerRegistry::ScrollEvent);
         scrollLayer->setHaveScrollEventHandlers(haveHandlers);
     }
 }
 
 void ScrollingCoordinator::setShouldUpdateScrollLayerPositionOnMainThread(MainThreadScrollingReasons reasons)
 {
-    if (WebLayer* scrollLayer = toWebLayer(m_page->mainFrame()->view()->layerForScrolling())) {
+    if (!m_page->mainFrame()->isLocalFrame())
+        return;
+    if (WebLayer* scrollLayer = toWebLayer(toLocalFrame(m_page->mainFrame())->view()->layerForScrolling())) {
         m_lastMainThreadScrollingReasons = reasons;
         scrollLayer->setShouldScrollOnMainThread(reasons);
     }
 }
 
 void ScrollingCoordinator::willBeDestroyed()
 {
     ASSERT(m_page);
     m_page = 0;
     for (ScrollbarMap::iterator it = m_horizontalScrollbars.begin(); it != m_horizontalScrollbars.end(); ++it)
         GraphicsLayer::unregisterContentsLayer(it->value->layer());
     for (ScrollbarMap::iterator it = m_verticalScrollbars.begin(); it != m_verticalScrollbars.end(); ++it)
         GraphicsLayer::unregisterContentsLayer(it->value->layer());
 }
 
 bool ScrollingCoordinator::coordinatesScrollingForFrameView(FrameView* frameView) const
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
 
     // We currently only handle the main frame.
     if (&frameView->frame() != m_page->mainFrame())
         return false;
 
+    // FIXME: And only if the main frame is not an OOPI.
+    if (!m_page->mainFrame()->isLocalFrame())
+        return false;
+
     // We currently only support composited mode.
-    RenderView* renderView = m_page->mainFrame()->contentRenderer();
+    RenderView* renderView = toLocalFrame(m_page->mainFrame())->contentRenderer();
     if (!renderView)
         return false;
     return renderView->usesCompositing();
 }
 
 Region ScrollingCoordinator::computeShouldHandleScrollGestureOnMainThreadRegion(const LocalFrame* frame, const IntPoint& frameLocation) const
 {
     Region shouldHandleScrollGestureOnMainThreadRegion;
     FrameView* frameView = frame->view();
     if (!frameView)
@@ skipping 112 matching lines @@
         }
     }
 
 }
 
 void ScrollingCoordinator::computeTouchEventTargetRects(LayerHitTestRects& rects)
 {
     TRACE_EVENT0("input", "ScrollingCoordinator::computeTouchEventTargetRects");
     ASSERT(touchHitTestingEnabled());
 
-    Document* document = m_page->mainFrame()->document();
+    Document* document = toLocalFrame(m_page->mainFrame())->document();
     if (!document || !document->view())
         return;
 
     accumulateDocumentTouchEventTargetRects(rects, document);
 }
 
 void ScrollingCoordinator::frameViewHasSlowRepaintObjectsDidChange(FrameView* frameView)
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
@@ skipping 10 matching lines @@
     ASSERT(m_page);
 
     if (!coordinatesScrollingForFrameView(frameView))
         return;
 
     m_shouldScrollOnMainThreadDirty = true;
 }
 
 bool ScrollingCoordinator::isForMainFrame(ScrollableArea* scrollableArea) const
 {
-    return scrollableArea == m_page->mainFrame()->view();
+    return m_page->mainFrame()->isLocalFrame() ? scrollableArea == toLocalFrame(m_page->mainFrame())->view() : false;
 }
 
 void ScrollingCoordinator::frameViewRootLayerDidChange(FrameView* frameView)
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
 
     if (!coordinatesScrollingForFrameView(frameView))
         return;
 
     notifyLayoutUpdated();
     updateHaveWheelEventHandlers();
     updateHaveScrollEventHandlers();
 }
 
 #if OS(MACOSX)
 void ScrollingCoordinator::handleWheelEventPhase(PlatformWheelEventPhase phase)
 {
     ASSERT(isMainThread());
 
     if (!m_page)
         return;
 
-    FrameView* frameView = m_page->mainFrame()->view();
+    FrameView* frameView = toLocalFrame(m_page->mainFrame())->view();
     if (!frameView)
         return;
 
     frameView->scrollAnimator()->handleWheelEventPhase(phase);
 }
 #endif
 
 bool ScrollingCoordinator::hasVisibleSlowRepaintViewportConstrainedObjects(FrameView* frameView) const
 {
     const FrameView::ViewportConstrainedObjectSet* viewportConstrainedObjects = frameView->viewportConstrainedObjects();
@@ skipping 15 matching lines @@
             return true;
     }
     return false;
 }
 
 MainThreadScrollingReasons ScrollingCoordinator::mainThreadScrollingReasons() const
 {
     // The main thread scrolling reasons are applicable to scrolls of the main
     // frame. If it does not exist or if it is not scrollable, there is no
     // reason to force main thread scrolling.
-    FrameView* frameView = m_page->mainFrame()->view();
+    if (!m_page->mainFrame()->isLocalFrame())
+        return static_cast<MainThreadScrollingReasons>(0);
+    FrameView* frameView = toLocalFrame(m_page->mainFrame())->view();
     if (!frameView)
         return static_cast<MainThreadScrollingReasons>(0);
 
     MainThreadScrollingReasons mainThreadScrollingReasons = (MainThreadScrollingReasons)0;
 
     if (frameView->hasSlowRepaintObjects())
         mainThreadScrollingReasons |= HasSlowRepaintObjects;
     if (hasVisibleSlowRepaintViewportConstrainedObjects(frameView))
         mainThreadScrollingReasons |= HasNonLayerViewportConstrainedObjects;
 
@@ skipping 11 matching lines @@
     if (reasons & ScrollingCoordinator::HasNonLayerViewportConstrainedObjects)
         stringBuilder.append("Has non-layer viewport-constrained objects, ");
 
     if (stringBuilder.length())
         stringBuilder.resize(stringBuilder.length() - 2);
     return stringBuilder.toString();
 }
 
 String ScrollingCoordinator::mainThreadScrollingReasonsAsText() const
 {
-    ASSERT(m_page->mainFrame()->document()->lifecycle().state() >= DocumentLifecycle::CompositingClean);
+    ASSERT(toLocalFrame(m_page->mainFrame())->document()->lifecycle().state() >= DocumentLifecycle::CompositingClean);
     return mainThreadScrollingReasonsAsText(m_lastMainThreadScrollingReasons);
 }
 
 bool ScrollingCoordinator::frameViewIsDirty() const
 {
-    FrameView* frameView = m_page->mainFrame()->view();
+    FrameView* frameView = m_page->mainFrame()->isLocalFrame() ? toLocalFrame(m_page->mainFrame())->view() : 0;
     bool frameIsScrollable = frameView && frameView->isScrollable();
     if (frameIsScrollable != m_wasFrameScrollable)
         return true;
 
     if (WebLayer* scrollLayer = frameView ? toWebLayer(frameView->layerForScrolling()) : 0)
         return blink::WebSize(frameView->contentsSize()) != scrollLayer->bounds();
     return false;
 }
 
 } // namespace WebCore