Remove NonCompositedContentHost -- Take 2

Source/core/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 177 matching lines @@
 
 void RenderLayerBacking::createPrimaryGraphicsLayer()
 {
     String layerName;
 #ifndef NDEBUG
     layerName = m_owningLayer->debugName();
 #endif
     
     m_graphicsLayer = createGraphicsLayer(layerName, m_owningLayer->compositingReasons());
 
+#if !OS(ANDROID)
     if (m_isMainFrameRenderViewLayer)
-        m_graphicsLayer->setContentsOpaque(true);
+        m_graphicsLayer->contentLayer()->setDrawCheckerboardForMissingTiles(true);
+#endif
 
     updateOpacity(renderer()->style());
     updateTransform(renderer()->style());
     updateFilters(renderer()->style());
 
     if (RuntimeEnabledFeatures::cssCompositingEnabled())
         updateLayerBlendMode(renderer()->style());
 }
 
 void RenderLayerBacking::destroyGraphicsLayers()
@@ skipping 51 matching lines @@
         //
         m_owningLayer->updateOrRemoveFilterEffectRenderer();
         setContentsNeedDisplay();
     }
 }
 
 void RenderLayerBacking::updateLayerBlendMode(const RenderStyle*)
 {
 }
 
+void RenderLayerBacking::updateContentsOpaque()
+{
+    // For non-root layers, background is always painted by the primary graphics layer.
+    ASSERT(m_isMainFrameRenderViewLayer || !m_backgroundLayer);
+    m_graphicsLayer->setContentsOpaque(m_owningLayer->backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
+}
+
 static bool hasNonZeroTransformOrigin(const RenderObject* renderer)
 {
     RenderStyle* style = renderer->style();
     return (style->transformOriginX().type() == Fixed && style->transformOriginX().value())
         || (style->transformOriginY().type() == Fixed && style->transformOriginY().value());
 }
 
 static bool layerOrAncestorIsTransformedOrUsingCompositedScrolling(RenderLayer* layer)
 {
     for (RenderLayer* curr = layer; curr; curr = curr->parent()) {
@@ skipping 91 matching lines @@
         
         if (flags & IsUpdateRoot) {
             updateGraphicsLayerGeometry();
             layerCompositor->updateRootLayerPosition();
             RenderLayer* stackingContainer = m_owningLayer->enclosingStackingContainer();
             if (!layerCompositor->compositingLayersNeedRebuild() && stackingContainer && (stackingContainer != m_owningLayer))
                 layerCompositor->updateCompositingDescendantGeometry(stackingContainer, stackingContainer, flags & CompositingChildrenOnly);
         }
     }
     
-    if (flags & NeedsFullRepaint && !paintsIntoWindow() && !paintsIntoCompositedAncestor())
+    if (flags & NeedsFullRepaint && !paintsIntoCompositedAncestor())
         setContentsNeedDisplay();
 }
 
 bool RenderLayerBacking::updateGraphicsLayerConfiguration()
 {
     RenderLayerCompositor* compositor = this->compositor();
     RenderObject* renderer = this->renderer();
 
     m_owningLayer->updateDescendantDependentFlags();
     m_owningLayer->updateZOrderLists();
@@ skipping 172 matching lines @@
     
     FloatSize oldSize = m_graphicsLayer->size();
     if (oldSize != contentsSize) {
         m_graphicsLayer->setSize(contentsSize);
         // Usually invalidation will happen via layout etc, but if we've affected the layer
         // size by constraining relative to a clipping ancestor or the viewport, we
         // have to invalidate to avoid showing stretched content.
         if (m_boundsConstrainedByClipping)
             m_graphicsLayer->setNeedsDisplay();
     }
-    if (!m_isMainFrameRenderViewLayer) {
-        // For non-root layers, background is always painted by the primary graphics layer.
-        ASSERT(!m_backgroundLayer);
-        m_graphicsLayer->setContentsOpaque(m_owningLayer->backgroundIsKnownToBeOpaqueInRect(localCompositingBounds));
-    }
 
     // If we have a layer that clips children, position it.
     IntRect clippingBox;
     if (GraphicsLayer* clipLayer = clippingLayer()) {
         clippingBox = clipBox(toRenderBox(renderer()));
         clipLayer->setPosition(FloatPoint(clippingBox.location() - localCompositingBounds.location()));
         clipLayer->setSize(clippingBox.size());
         clipLayer->setOffsetFromRenderer(toIntSize(clippingBox.location()));
     }
     
@@ skipping 129 matching lines @@
             m_foregroundLayer->setOffsetFromRenderer(m_scrollingContentsLayer->offsetFromRenderer());
         }
     }
 
     // If this layer was created just for clipping or to apply perspective, it doesn't need its own backing store.
     setRequiresOwnBackingStore(compositor()->requiresOwnBackingStore(m_owningLayer, compAncestor));
 
     updateContentsRect(isSimpleContainer);
     updateBackgroundColor(isSimpleContainer);
     updateDrawsContent(isSimpleContainer);
+    updateContentsOpaque();
     updateAfterWidgetResize();
     registerScrollingLayers();
 
     updateCompositingReasons();
 }
 
 void RenderLayerBacking::registerScrollingLayers()
 {
     // Register fixed position layers and their containers with the scrolling coordinator.
     ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
@@ skipping 584 matching lines @@
 }
 
 // Conservative test for having no rendered children.
 bool RenderLayerBacking::hasVisibleNonCompositingDescendantLayers() const
 {
     return hasVisibleNonCompositingDescendant(m_owningLayer);
 }
 
 bool RenderLayerBacking::containsPaintedContent() const
 {
-    if (isSimpleContainerCompositingLayer() || paintsIntoWindow() || paintsIntoCompositedAncestor() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())
+    if (isSimpleContainerCompositingLayer() || paintsIntoCompositedAncestor() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())
         return false;
 
     if (isDirectlyCompositedImage())
         return false;
 
     // FIXME: we could optimize cases where the image, video or canvas is known to fill the border box entirely,
     // and set background color on the layer in that case, instead of allocating backing store and painting.
     if (renderer()->isVideo() && toRenderVideo(renderer())->shouldDisplayVideo())
         return m_owningLayer->hasBoxDecorationsOrBackground();
 
@@ skipping 162 matching lines @@
 {
     if (m_ancestorClippingLayer)
         return m_ancestorClippingLayer.get();
 
     if (m_contentsContainmentLayer)
         return m_contentsContainmentLayer.get();
     
     return m_graphicsLayer.get();
 }
 
-bool RenderLayerBacking::paintsIntoWindow() const
-{
-    if (m_owningLayer->isRootLayer()) {
-        return compositor()->rootLayerAttachment() != RenderLayerCompositor::RootLayerAttachedViaEnclosingFrame;
-    }
-    
-    return false;
-}
-
 void RenderLayerBacking::setRequiresOwnBackingStore(bool requiresOwnBacking)
 {
     if (requiresOwnBacking == m_requiresOwnBackingStore)
         return;
     
     m_requiresOwnBackingStore = requiresOwnBacking;
 
     // This affects the answer to paintsIntoCompositedAncestor(), which in turn affects
     // cached clip rects, so when it changes we have to clear clip rects on descendants.
     m_owningLayer->clearClipRectsIncludingDescendants(PaintingClipRects);
@@ skipping 60 matching lines @@
         IntRect layerDirtyRect = r;
         layerDirtyRect.move(-m_scrollingContentsLayer->offsetFromRenderer());
         m_scrollingContentsLayer->setNeedsDisplayInRect(layerDirtyRect);
     }
 }
 
 void RenderLayerBacking::paintIntoLayer(const GraphicsLayer* graphicsLayer, GraphicsContext* context,
                     const IntRect& paintDirtyRect, // In the coords of rootLayer.
                     PaintBehavior paintBehavior, GraphicsLayerPaintingPhase paintingPhase)
 {
-    if (paintsIntoWindow() || paintsIntoCompositedAncestor()) {
+    if (paintsIntoCompositedAncestor()) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     FontCachePurgePreventer fontCachePurgePreventer;
     
     RenderLayer::PaintLayerFlags paintFlags = 0;
     if (paintingPhase & GraphicsLayerPaintBackground)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingBackgroundPhase;
     if (paintingPhase & GraphicsLayerPaintForeground)
@@ skipping 351 matching lines @@
     info.addMember(m_childContainmentLayer, "childContainmentLayer");
     info.addMember(m_maskLayer, "maskLayer");
     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