Get rid of CompositingState.

sky/engine/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 513 matching lines @@
 {
     if (stackingNode()->isNormalFlowOnly())
         return parent();
     if (RenderLayerStackingNode* ancestorStackingNode = stackingNode()->ancestorStackingContextNode())
         return ancestorStackingNode->layer();
     return 0;
 }
 
 bool RenderLayer::isPaintInvalidationContainer() const
 {
-    return compositingState() == PaintsIntoOwnBacking || compositingState() == PaintsIntoGroupedBacking;
+    // FIXME(sky): Remove
+    return false;
 }
 
 // Note: enclosingCompositingLayer does not include squashed layers. Compositing stacking children of squashed layers
 // receive graphics layers that are parented to the compositing ancestor of the squashed layer.
 RenderLayer* RenderLayer::enclosingLayerWithCompositedLayerMapping(IncludeSelfOrNot includeSelf) const
 {
     // FIXME(sky): Remove
     return 0;
 }
 
@@ skipping 245 matching lines @@
     return oldChild;
 }
 
 void RenderLayer::removeOnlyThisLayer()
 {
     if (!m_parent)
         return;
 
     m_clipper.clearClipRectsIncludingDescendants();
 
-    // For querying RenderLayer::compositingState()
-    // Eager invalidation here is correct, since we are invalidating with respect to the previous frame's
-    // compositing state when removing the layer.
-    DisableCompositingQueryAsserts disabler;
     paintInvalidator().paintInvalidationIncludingNonCompositingDescendants();
 
     RenderLayer* nextSib = nextSibling();
 
     // Now walk our kids and reattach them to our parent.
     RenderLayer* current = m_first;
     while (current) {
         RenderLayer* next = current->nextSibling();
         removeChild(current);
         m_parent->addChild(current, nextSib);
@@ skipping 119 matching lines @@
 }
 
 bool RenderLayer::hasOverflowControls() const
 {
     return m_scrollableArea && m_scrollableArea->hasScrollbar();
 }
 
 void RenderLayer::paint(GraphicsContext* context, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot, PaintLayerFlags paintFlags)
 {
     LayerPaintingInfo paintingInfo(this, enclosingIntRect(damageRect), paintBehavior, LayoutSize(), paintingRoot);
-    if (shouldPaintLayerInSoftwareMode(paintingInfo, paintFlags))
-        paintLayer(context, paintingInfo, paintFlags);
+    paintLayer(context, paintingInfo, paintFlags);
 }
 
 void RenderLayer::paintOverlayScrollbars(GraphicsContext* context, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot)
 {
     if (!m_containsDirtyOverlayScrollbars)
         return;
 
     LayerPaintingInfo paintingInfo(this, enclosingIntRect(damageRect), paintBehavior, LayoutSize(), paintingRoot);
     paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
@@ skipping 58 matching lines @@
 {
     // Avoid painting descendants of the root layer when stylesheets haven't loaded. This eliminates FOUC.
     // It's ok not to draw, because later on, when all the stylesheets do load, updateStyleSelector on the Document
     // will do a full paintInvalidationForWholeRenderer().
     if (layer->renderer()->document().didLayoutWithPendingStylesheets() && !layer->isRootLayer() && !layer->renderer()->isDocumentElement())
         return true;
 
     return false;
 }
 
-static bool paintForFixedRootBackground(const RenderLayer* layer, PaintLayerFlags paintFlags)
-{
-    return layer->renderer()->isDocumentElement() && (paintFlags & PaintLayerPaintingRootBackgroundOnly);
-}
-
 static ShouldRespectOverflowClip shouldRespectOverflowClip(PaintLayerFlags paintFlags, const RenderObject* renderer)
 {
     return (paintFlags & PaintLayerPaintingOverflowContents || (paintFlags & PaintLayerPaintingChildClippingMaskPhase && renderer->hasClipPath())) ? IgnoreOverflowClip : RespectOverflowClip;
 }
 
 void RenderLayer::paintLayer(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
 {
-    // https://code.google.com/p/chromium/issues/detail?id=343772
-    DisableCompositingQueryAsserts disabler;
-
-    if (compositingState() != NotComposited) {
-        if (paintingInfo.paintBehavior & PaintBehaviorFlattenCompositingLayers) {
-            // FIXME: ok, but what about PaintBehaviorFlattenCompositingLayers? That's for printing.
-            // FIXME: why isn't the code here global, as opposed to being set on each paintLayer() call?
-            paintFlags |= PaintLayerUncachedClipRects;
-        }
-    }
-
     // Non self-painting leaf layers don't need to be painted as their renderer() should properly paint itself.
     if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
         return;
 
     if (shouldSuppressPaintingLayer(this))
         return;
 
     // If this layer is totally invisible then there is nothing to paint.
     if (!renderer()->opacity())
         return;
@@ skipping 82 matching lines @@
 
     if (paintFlags & PaintLayerPaintingRootBackgroundOnly && !renderer()->isRenderView() && !renderer()->isDocumentElement())
         return;
 
     // Ensure our lists are up-to-date.
     m_stackingNode->updateLayerListsIfNeeded();
 
     LayoutPoint offsetFromRoot;
     convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
 
-    if (compositingState() == PaintsIntoOwnBacking)
-        offsetFromRoot.move(subpixelAccumulation());
-
     LayoutRect rootRelativeBounds;
     bool rootRelativeBoundsComputed = false;
 
     // Apply clip-path to context.
     GraphicsContextStateSaver clipStateSaver(*context, false);
     RenderStyle* style = renderer()->style();
 
     // Clip-path, like border radius, must not be applied to the contents of a composited-scrolling container.
     // It must, however, still be applied to the mask layer, so that the compositor can properly mask the
     // scrolling contents and scrollbars.
@@ skipping 170 matching lines @@
         stateSaver.save();
         context->concatCTM(transform.toAffineTransform());
     }
 
     // Now do a paint with the root layer shifted to be us.
     LayerPaintingInfo transformedPaintingInfo(this, enclosingIntRect(transform.inverse().mapRect(paintingInfo.paintDirtyRect)), paintingInfo.paintBehavior,
         adjustedSubPixelAccumulation, paintingInfo.paintingRoot);
     paintLayerContentsAndReflection(context, transformedPaintingInfo, paintFlags);
 }
 
-bool RenderLayer::shouldPaintLayerInSoftwareMode(const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
-{
-    DisableCompositingQueryAsserts disabler;
-
-    return compositingState() == NotComposited
-        || compositingState() == HasOwnBackingButPaintsIntoAncestor
-        || (paintingInfo.paintBehavior & PaintBehaviorFlattenCompositingLayers)
-        || paintForFixedRootBackground(this, paintFlags);
-}
-
 void RenderLayer::paintChildren(unsigned childrenToVisit, GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
 {
     if (!hasSelfPaintingLayerDescendant())
         return;
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(m_stackingNode.get());
 #endif
 
     RenderLayerStackingNodeIterator iterator(*m_stackingNode, childrenToVisit);
     while (RenderLayerStackingNode* child = iterator.next()) {
-        RenderLayer* childLayer = child->layer();
-        // If this RenderLayer should paint into its own backing or a grouped backing, that will be done via CompositedLayerMapping::paintContents()
-        // and CompositedLayerMapping::doPaintTask().
-        if (!childLayer->shouldPaintLayerInSoftwareMode(paintingInfo, paintFlags))
-            continue;
-
-        childLayer->paintLayer(context, paintingInfo, paintFlags);
+        child->layer()->paintLayer(context, paintingInfo, paintFlags);
     }
 }
 
 void RenderLayer::collectFragments(LayerFragments& fragments, const RenderLayer* rootLayer, const LayoutRect& dirtyRect,
     ClipRectsCacheSlot clipRectsCacheSlot, ShouldRespectOverflowClip respectOverflowClip, const LayoutPoint* offsetFromRoot,
     const LayoutSize& subPixelAccumulation, const LayoutRect* layerBoundingBox)
 {
     // For unpaginated layers, there is only one fragment.
     LayerFragment fragment;
     ClipRectsContext clipRectsContext(rootLayer, clipRectsCacheSlot, subPixelAccumulation);
@@ skipping 677 matching lines @@
 static void expandRectForReflectionAndStackingChildren(const RenderLayer* ancestorLayer, RenderLayer::CalculateBoundsOptions options, LayoutRect& result)
 {
     ASSERT(ancestorLayer->stackingNode()->isStackingContext() || !ancestorLayer->stackingNode()->hasPositiveZOrderList());
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(const_cast<RenderLayer*>(ancestorLayer)->stackingNode());
 #endif
 
     RenderLayerStackingNodeIterator iterator(*ancestorLayer->stackingNode(), AllChildren);
     while (RenderLayerStackingNode* node = iterator.next()) {
-        // Here we exclude both directly composited layers and squashing layers
-        // because those RenderLayers don't paint into the graphics layer
-        // for this RenderLayer. For example, the bounds of squashed RenderLayers
-        // will be included in the computation of the appropriate squashing
-        // GraphicsLayer.
-        if (options != RenderLayer::ApplyBoundsChickenEggHacks && node->layer()->compositingState() != NotComposited)
-            continue;
         result.unite(node->layer()->boundingBoxForCompositing(ancestorLayer, options));
     }
 }
 
 LayoutRect RenderLayer::physicalBoundingBoxIncludingReflectionAndStackingChildren(const RenderLayer* ancestorLayer, const LayoutPoint& offsetFromRoot) const
 {
     LayoutPoint origin;
     LayoutRect result = physicalBoundingBox(ancestorLayer, &origin);
 
     const_cast<RenderLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
@@ skipping 68 matching lines @@
 }
 
 bool RenderLayer::clipsCompositingDescendantsWithBorderRadius() const
 {
     // FIXME(sky): Remove
     return false;
 }
 
 bool RenderLayer::paintsWithTransform(PaintBehavior paintBehavior) const
 {
-    return transform() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || compositingState() != PaintsIntoOwnBacking);
+    // FIXME(sky): Remove
+    return transform();
 }
 
 bool RenderLayer::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
         return false;
 
     if (paintsWithTransparency(PaintBehaviorNormal))
         return false;
 
@@ skipping 191 matching lines @@
 }
 
 void RenderLayer::filterNeedsPaintInvalidation()
 {
 }
 
 void RenderLayer::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants()
 {
     renderer()->setShouldDoFullPaintInvalidation(true);
 
-    // Disable for reading compositingState() in isPaintInvalidationContainer() below.
-    DisableCompositingQueryAsserts disabler;
-
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
         if (!child->isPaintInvalidationContainer())
             child->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
     }
 }
 
 DisableCompositingQueryAsserts::DisableCompositingQueryAsserts()
     : m_disabler(gCompositingQueryMode, CompositingQueriesAreAllowed) { }
 
 } // namespace blink
@@ skipping 10 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif