[DO NOT COMMIT] Random hacks to unblock work on replication.

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 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 119 matching lines @@
         // No tests fail if it's deleted.
         setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
         setCompositingModeEnabled(true);
     }
 }
 
 bool RenderLayerCompositor::rootShouldAlwaysComposite() const
 {
     if (!m_hasAcceleratedCompositing)
         return false;
-    return m_renderView.frame()->isMainFrame() || m_compositingReasonFinder.requiresCompositingForScrollableFrame();
+    return m_renderView.frame()->isMainFrame() || m_renderView.frame()->isLocalRoot() ||
+      m_compositingReasonFinder.requiresCompositingForScrollableFrame();
 }
 
 void RenderLayerCompositor::updateAcceleratedCompositingSettings()
 {
     m_compositingReasonFinder.updateTriggers();
     m_hasAcceleratedCompositing = m_renderView.document().settings()->acceleratedCompositingEnabled();
     m_rootShouldAlwaysCompositeDirty = true;
 }
 
 bool RenderLayerCompositor::layerSquashingEnabled() const
@@ skipping 92 matching lines @@
 }
 
 #endif
 
 void RenderLayerCompositor::applyOverlayFullscreenVideoAdjustment()
 {
     m_inOverlayFullscreenVideo = false;
     if (!m_rootContentLayer)
         return;
 
-    bool isMainFrame = m_renderView.frame()->isMainFrame();
+    bool isLocalRoot = m_renderView.frame()->isLocalRoot();
     RenderVideo* video = findFullscreenVideoRenderer(m_renderView.document());
     if (!video || !video->hasCompositedLayerMapping()) {
-        if (isMainFrame) {
+        if (isLocalRoot) {
             GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer();
             if (backgroundLayer && !backgroundLayer->parent())
                 rootFixedBackgroundsChanged();
         }
         return;
     }
 
     GraphicsLayer* videoLayer = video->compositedLayerMapping()->mainGraphicsLayer();
 
     // The fullscreen video has layer position equal to its enclosing frame's scroll position because fullscreen container is fixed-positioned.
     // We should reset layer position here since we are going to reattach the layer at the very top level.
     videoLayer->setPosition(IntPoint());
 
     // Only steal fullscreen video layer and clear all other layers if we are the main frame.
-    if (!isMainFrame)
+    if (!isLocalRoot)
         return;
 
     m_rootContentLayer->removeAllChildren();
     m_overflowControlsHostLayer->addChild(videoLayer);
     if (GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer())
         backgroundLayer->removeFromParent();
     m_inOverlayFullscreenVideo = true;
 }
 
 void RenderLayerCompositor::updateIfNeeded()
@@ skipping 68 matching lines @@
     }
 
     for (unsigned i = 0; i < layersNeedingRepaint.size(); i++) {
         RenderLayer* layer = layersNeedingRepaint[i];
         layer->repainter().computeRepaintRectsIncludingNonCompositingDescendants();
 
         repaintOnCompositingChange(layer);
     }
 
     // Inform the inspector that the layer tree has changed.
-    if (m_renderView.frame()->isMainFrame())
+    if (m_renderView.frame()->isLocalRoot())
         InspectorInstrumentation::layerTreeDidChange(m_renderView.frame());
 }
 
 bool RenderLayerCompositor::allocateOrClearCompositedLayerMapping(RenderLayer* layer, const CompositingStateTransitionType compositedLayerUpdate)
 {
     bool compositedLayerMappingChanged = false;
     bool nonCompositedReasonChanged = updateLayerIfViewportConstrained(layer);
 
     // FIXME: It would be nice to directly use the layer's compositing reason,
     // but allocateOrClearCompositedLayerMapping also gets called without having updated compositing
@@ skipping 10 matching lines @@
         // sorts of compositingState transitions.
         layer->setLostGroupedMapping(false);
         layer->setGroupedMapping(0);
 
         // If we need to repaint, do so before allocating the compositedLayerMapping
         repaintOnCompositingChange(layer);
         layer->ensureCompositedLayerMapping();
         compositedLayerMappingChanged = true;
 
         // At this time, the ScrollingCooridnator only supports the top-level frame.
-        if (layer->isRootLayer() && m_renderView.frame()->isMainFrame()) {
+        if (layer->isRootLayer() && m_renderView.frame()->isLocalRoot()) {
             if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
                 scrollingCoordinator->frameViewRootLayerDidChange(m_renderView.frameView());
         }
         break;
     case RemoveOwnCompositedLayerMapping:
     // PutInSquashingLayer means you might have to remove the composited layer mapping first.
     case PutInSquashingLayer:
         if (layer->hasCompositedLayerMapping()) {
             // If we're removing the compositedLayerMapping from a reflection, clear the source GraphicsLayer's pointer to
             // its replica GraphicsLayer. In practice this should never happen because reflectee and reflection
@@ skipping 135 matching lines @@
 {
     FrameView* frameView = m_renderView.frameView();
     IntPoint scrollPosition = frameView->scrollPosition();
 
     if (!m_scrollLayer)
         return;
 
     bool scrollingCoordinatorHandlesOffset = false;
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator()) {
         if (Settings* settings = m_renderView.document().settings()) {
-            if (m_renderView.frame()->isMainFrame() || settings->compositedScrollingForFramesEnabled())
+            if (m_renderView.frame()->isLocalRoot() || settings->compositedScrollingForFramesEnabled())
                 scrollingCoordinatorHandlesOffset = scrollingCoordinator->scrollableAreaScrollLayerDidChange(frameView);
         }
     }
 
     // Scroll position = scroll minimum + scroll offset. Adjust the layer's
     // position to handle whatever the scroll coordinator isn't handling.
     // The minimum scroll position is non-zero for RTL pages with overflow.
     if (scrollingCoordinatorHandlesOffset)
         m_scrollLayer->setPosition(-frameView->minimumScrollPosition());
     else
@@ skipping 165 matching lines @@
 
 void RenderLayerCompositor::setIsInWindow(bool isInWindow)
 {
     if (!staleInCompositingMode())
         return;
 
     if (isInWindow) {
         if (m_rootLayerAttachment != RootLayerUnattached)
             return;
 
-        RootLayerAttachment attachment = m_renderView.frame()->isMainFrame() ? RootLayerAttachedViaChromeClient : RootLayerAttachedViaEnclosingFrame;
+        RootLayerAttachment attachment = m_renderView.frame()->isLocalRoot() ? RootLayerAttachedViaChromeClient : RootLayerAttachedViaEnclosingFrame;
         attachRootLayer(attachment);
     } else {
         if (m_rootLayerAttachment == RootLayerUnattached)
             return;
 
         detachRootLayer();
     }
 }
 
 void RenderLayerCompositor::updateRootLayerPosition()
@@ skipping 201 matching lines @@
 
 bool RenderLayerCompositor::requiresScrollCornerLayer() const
 {
     FrameView* view = m_renderView.frameView();
     return shouldCompositeOverflowControls(view) && view->isScrollCornerVisible();
 }
 
 void RenderLayerCompositor::updateOverflowControlsLayers()
 {
 #if USE(RUBBER_BANDING)
-    if (m_renderView.frame()->isMainFrame()) {
+    if (m_renderView.frame()->isLocalRoot()) {
         if (!m_layerForOverhangShadow) {
             m_layerForOverhangShadow = GraphicsLayer::create(graphicsLayerFactory(), this);
             OverscrollTheme::theme()->setUpOverhangShadowLayer(m_layerForOverhangShadow.get());
             OverscrollTheme::theme()->updateOverhangShadowLayer(m_layerForOverhangShadow.get(), m_rootContentLayer.get());
             m_scrollLayer->addChild(m_layerForOverhangShadow.get());
         }
     } else {
         ASSERT(!m_layerForOverhangShadow);
     }
 #endif
@@ skipping 45 matching lines @@
     } else if (m_layerForScrollCorner) {
         m_layerForScrollCorner->removeFromParent();
         m_layerForScrollCorner = nullptr;
     }
 
     m_renderView.frameView()->positionScrollbarLayers();
 }
 
 void RenderLayerCompositor::ensureRootLayer()
 {
-    RootLayerAttachment expectedAttachment = m_renderView.frame()->isMainFrame() ? RootLayerAttachedViaChromeClient : RootLayerAttachedViaEnclosingFrame;
+    RootLayerAttachment expectedAttachment = m_renderView.frame()->isLocalRoot() ? RootLayerAttachedViaChromeClient : RootLayerAttachedViaEnclosingFrame;
     if (expectedAttachment == m_rootLayerAttachment)
          return;
 
     if (!m_rootContentLayer) {
         m_rootContentLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
         IntRect overflowRect = m_renderView.pixelSnappedLayoutOverflowRect();
         m_rootContentLayer->setSize(FloatSize(overflowRect.maxX(), overflowRect.maxY()));
         m_rootContentLayer->setPosition(FloatPoint());
         m_rootContentLayer->setOwnerNodeId(InspectorNodeIds::idForNode(m_renderView.generatingNode()));
 
         // Need to clip to prevent transformed content showing outside this frame
         m_rootContentLayer->setMasksToBounds(true);
     }
 
     if (!m_overflowControlsHostLayer) {
         ASSERT(!m_scrollLayer);
         ASSERT(!m_containerLayer);
 
         // Create a layer to host the clipping layer and the overflow controls layers.
         m_overflowControlsHostLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
 
         // Create a clipping layer if this is an iframe or settings require to clip.
         m_containerLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
-        bool containerMasksToBounds = !m_renderView.frame()->isMainFrame();
+        bool containerMasksToBounds = !m_renderView.frame()->isLocalRoot();
         if (Settings* settings = m_renderView.document().settings()) {
             if (settings->mainFrameClipsContent())
                 containerMasksToBounds = true;
         }
         m_containerLayer->setMasksToBounds(containerMasksToBounds);
 
         m_scrollLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
         if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
             scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(m_scrollLayer.get(), true);
 
@@ skipping 176 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore