Add support for accelerated fixed root background

Source/WebCore/rendering/RenderLayerBacking.cpp

 /*
  * Copyright (C) 2009, 2010, 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 103 matching lines @@
     , m_usingTiledCacheLayer(false)
     , m_requiresOwnBackingStore(true)
 #if ENABLE(CSS_FILTERS)
     , m_canCompositeFilters(false)
 #endif
     , m_backgroundLayerPaintsFixedRootBackground(false)
 {
     if (layer->isRootLayer()) {
         Frame* frame = toRenderView(renderer())->frameView()->frame();
         Page* page = frame ? frame->page() : 0;
-        if (page && frame && page->mainFrame() == frame) {
+        if (page && frame && page->mainFrame() == frame)
             m_isMainFrameRenderViewLayer = true;
+    }
 
-#if PLATFORM(MAC)
-            // FIXME: It's a little weird that we base this decision on whether there's a scrolling coordinator or not.
-            if (page->scrollingCoordinator())
-                m_usingTiledCacheLayer = true;
-#endif
-        }
-    }
-    
     createPrimaryGraphicsLayer();
 
     if (m_usingTiledCacheLayer) {
         TiledBacking* tiledBacking = this->tiledBacking();
         if (Page* page = renderer()->frame()->page()) {
             Frame* frame = renderer()->frame();
             tiledBacking->setIsInWindow(page->isInWindow());
 
             if (m_isMainFrameRenderViewLayer)
                 tiledBacking->setUnparentsOffscreenTiles(true);
@@ skipping 135 matching lines @@
     
     // The call to createGraphicsLayer ends calling back into here as
     // a GraphicsLayerClient to ask if it shouldUseTiledBacking(). We only want
     // the tile cache on our main layer. This is pretty ugly, but saves us from
     // exposing the API to all clients.
 
     m_creatingPrimaryGraphicsLayer = true;
     m_graphicsLayer = createGraphicsLayer(layerName);
     m_creatingPrimaryGraphicsLayer = false;
 
-    if (m_usingTiledCacheLayer)
-        m_childContainmentLayer = createGraphicsLayer("TiledBacking Flattening Layer");
-
     if (m_isMainFrameRenderViewLayer) {
         m_graphicsLayer->setContentsOpaque(true);
         m_graphicsLayer->setAppliesPageScale();
     }
 
 #if PLATFORM(MAC) && USE(CA)
     if (!compositor()->acceleratedDrawingEnabled() && renderer()->isCanvas()) {
         HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(renderer()->node());
         if (canvas->shouldAccelerate(canvas->size()))
             m_graphicsLayer->setAcceleratesDrawing(true);
@@ skipping 94 matching lines @@
     
     return false;
 }
 
 bool RenderLayerBacking::shouldClipCompositedBounds() const
 {
     // Scrollbar layers use this layer for relative positioning, so don't clip.
     if (layerForHorizontalScrollbar() || layerForVerticalScrollbar())
         return false;
 
-    if (m_usingTiledCacheLayer)
+    if (m_usingTiledCacheLayer || m_backgroundLayerPaintsFixedRootBackground)
         return false;
 
     if (!compositor()->compositingConsultsOverlap())
         return false;
 
     if (layerOrAncestorIsTransformedOrUsingCompositedScrolling(m_owningLayer))
         return false;
 
     return true;
 }
@@ skipping 357 matching lines @@
         if (foregroundSize != m_foregroundLayer->size()) {
             m_foregroundLayer->setSize(foregroundSize);
             m_foregroundLayer->setNeedsDisplay();
         }
         m_foregroundLayer->setOffsetFromRenderer(foregroundOffset);
     }
 
     if (m_backgroundLayer) {
         FloatPoint backgroundPosition;
         FloatSize backgroundSize = contentsSize;
-        if (backgroundLayerPaintsFixedRootBackground()) {
-            FrameView* frameView = toRenderView(renderer())->frameView();
-            backgroundPosition = IntPoint(frameView->scrollOffsetForFixedPosition());
-            backgroundSize = frameView->visibleContentRect().size();
-        }
         m_backgroundLayer->setPosition(backgroundPosition);
         if (backgroundSize != m_backgroundLayer->size()) {
             m_backgroundLayer->setSize(backgroundSize);
             m_backgroundLayer->setNeedsDisplay();
         }
-        m_backgroundLayer->setOffsetFromRenderer(m_graphicsLayer->offsetFromRenderer());
     }
 
     if (m_owningLayer->reflectionLayer() && m_owningLayer->reflectionLayer()->isComposited()) {
         RenderLayerBacking* reflectionBacking = m_owningLayer->reflectionLayer()->backing();
         reflectionBacking->updateGraphicsLayerGeometry();
         
         // The reflection layer has the bounds of m_owningLayer->reflectionLayer(),
         // but the reflected layer is the bounds of this layer, so we need to position it appropriately.
         FloatRect layerBounds = compositedBounds();
         FloatRect reflectionLayerBounds = reflectionBacking->compositedBounds();
@@ skipping 72 matching lines @@
     // m_foregroundLayer has to be inserted in the correct order with child layers,
     // so it's not inserted here.
     if (m_ancestorClippingLayer)
         m_ancestorClippingLayer->removeAllChildren();
     
     if (m_contentsContainmentLayer) {
         m_contentsContainmentLayer->removeAllChildren();
         if (m_ancestorClippingLayer)
             m_ancestorClippingLayer->addChild(m_contentsContainmentLayer.get());
     }
-    
-    if (m_backgroundLayer)
-        m_contentsContainmentLayer->addChild(m_backgroundLayer.get());
 
     m_graphicsLayer->removeFromParent();
     if (m_contentsContainmentLayer)
         m_contentsContainmentLayer->addChild(m_graphicsLayer.get());
     else if (m_ancestorClippingLayer)
         m_ancestorClippingLayer->addChild(m_graphicsLayer.get());
 
     if (m_childContainmentLayer) {
         m_childContainmentLayer->removeFromParent();
         m_graphicsLayer->addChild(m_childContainmentLayer.get());
@@ skipping 76 matching lines @@
             layersChanged = true;
         }
     } else if (m_ancestorClippingLayer) {
         willDestroyLayer(m_ancestorClippingLayer.get());
         m_ancestorClippingLayer->removeFromParent();
         m_ancestorClippingLayer = nullptr;
         layersChanged = true;
     }
     
     if (needsDescendantClip) {
-        if (!m_childContainmentLayer && !m_usingTiledCacheLayer) {
+        if (!m_childContainmentLayer && !m_usingTiledCacheLayer && !m_backgroundLayerPaintsFixedRootBackground) {
             m_childContainmentLayer = createGraphicsLayer("Child clipping Layer");
             m_childContainmentLayer->setMasksToBounds(true);
             layersChanged = true;
         }
     } else if (hasClippingLayer()) {
         willDestroyLayer(m_childContainmentLayer.get());
         m_childContainmentLayer->removeFromParent();
         m_childContainmentLayer = nullptr;
         layersChanged = true;
     }
@@ skipping 166 matching lines @@
             String layerName;
 #ifndef NDEBUG
             layerName = m_owningLayer->name() + " (background)";
 #endif
             m_backgroundLayer = createGraphicsLayer(layerName);
             m_backgroundLayer->setDrawsContent(true);
             m_backgroundLayer->setAnchorPoint(FloatPoint3D());
             m_backgroundLayer->setPaintingPhase(GraphicsLayerPaintBackground);
             layerChanged = true;
         }
-        
-        if (!m_contentsContainmentLayer) {
-            String layerName;
-#ifndef NDEBUG
-            layerName = m_owningLayer->name() + " (contents containment)";
-#endif
-            m_contentsContainmentLayer = createGraphicsLayer(layerName);
-            m_contentsContainmentLayer->setAppliesPageScale(true);
-            m_graphicsLayer->setAppliesPageScale(false);
-            layerChanged = true;
-        }
     } else {
         if (m_backgroundLayer) {
             willDestroyLayer(m_backgroundLayer.get());
             m_backgroundLayer->removeFromParent();
             m_backgroundLayer = nullptr;
             layerChanged = true;
         }
-        if (m_contentsContainmentLayer) {
-            willDestroyLayer(m_contentsContainmentLayer.get());
-            m_contentsContainmentLayer->removeFromParent();
-            m_contentsContainmentLayer = nullptr;
-            layerChanged = true;
-            m_graphicsLayer->setAppliesPageScale(true);
-        }
+    }
+    
+    if (layerChanged) {
+        // This assumes that the background layer is only used for fixed backgrounds, which is currently a correct assumption.
+        if (renderer()->view())
+            compositor()->fixedRootBackgroundLayerChanged();
     }
     
     return layerChanged;
 }
 
 bool RenderLayerBacking::updateMaskLayer(bool needsMaskLayer)
 {
     bool layerChanged = false;
     if (needsMaskLayer) {
         if (!m_maskLayer) {
@@ skipping 123 matching lines @@
     Color backgroundColor;
     if (isSimpleContainer)
         backgroundColor = rendererBackgroundColor();
 
     // An unset (invalid) color will remove the solid color.
     m_graphicsLayer->setContentsToSolidColor(backgroundColor);
 }
 
 void RenderLayerBacking::updateRootLayerConfiguration()
 {
-    if (!m_usingTiledCacheLayer)
+    if (!m_usingTiledCacheLayer && !m_backgroundLayerPaintsFixedRootBackground)
         return;
 
     Color backgroundColor;
     bool viewIsTransparent = compositor()->viewHasTransparentBackground(&backgroundColor);
 
     if (m_backgroundLayerPaintsFixedRootBackground && m_backgroundLayer) {
         m_backgroundLayer->setBackgroundColor(backgroundColor);
         m_backgroundLayer->setContentsOpaque(!viewIsTransparent);
 
         m_graphicsLayer->setBackgroundColor(Color());
@@ skipping 340 matching lines @@
         return m_ancestorClippingLayer.get();
 
     if (m_contentsContainmentLayer)
         return m_contentsContainmentLayer.get();
     
     return m_graphicsLayer.get();
 }
 
 bool RenderLayerBacking::paintsIntoWindow() const
 {
-    if (m_usingTiledCacheLayer)
+    if (m_usingTiledCacheLayer || m_backgroundLayerPaintsFixedRootBackground)
         return false;
 
     if (m_owningLayer->isRootLayer()) {
 #if PLATFORM(BLACKBERRY)
         if (compositor()->inForcedCompositingMode())
             return false;
 #endif
 
         return compositor()->rootLayerAttachment() != RenderLayerCompositor::RootLayerAttachedViaEnclosingFrame;
     }
@@ skipping 522 matching lines @@
     info.addMember(m_layerForHorizontalScrollbar, "layerForHorizontalScrollbar");
     info.addMember(m_layerForVerticalScrollbar, "layerForVerticalScrollbar");
     info.addMember(m_layerForScrollCorner, "layerForScrollCorner");
     info.addMember(m_scrollingLayer, "scrollingLayer");
     info.addMember(m_scrollingContentsLayer, "scrollingContentsLayer");
 }
 
 } // namespace WebCore
 
 #endif // USE(ACCELERATED_COMPOSITING)