Make compositingState explicit

Source/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 229 matching lines @@
         m_backing->contentChanged(changeType);
 }
 
 bool RenderLayer::canRender3DTransforms() const
 {
     return compositor()->canRender3DTransforms();
 }
 
 bool RenderLayer::paintsWithFilters() const
 {
-    // FIXME: Eventually there will be more factors than isComposited() to decide whether or not to render the filter
     if (!renderer()->hasFilter())
         return false;
 
-    if (!isComposited())
+    // FIXME: shouldn't we return true if this layer has a backing but paints into its ancestor?

[Ian Vollick, 2013/10/01 19:46:22]

Whatever we decide for paintsWithTransparency, the same should go for the other
paintsWith* fn's.

[shawnsingh, 2013/10/03 03:04:04]

done.

+    if (!backing())
         return true;
 
     if (!m_backing || !m_backing->canCompositeFilters())
         return true;
 
     return false;
 }
 
 bool RenderLayer::requiresFullLayerImageForFilters() const
 {
@@ skipping 94 matching lines @@
         clearRepaintRects();
 
     m_repaintStatus = NeedsNormalRepaint;
 
     // Go ahead and update the reflection's position and size.
     if (m_reflection)
         m_reflection->layout();
 
     // Clear the IsCompositingUpdateRoot flag once we've found the first compositing layer in this update.
     bool isUpdateRoot = (flags & IsCompositingUpdateRoot);
-    if (isComposited())
+    if (backing())
         flags &= ~IsCompositingUpdateRoot;
 
     if (useRegionBasedColumns() && renderer()->isInFlowRenderFlowThread()) {
         updatePagination();
         flags |= UpdatePagination;
     }
 
     if (renderer()->hasColumns())
         flags |= UpdatePagination;
 
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->updateLayerPositions(geometryMap, flags);
 
-    if ((flags & UpdateCompositingLayers) && isComposited()) {
+    if ((flags & UpdateCompositingLayers) && backing()) {
         RenderLayerBacking::UpdateAfterLayoutFlags updateFlags = RenderLayerBacking::CompositingChildrenOnly;
         if (flags & NeedsFullRepaintInBacking)
             updateFlags |= RenderLayerBacking::NeedsFullRepaint;
         if (isUpdateRoot)
             updateFlags |= RenderLayerBacking::IsUpdateRoot;
         backing()->updateAfterLayout(updateFlags);
     }
 
     if (geometryMap)
         geometryMap->popMappingsToAncestor(parent());
 }
 
 LayoutRect RenderLayer::repaintRectIncludingNonCompositingDescendants() const
 {
     LayoutRect repaintRect = m_repaintRect;
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
         // Don't include repaint rects for composited child layers; they will paint themselves and have a different origin.
-        if (child->isComposited())
+        if (child->backing())
             continue;
 
         repaintRect.unite(child->repaintRectIncludingNonCompositingDescendants());
     }
     return repaintRect;
 }
 
 void RenderLayer::setAncestorChainHasSelfPaintingLayerDescendant()
 {
     for (RenderLayer* layer = this; layer; layer = layer->parent()) {
@@ skipping 516 matching lines @@
 {
     const Settings* settings = renderer()->document().settings();
     return settings && settings->regionBasedColumnsEnabled();
 }
 
 void RenderLayer::updatePagination()
 {
     m_isPaginated = false;
     m_enclosingPaginationLayer = 0;
 
-    if (isComposited() || !parent())
+    if (backing() || !parent())
         return; // FIXME: We will have to deal with paginated compositing layers someday.
                 // FIXME: For now the RenderView can't be paginated.  Eventually printing will move to a model where it is though.
 
     // The main difference between the paginated booleans for the old column code and the new column code
     // is that each paginated layer has to paint on its own with the new code. There is no
     // recurring into child layers. This means that the m_isPaginated bits for the new column code can't just be set on
     // "roots" that get split and paint all their descendants. Instead each layer has to be checked individually and
     // genuinely know if it is going to have to split itself up when painting only its contents (and not any other descendant
     // layers). We track an enclosingPaginationLayer instead of using a simple bit, since we want to be able to get back
     // to that layer easily.
@@ skipping 289 matching lines @@
         if (positionedParent->renderer()->hasOverflowClip()) {
             LayoutSize offset = positionedParent->scrolledContentOffset();
             localPoint -= offset;
         }
 
         if (renderer()->isOutOfFlowPositioned() && positionedParent->renderer()->isInFlowPositioned() && positionedParent->renderer()->isRenderInline()) {
             LayoutSize offset = toRenderInline(positionedParent->renderer())->offsetForInFlowPositionedInline(toRenderBox(renderer()));
             localPoint += offset;
         }
     } else if (parent()) {
-        if (isComposited()) {
+        if (backing()) {
             // FIXME: Composited layers ignore pagination, so about the best we can do is make sure they're offset into the appropriate column.
             // They won't split across columns properly.
             LayoutSize columnOffset;
             if (!parent()->renderer()->hasColumns() && parent()->renderer()->isRoot() && renderer()->view()->hasColumns())
                 renderer()->view()->adjustForColumns(columnOffset, localPoint);
             else
                 parent()->renderer()->adjustForColumns(columnOffset, localPoint);
 
             localPoint += columnOffset;
         }
@@ skipping 155 matching lines @@
 }
 
 inline bool RenderLayer::shouldRepaintAfterLayout() const
 {
     if (m_repaintStatus == NeedsNormalRepaint)
         return true;
 
     // Composited layers that were moved during a positioned movement only
     // layout, don't need to be repainted. They just need to be recomposited.
     ASSERT(m_repaintStatus == NeedsFullRepaintForPositionedMovementLayout);
-    return !isComposited();
+    return !backing();
 }
 
+// FIXME: having two different functions named enclosingCompositingLayer and enclosingCompositingLayerForRepaint
+//        is error-prone and misleading for reading code that uses these functions - especially compounded with
+//        the includeSelf option.
 RenderLayer* RenderLayer::enclosingCompositingLayer(bool includeSelf) const
 {
-    if (includeSelf && isComposited())
+    if (includeSelf && backing())
         return const_cast<RenderLayer*>(this);
 
     for (const RenderLayer* curr = compositingContainer(this); curr; curr = compositingContainer(curr)) {
-        if (curr->isComposited())
+        if (curr->backing())
             return const_cast<RenderLayer*>(curr);
     }
 
     return 0;
 }
 
 RenderLayer* RenderLayer::enclosingCompositingLayerForRepaint(bool includeSelf) const
 {
-    if (includeSelf && isComposited() && !backing()->paintsIntoCompositedAncestor())
+    if (includeSelf && compositingState() == PaintsIntoOwnBacking)
         return const_cast<RenderLayer*>(this);
 
     for (const RenderLayer* curr = compositingContainer(this); curr; curr = compositingContainer(curr)) {
-        if (curr->isComposited() && !curr->backing()->paintsIntoCompositedAncestor())
+        if (curr->compositingState() == PaintsIntoOwnBacking)
             return const_cast<RenderLayer*>(curr);
     }
 
     return 0;
 }
 
 RenderLayer* RenderLayer::ancestorScrollingLayer() const
 {
     if (!acceleratedCompositingForOverflowScrollEnabled())
         return 0;
@@ skipping 17 matching lines @@
         if (curr->requiresFullLayerImageForFilters())
             return const_cast<RenderLayer*>(curr);
     }
 
     return 0;
 }
 
 RenderLayer* RenderLayer::enclosingFilterRepaintLayer() const
 {
     for (const RenderLayer* curr = this; curr; curr = curr->parent()) {
-        if ((curr != this && curr->requiresFullLayerImageForFilters()) || curr->isComposited() || curr->isRootLayer())
+        if ((curr != this && curr->requiresFullLayerImageForFilters()) || curr->compositingState() == PaintsIntoOwnBacking || curr->isRootLayer())
             return const_cast<RenderLayer*>(curr);
     }
     return 0;
 }
 
 void RenderLayer::setFilterBackendNeedsRepaintingInRect(const LayoutRect& rect)
 {
     if (rect.isEmpty())
         return;
 
@@ skipping 10 matching lines @@
         // shader can address any ouput pixel.
         // Note: This is only for output rect, so there's no need to expand the dirty source rect.
         rectForRepaint.unite(calculateLayerBounds(this));
     }
 
     RenderLayer* parentLayer = enclosingFilterRepaintLayer();
     ASSERT(parentLayer);
     FloatQuad repaintQuad(rectForRepaint);
     LayoutRect parentLayerRect = renderer()->localToContainerQuad(repaintQuad, parentLayer->renderer()).enclosingBoundingBox();
 
-    if (parentLayer->isComposited()) {
+    if (parentLayer->backing()) {
         parentLayer->setBackingNeedsRepaintInRect(parentLayerRect);
         return;
     }
 
     if (parentLayer->paintsWithFilters()) {
         parentLayer->setFilterBackendNeedsRepaintingInRect(parentLayerRect);
         return;
     }
 
     if (parentLayer->isRootLayer()) {
@@ skipping 10 matching lines @@
     for (const RenderLayer* curr = this; curr; curr = curr->parent()) {
         RenderLayerModelObject* renderer = curr->renderer();
         if (renderer->style()->hasFilterOutsets())
             return true;
     }
     return false;
 }
 
 RenderLayer* RenderLayer::clippingRootForPainting() const
 {
-    if (isComposited())
+    if (backing())
         return const_cast<RenderLayer*>(this);
 
     const RenderLayer* current = this;
     while (current) {
         if (current->isRootLayer())
             return const_cast<RenderLayer*>(current);
 
         current = compositingContainer(current);
         ASSERT(current);
         if (current->transform()
-            || (current->isComposited() && !current->backing()->paintsIntoCompositedAncestor())
+            || (current->backing() && !current->backing()->paintsIntoCompositedAncestor())
         )
             return const_cast<RenderLayer*>(current);
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 LayoutPoint RenderLayer::absoluteToContents(const LayoutPoint& absolutePoint) const
 {
@@ skipping 14 matching lines @@
 {
     // FIXME: This seems incorrect; why would SVG layers be opaque?
     if (renderer()->node() && renderer()->node()->namespaceURI() == SVGNames::svgNamespaceURI)
         return false;
 
     return renderer()->isTransparent() || renderer()->hasMask();
 }
 
 RenderLayer* RenderLayer::transparentPaintingAncestor()
 {
-    if (isComposited())
+    if (backing())
         return 0;
 
     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
-        if (curr->isComposited())
+        if (curr->backing())
             return 0;
         if (curr->isTransparent())
             return curr;
     }
     return 0;
 }
 
 enum TransparencyClipBoxBehavior {
     PaintingTransparencyClipBox,
     HitTestingTransparencyClipBox
@@ skipping 418 matching lines @@
 }
 
 bool RenderLayer::usesCompositedScrolling() const
 {
     RenderBox* box = renderBox();
 
     // Scroll form controls on the main thread so they exhibit correct touch scroll event bubbling
     if (box && (box->isIntristicallyScrollable(VerticalScrollbar) || box->isIntristicallyScrollable(HorizontalScrollbar)))
         return false;
 
-    return isComposited() && backing()->scrollingLayer();
+    return backing() && backing()->scrollingLayer();
 }
 
 bool RenderLayer::needsCompositedScrolling() const
 {
     if (!compositorDrivenAcceleratedScrollingEnabled())
         return needsToBeStackingContainer();
     if (FrameView* frameView = renderer()->view()->frameView())
         return frameView->containsScrollableArea(scrollableArea());
     return false;
 }
@@ skipping 705 matching lines @@
     RenderBox* box = renderBox();
     if (!box)
         return;
 
     m_scrollableArea->positionOverflowControls(offsetFromRoot);
 
     const IntRect borderBox = box->pixelSnappedBorderBoxRect();
     if (m_resizer)
         m_resizer->setFrameRect(resizerCornerRect(borderBox, ResizerForPointer));
 
-    if (isComposited())
+    if (backing())
         backing()->positionOverflowControlsLayers(offsetFromRoot);
 }
 
 int RenderLayer::scrollWidth() const
 {
     return m_scrollableArea->scrollWidth();
 }
 
 int RenderLayer::scrollHeight() const
 {
@@ skipping 271 matching lines @@
     return false;
 }
 
 static bool paintForFixedRootBackground(const RenderLayer* layer, RenderLayer::PaintLayerFlags paintFlags)
 {
     return layer->renderer()->isRoot() && (paintFlags & RenderLayer::PaintLayerPaintingRootBackgroundOnly);
 }
 
 void RenderLayer::paintLayer(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
 {
-    if (isComposited()) {
+    if (backing()) {
         // The updatingControlTints() painting pass goes through compositing layers,
         // but we need to ensure that we don't cache clip rects computed with the wrong root in this case.
         if (context->updatingControlTints() || (paintingInfo.paintBehavior & PaintBehaviorFlattenCompositingLayers)) {
             paintFlags |= PaintLayerTemporaryClipRects;
         } else if (!backing()->paintsIntoCompositedAncestor()
             && !shouldDoSoftwarePaint(this, paintFlags & PaintLayerPaintingReflection)
             && !paintForFixedRootBackground(this, paintFlags)) {
             // If this RenderLayer should paint into its backing, that will be done via RenderLayerBacking::paintIntoLayer().
             return;
         }
@@ skipping 1791 matching lines @@
             return pixelSnappedIntRect(localClipRect);
         }
     }
 
     // FIXME: should probably just pass 'flags' down to descendants.
     CalculateLayerBoundsFlags descendantFlags = DefaultCalculateLayerBoundsFlags | (flags & ExcludeHiddenDescendants) | (flags & IncludeCompositedDescendants);
 
     const_cast<RenderLayer*>(this)->updateLayerListsIfNeeded();
 
     if (RenderLayer* reflection = reflectionLayer()) {
-        if (!reflection->isComposited()) {
+        if (!reflection->backing()) {
             IntRect childUnionBounds = reflection->calculateLayerBounds(this, 0, descendantFlags);
             unionBounds.unite(childUnionBounds);
         }
     }
 
     ASSERT(isStackingContainer() || (!posZOrderList() || !posZOrderList()->size()));
 
 #if !ASSERT_DISABLED
     LayerListMutationDetector mutationChecker(const_cast<RenderLayer*>(this));
 #endif
 
     if (Vector<RenderLayer*>* negZOrderList = this->negZOrderList()) {
         size_t listSize = negZOrderList->size();
         for (size_t i = 0; i < listSize; ++i) {
             RenderLayer* curLayer = negZOrderList->at(i);
-            if (flags & IncludeCompositedDescendants || !curLayer->isComposited()) {
+            if (flags & IncludeCompositedDescendants || !curLayer->backing()) {
                 IntRect childUnionBounds = curLayer->calculateLayerBounds(this, 0, descendantFlags);
                 unionBounds.unite(childUnionBounds);
             }
         }
     }
 
     if (Vector<RenderLayer*>* posZOrderList = this->posZOrderList()) {
         size_t listSize = posZOrderList->size();
         for (size_t i = 0; i < listSize; ++i) {
             RenderLayer* curLayer = posZOrderList->at(i);
-            if (flags & IncludeCompositedDescendants || !curLayer->isComposited()) {
+            if (flags & IncludeCompositedDescendants || !curLayer->backing()) {
                 IntRect childUnionBounds = curLayer->calculateLayerBounds(this, 0, descendantFlags);
                 unionBounds.unite(childUnionBounds);
             }
         }
     }
 
     if (Vector<RenderLayer*>* normalFlowList = this->normalFlowList()) {
         size_t listSize = normalFlowList->size();
         for (size_t i = 0; i < listSize; ++i) {
             RenderLayer* curLayer = normalFlowList->at(i);
-            if (flags & IncludeCompositedDescendants || !curLayer->isComposited()) {
+            if (flags & IncludeCompositedDescendants || !curLayer->backing()) {
                 IntRect curAbsBounds = curLayer->calculateLayerBounds(this, 0, descendantFlags);
                 unionBounds.unite(curAbsBounds);
             }
         }
     }
 
     // FIXME: We can optimize the size of the composited layers, by not enlarging
     // filtered areas with the outsets if we know that the filter is going to render in hardware.
     // https://bugs.webkit.org/show_bug.cgi?id=81239
     if (flags & IncludeLayerFilterOutsets)
@@ skipping 32 matching lines @@
     if (typeToClear == AllClipRectTypes)
         m_clipRectsCache = nullptr;
     else {
         ASSERT(typeToClear < NumCachedClipRectsTypes);
         RefPtr<ClipRects> dummy;
         m_clipRectsCache->setClipRects(typeToClear, RespectOverflowClip, dummy);
         m_clipRectsCache->setClipRects(typeToClear, IgnoreOverflowClip, dummy);
     }
 }
 
+CompositingState RenderLayer::compositingState() const
+{
+    // This is computed procedurally so there is no redundant state variable that
+    // can get out of sync from the real actual compositing state.
+
+    if (!m_backing)
+        return NotComposited;
+
+    if (m_backing && backing()->paintsIntoCompositedAncestor())
+        return HasOwnBackingButPaintsIntoAncestor;
+
+    ASSERT(m_backing);
+    return PaintsIntoOwnBacking;
+}
+
 RenderLayerBacking* RenderLayer::ensureBacking()
 {
     if (!m_backing) {
         m_backing = adoptPtr(new RenderLayerBacking(this));
         compositor()->layerBecameComposited(this);
 
         updateOrRemoveFilterEffectRenderer();
 
         if (RuntimeEnabledFeatures::cssCompositingEnabled())
             backing()->setBlendMode(m_blendMode);
@@ skipping 41 matching lines @@
     return m_backing ? m_backing->layerForVerticalScrollbar() : 0;
 }
 
 GraphicsLayer* RenderLayer::layerForScrollCorner() const
 {
     return m_backing ? m_backing->layerForScrollCorner() : 0;
 }
 
 bool RenderLayer::paintsWithTransform(PaintBehavior paintBehavior) const
 {
-    return transform() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited());
+    // FIXME: shouldn't we return true if this layer has a backing but paints into its ancestor?
+    return transform() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !backing());
 }
 
 bool RenderLayer::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
         return false;
 
     if (paintsWithTransparency(PaintBehaviorNormal))
         return false;
 
@@ skipping 30 matching lines @@
         || listBackgroundIsKnownToBeOpaqueInRect(normalFlowList(), localRect);
 }
 
 bool RenderLayer::listBackgroundIsKnownToBeOpaqueInRect(const Vector<RenderLayer*>* list, const LayoutRect& localRect) const
 {
     if (!list || list->isEmpty())
         return false;
 
     for (Vector<RenderLayer*>::const_reverse_iterator iter = list->rbegin(); iter != list->rend(); ++iter) {
         const RenderLayer* childLayer = *iter;
-        if (childLayer->isComposited())
+        if (childLayer->backing())
             continue;
 
         if (!childLayer->canUseConvertToLayerCoords())
             continue;
 
         LayoutPoint childOffset;
         LayoutRect childLocalRect(localRect);
         childLayer->convertToLayerCoords(this, childOffset);
         childLocalRect.moveBy(-childOffset);
 
@@ skipping 236 matching lines @@
 
 void RenderLayer::repaintIncludingDescendants()
 {
     renderer()->repaint();
     for (RenderLayer* curr = firstChild(); curr; curr = curr->nextSibling())
         curr->repaintIncludingDescendants();
 }
 
 void RenderLayer::setBackingNeedsRepaint()
 {
-    ASSERT(isComposited());
+    ASSERT(backing());
     backing()->setContentsNeedDisplay();
 }
 
 void RenderLayer::setBackingNeedsRepaintInRect(const LayoutRect& r)
 {
     // https://bugs.webkit.org/show_bug.cgi?id=61159 describes an unreproducible crash here,
     // so assert but check that the layer is composited.
-    ASSERT(isComposited());
-    if (!isComposited()) {
+    ASSERT(backing());
+    if (!backing()) {
         // If we're trying to repaint the placeholder document layer, propagate the
         // repaint to the native view system.
         LayoutRect absRect(r);
         LayoutPoint delta;
         convertToLayerCoords(root(), delta);
         absRect.moveBy(delta);
 
         RenderView* view = renderer()->view();
         if (view)
             view->repaintViewRectangle(absRect);
     } else
         backing()->setContentsNeedDisplayInRect(pixelSnappedIntRect(r));
 }
 
 // Since we're only painting non-composited layers, we know that they all share the same repaintContainer.
 void RenderLayer::repaintIncludingNonCompositingDescendants(RenderLayerModelObject* repaintContainer)
 {
     renderer()->repaintUsingContainer(repaintContainer, pixelSnappedIntRect(renderer()->clippedOverflowRectForRepaint(repaintContainer)));
 
     for (RenderLayer* curr = firstChild(); curr; curr = curr->nextSibling()) {
-        if (!curr->isComposited())
+        if (!curr->backing())
             curr->repaintIncludingNonCompositingDescendants(repaintContainer);
     }
 }
 
 bool RenderLayer::shouldBeNormalFlowOnly() const
 {
     return shouldBeNormalFlowOnlyIgnoringCompositedScrolling() && !needsCompositedScrolling();
 }
 
 bool RenderLayer::shouldBeNormalFlowOnlyIgnoringCompositedScrolling() const
@@ skipping 185 matching lines @@
 
 inline bool RenderLayer::needsCompositingLayersRebuiltForClip(const RenderStyle* oldStyle, const RenderStyle* newStyle) const
 {
     ASSERT(newStyle);
     return oldStyle && (oldStyle->clip() != newStyle->clip() || oldStyle->hasClip() != newStyle->hasClip());
 }
 
 inline bool RenderLayer::needsCompositingLayersRebuiltForOverflow(const RenderStyle* oldStyle, const RenderStyle* newStyle) const
 {
     ASSERT(newStyle);
-    return !isComposited() && oldStyle && (oldStyle->overflowX() != newStyle->overflowX()) && ancestorStackingContainer()->hasCompositingDescendant();
+    return !backing() && oldStyle && (oldStyle->overflowX() != newStyle->overflowX()) && ancestorStackingContainer()->hasCompositingDescendant();
 }
 
 inline bool RenderLayer::needsCompositingLayersRebuiltForFilters(const RenderStyle* oldStyle, const RenderStyle* newStyle, bool didPaintWithFilters) const
 {
     if (!hasOrHadFilters(oldStyle, newStyle))
         return false;
 
     if (renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyWebkitFilter)) {
         // When the compositor is performing the filter animation, we shouldn't touch the compositing layers.
         // All of the layers above us should have been promoted to compositing layers already.
@@ skipping 23 matching lines @@
 }
 
 void RenderLayer::updateFilters(const RenderStyle* oldStyle, const RenderStyle* newStyle)
 {
     if (!hasOrHadFilters(oldStyle, newStyle))
         return;
 
     updateOrRemoveFilterClients();
     // During an accelerated animation, both WebKit and the compositor animate properties.
     // However, WebKit shouldn't ask the compositor to update its filters if the compositor is performing the animation.
-    bool shouldUpdateFilters = isComposited() && !renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyWebkitFilter);
+    bool shouldUpdateFilters = backing() && !renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyWebkitFilter);
     if (shouldUpdateFilters)
         backing()->updateFilters(renderer()->style());
     updateOrRemoveFilterEffectRenderer();
 }
 
 void RenderLayer::styleChanged(StyleDifference, const RenderStyle* oldStyle)
 {
     updateIsNormalFlowOnly();
 
     updateResizerAreaSet();
@@ skipping 27 matching lines @@
     if (paintsWithFilters())
         didPaintWithFilters = true;
     updateFilters(oldStyle, renderer()->style());
 
     const RenderStyle* newStyle = renderer()->style();
     if (compositor()->updateLayerCompositingState(this)
         || needsCompositingLayersRebuiltForClip(oldStyle, newStyle)
         || needsCompositingLayersRebuiltForOverflow(oldStyle, newStyle)
         || needsCompositingLayersRebuiltForFilters(oldStyle, newStyle, didPaintWithFilters))
         compositor()->setCompositingLayersNeedRebuild();
-    else if (isComposited())
+    else if (backing())
         backing()->updateGraphicsLayerGeometry();
 }
 
 void RenderLayer::updateResizerAreaSet() {
     Frame* frame = renderer()->frame();
     if (!frame)
         return;
     FrameView* frameView = frame->view();
     if (!frameView)
         return;
@@ skipping 341 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif