Use a boolean hasCompositedLayerMapping() accessor instead of the pointer

Source/core/rendering/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 284 matching lines @@
 
     IntRect visibleRect = m_containerLayer ? IntRect(IntPoint(), frameView->contentsSize()) : frameView->visibleContentRect();
     if (rootLayer->visibleRectChangeRequiresFlush(visibleRect)) {
         if (Page* page = this->page())
             page->chrome().client().scheduleCompositingLayerFlush();
     }
 }
 
 bool RenderLayerCompositor::hasAnyAdditionalCompositedLayers(const RenderLayer* rootLayer) const
 {
-    return m_compositedLayerCount > (rootLayer->compositedLayerMapping() ? 1 : 0);
+    return m_compositedLayerCount > (rootLayer->hasCompositedLayerMapping() ? 1 : 0);
 }
 
 void RenderLayerCompositor::updateCompositingRequirementsState()
 {
     if (!m_needsUpdateCompositingRequirementsState)
         return;
 
     TRACE_EVENT0("blink_rendering,comp-scroll", "RenderLayerCompositor::updateCompositingRequirementsState");
 
     m_needsUpdateCompositingRequirementsState = false;
@@ skipping 130 matching lines @@
         // Update the hierarchy of the compositing layers.
         Vector<GraphicsLayer*> childList;
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::rebuildCompositingLayerTree");
             rebuildCompositingLayerTree(updateRoot, childList, 0);
         }
 
         // Host the document layer in the RenderView's root layer.
         if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && isMainFrame()) {
             RenderVideo* video = findFullscreenVideoRenderer(&m_renderView->document());
-            if (video) {
+            if (video && video->hasCompositedLayerMapping()) {
                 CompositedLayerMapping* compositedLayerMapping = video->compositedLayerMapping();
-                if (compositedLayerMapping) {
-                    childList.clear();
-                    childList.append(compositedLayerMapping->mainGraphicsLayer());
-                }
+                ASSERT(compositedLayerMapping);

[hartmanng, 2013/11/04 22:56:09]

Personally, I'd just take this out - seems inconsistent to ASSERT this here, but
everywhere else just checking hasCompositedLayerMapping() is enough.

+                childList.clear();
+                childList.append(compositedLayerMapping->mainGraphicsLayer());
             }
         }
         // Even when childList is empty, don't drop out of compositing mode if there are
         // composited layers that we didn't hit in our traversal (e.g. because of visibility:hidden).
         if (childList.isEmpty() && !hasAnyAdditionalCompositedLayers(updateRoot))
             destroyRootLayer();
         else
             m_rootContentLayer->setChildren(childList);
     } else if (needGeometryUpdate) {
         // We just need to do a geometry update. This is only used for position:fixed scrolling;
@@ skipping 42 matching lines @@
     bool compositedLayerMappingChanged = false;
     RenderLayer::ViewportConstrainedNotCompositedReason viewportConstrainedNotCompositedReason = RenderLayer::NoNotCompositedReason;
     requiresCompositingForPosition(layer->renderer(), layer, &viewportConstrainedNotCompositedReason);
 
     // FIXME: It would be nice to directly use the layer's compositing reason,
     // but allocateOrClearCompositedLayerMapping also gets called without having updated compositing
     // requirements fully.
     if (needsToBeComposited(layer)) {
         enableCompositingMode();
 
-        if (!layer->compositedLayerMapping()) {
+        if (!layer->hasCompositedLayerMapping()) {
             // If we need to repaint, do so before allocating the compositedLayerMapping
             if (shouldRepaint == CompositingChangeRepaintNow)
                 repaintOnCompositingChange(layer);
 
             layer->ensureCompositedLayerMapping();
             compositedLayerMappingChanged = true;
 
             // At this time, the ScrollingCooridnator only supports the top-level frame.
             if (layer->isRootLayer() && !isMainFrame()) {
                 if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
                     scrollingCoordinator->frameViewRootLayerDidChange(m_renderView->frameView());
             }
 
             // This layer and all of its descendants have cached repaints rects that are relative to
             // the repaint container, so change when compositing changes; we need to update them here.
             if (layer->parent())
                 layer->repainter().computeRepaintRectsIncludingDescendants();
         }
 
         if (layer->compositedLayerMapping()->updateRequiresOwnBackingStoreForIntrinsicReasons())
             compositedLayerMappingChanged = true;
     } else {
-        if (layer->compositedLayerMapping()) {
+        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
             // are both either composited, or not composited.
             if (layer->isReflection()) {
                 RenderLayer* sourceLayer = toRenderLayerModelObject(layer->renderer()->parent())->layer();
-                if (CompositedLayerMapping* compositedLayerMapping = sourceLayer->compositedLayerMapping()) {
+                if (sourceLayer->hasCompositedLayerMapping()) {
+                    CompositedLayerMapping* compositedLayerMapping = sourceLayer->compositedLayerMapping();
                     ASSERT(compositedLayerMapping->mainGraphicsLayer()->replicaLayer() == layer->compositedLayerMapping()->mainGraphicsLayer());
                     compositedLayerMapping->mainGraphicsLayer()->setReplicatedByLayer(0);
                 }
             }
 
             removeViewportConstrainedLayer(layer);
 
             layer->clearCompositedLayerMapping();
             compositedLayerMappingChanged = true;
 
@@ skipping 33 matching lines @@
     return compositedLayerMappingChanged || nonCompositedReasonChanged;
 }
 
 bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer, CompositingChangeRepaint shouldRepaint)
 {
     updateDirectCompositingReasons(layer);
     bool layerChanged = allocateOrClearCompositedLayerMapping(layer, shouldRepaint);
 
     // See if we need content or clipping layers. Methods called here should assume
     // that the compositing state of descendant layers has not been updated yet.
-    if (layer->compositedLayerMapping() && layer->compositedLayerMapping()->updateGraphicsLayerConfiguration())
+    if (layer->hasCompositedLayerMapping() && layer->compositedLayerMapping()->updateGraphicsLayerConfiguration())
         layerChanged = true;
 
     return layerChanged;
 }
 
 void RenderLayerCompositor::repaintOnCompositingChange(RenderLayer* layer)
 {
     // If the renderer is not attached yet, no need to repaint.
     if (layer->renderer() != m_renderView && !layer->renderer()->parent())
         return;
@@ skipping 38 matching lines @@
     return layer->calculateLayerBounds(ancestorLayer, 0, flags);
 }
 
 void RenderLayerCompositor::layerWasAdded(RenderLayer* /*parent*/, RenderLayer* /*child*/)
 {
     setCompositingLayersNeedRebuild();
 }
 
 void RenderLayerCompositor::layerWillBeRemoved(RenderLayer* parent, RenderLayer* child)
 {
-    if (!child->compositedLayerMapping() || parent->renderer()->documentBeingDestroyed())
+    if (!child->hasCompositedLayerMapping() || parent->renderer()->documentBeingDestroyed())
         return;
 
     removeViewportConstrainedLayer(child);
     repaintInCompositedAncestor(child, child->compositedLayerMapping()->compositedBounds());
 
     setCompositingParent(child, 0);
     setCompositingLayersNeedRebuild();
 }
 
 RenderLayer* RenderLayerCompositor::enclosingNonStackingClippingLayer(const RenderLayer* layer) const
@@ skipping 296 matching lines @@
 
     descendantHas3DTransform |= anyDescendantHas3DTransform || layer->has3DTransform();
 
     if (overlapMap)
         overlapMap->geometryMap().popMappingsToAncestor(ancestorLayer);
 }
 
 void RenderLayerCompositor::setCompositingParent(RenderLayer* childLayer, RenderLayer* parentLayer)
 {
     ASSERT(!parentLayer || childLayer->ancestorCompositingLayer() == parentLayer);
-    ASSERT(childLayer->compositedLayerMapping());
+    ASSERT(childLayer->hasCompositedLayerMapping());
 
     // It's possible to be called with a parent that isn't yet composited when we're doing
     // partial updates as required by painting or hit testing. Just bail in that case;
     // we'll do a full layer update soon.
-    if (!parentLayer || !parentLayer->compositedLayerMapping())
+    if (!parentLayer || !parentLayer->hasCompositedLayerMapping())
         return;
 
     if (parentLayer) {
         GraphicsLayer* hostingLayer = parentLayer->compositedLayerMapping()->parentForSublayers();
         GraphicsLayer* hostedLayer = childLayer->compositedLayerMapping()->childForSuperlayers();
 
         hostingLayer->addChild(hostedLayer);
     } else {
         childLayer->compositedLayerMapping()->childForSuperlayers()->removeFromParent();
     }
 }
 
 void RenderLayerCompositor::removeCompositedChildren(RenderLayer* layer)
 {
-    ASSERT(layer->compositedLayerMapping());
+    ASSERT(layer->hasCompositedLayerMapping());
 
     GraphicsLayer* hostingLayer = layer->compositedLayerMapping()->parentForSublayers();
     hostingLayer->removeAllChildren();
 }
 
 bool RenderLayerCompositor::canAccelerateVideoRendering(RenderVideo* o) const
 {
     if (!m_hasAcceleratedCompositing)
         return false;
 
@@ skipping 11 matching lines @@
     // Used for gathering UMA data about the effect on memory usage of promoting all layers
     // that have a webkit-transition on opacity or transform and intersect the viewport.
     static double pixelsWithoutPromotingAllTransitions = 0.0;
     static double pixelsAddedByPromotingAllTransitions = 0.0;
 
     if (!depth) {
         pixelsWithoutPromotingAllTransitions = 0.0;
         pixelsAddedByPromotingAllTransitions = 0.0;
     }
 
-    CompositedLayerMapping* currentCompositedLayerMapping = layer->compositedLayerMapping();
-    if (currentCompositedLayerMapping) {
+    if (layer->hasCompositedLayerMapping()) {
+        CompositedLayerMapping* currentCompositedLayerMapping = layer->compositedLayerMapping();
         // The compositing state of all our children has been updated already, so now
         // we can compute and cache the composited bounds for this layer.
         currentCompositedLayerMapping->updateCompositedBounds();
 
         if (layer->reflectionInfo()) {
             RenderLayer* reflectionLayer = layer->reflectionInfo()->reflectionLayer();
-            if (reflectionLayer->compositedLayerMapping())
+            if (reflectionLayer->hasCompositedLayerMapping())
                 reflectionLayer->compositedLayerMapping()->updateCompositedBounds();
         }
 
         currentCompositedLayerMapping->updateGraphicsLayerConfiguration();
         currentCompositedLayerMapping->updateGraphicsLayerGeometry();
 
         if (!layer->parent())
             updateRootLayerPosition();
 
         if (currentCompositedLayerMapping->hasUnpositionedOverflowControlsLayers())
             layer->scrollableArea()->positionOverflowControls();
 
         pixelsWithoutPromotingAllTransitions += layer->size().height() * layer->size().width();
     } else {
         if ((layer->renderer()->style()->transitionForProperty(CSSPropertyOpacity) ||
              layer->renderer()->style()->transitionForProperty(CSSPropertyWebkitTransform)) &&
             m_renderView->viewRect().intersects(layer->absoluteBoundingBox()))
             pixelsAddedByPromotingAllTransitions += layer->size().height() * layer->size().width();
     }
 
     // If this layer has a compositedLayerMapping, then that is where we place subsequent children GraphicsLayers.
     // Otherwise children continue to append to the child list of the enclosing layer.
     Vector<GraphicsLayer*> layerChildren;
-    Vector<GraphicsLayer*>& childList = currentCompositedLayerMapping ? layerChildren : childLayersOfEnclosingLayer;
+    Vector<GraphicsLayer*>& childList = layer->hasCompositedLayerMapping() ? layerChildren : childLayersOfEnclosingLayer;
 
 #if !ASSERT_DISABLED
     LayerListMutationDetector mutationChecker(layer->stackingNode());
 #endif
 
     if (layer->stackingNode()->isStackingContainer()) {
         RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NegativeZOrderChildren);
         while (RenderLayerStackingNode* curNode = iterator.next())
             rebuildCompositingLayerTree(curNode->layer(), childList, depth + 1);
 
         // If a negative z-order child is compositing, we get a foreground layer which needs to get parented.
-        if (currentCompositedLayerMapping && currentCompositedLayerMapping->foregroundLayer())
-            childList.append(currentCompositedLayerMapping->foregroundLayer());
+        if (layer->hasCompositedLayerMapping() && layer->compositedLayerMapping()->foregroundLayer())
+            childList.append(layer->compositedLayerMapping()->foregroundLayer());
     }
 
     RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
     while (RenderLayerStackingNode* curNode = iterator.next())
         rebuildCompositingLayerTree(curNode->layer(), childList, depth + 1);
 
-    if (currentCompositedLayerMapping) {
+    if (layer->hasCompositedLayerMapping()) {
+        CompositedLayerMapping* currentCompositedLayerMapping = layer->compositedLayerMapping();
         bool parented = false;
         if (layer->renderer()->isRenderPart())
             parented = parentFrameContentLayers(toRenderPart(layer->renderer()));
 
         if (!parented)
             currentCompositedLayerMapping->parentForSublayers()->setChildren(layerChildren);
 
         // If the layer has a clipping layer the overflow controls layers will be siblings of the clipping layer.
         // Otherwise, the overflow control layers are normal children.
         if (!currentCompositedLayerMapping->hasClippingLayer() && !currentCompositedLayerMapping->hasScrollingLayer()) {
@@ skipping 162 matching lines @@
     return 0;
 }
 
 bool RenderLayerCompositor::parentFrameContentLayers(RenderPart* renderer)
 {
     RenderLayerCompositor* innerCompositor = frameContentsCompositor(renderer);
     if (!innerCompositor || !innerCompositor->inCompositingMode() || innerCompositor->rootLayerAttachment() != RootLayerAttachedViaEnclosingFrame)
         return false;
 
     RenderLayer* layer = renderer->layer();
-    if (!layer->compositedLayerMapping())
+    if (!layer->hasCompositedLayerMapping())
         return false;
 
     CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping();
     GraphicsLayer* hostingLayer = compositedLayerMapping->parentForSublayers();
     GraphicsLayer* rootLayer = innerCompositor->rootGraphicsLayer();
     if (hostingLayer->children().size() != 1 || hostingLayer->children()[0] != rootLayer) {
         hostingLayer->removeAllChildren();
         hostingLayer->addChild(rootLayer);
     }
     return true;
 }
 
 // This just updates layer geometry without changing the hierarchy.
 void RenderLayerCompositor::updateLayerTreeGeometry(RenderLayer* layer)
 {
-    if (CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping()) {
+    if (layer->hasCompositedLayerMapping()) {
+        CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping();
         // The compositing state of all our children has been updated already, so now
         // we can compute and cache the composited bounds for this layer.
         compositedLayerMapping->updateCompositedBounds();
 
         if (layer->reflectionInfo()) {
             RenderLayer* reflectionLayer = layer->reflectionInfo()->reflectionLayer();
-            if (reflectionLayer->compositedLayerMapping())
+            if (reflectionLayer->hasCompositedLayerMapping())
                 reflectionLayer->compositedLayerMapping()->updateCompositedBounds();
         }
 
         compositedLayerMapping->updateGraphicsLayerConfiguration();
         compositedLayerMapping->updateGraphicsLayerGeometry();
 
         if (!layer->parent())
             updateRootLayerPosition();
     }
 
 #if !ASSERT_DISABLED
     LayerListMutationDetector mutationChecker(layer->stackingNode());
 #endif
 
     RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), AllChildren);
     while (RenderLayerStackingNode* curNode = iterator.next())
         updateLayerTreeGeometry(curNode->layer());
 }
 
 // Recurs down the RenderLayer tree until its finds the compositing descendants of compositingAncestor and updates their geometry.
 void RenderLayerCompositor::updateCompositingDescendantGeometry(RenderLayerStackingNode* compositingAncestor, RenderLayer* layer, bool compositedChildrenOnly)
 {
-    if (layer->stackingNode() != compositingAncestor) {
-        if (CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping()) {
-            compositedLayerMapping->updateCompositedBounds();
+    if (layer->stackingNode() != compositingAncestor && layer->hasCompositedLayerMapping()) {
+        CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping();
+        compositedLayerMapping->updateCompositedBounds();
 
-            if (layer->reflectionInfo()) {
-                RenderLayer* reflectionLayer = layer->reflectionInfo()->reflectionLayer();
-                if (reflectionLayer->compositedLayerMapping())
-                    reflectionLayer->compositedLayerMapping()->updateCompositedBounds();
-            }
+        if (layer->reflectionInfo()) {
+            RenderLayer* reflectionLayer = layer->reflectionInfo()->reflectionLayer();
+            if (reflectionLayer->hasCompositedLayerMapping())
+                reflectionLayer->compositedLayerMapping()->updateCompositedBounds();
+        }
 
-            compositedLayerMapping->updateGraphicsLayerGeometry();
-            if (compositedChildrenOnly)
-                return;
-        }
+        compositedLayerMapping->updateGraphicsLayerGeometry();
+        if (compositedChildrenOnly)
+            return;
     }
 
     if (layer->reflectionInfo())
         updateCompositingDescendantGeometry(compositingAncestor, layer->reflectionInfo()->reflectionLayer(), compositedChildrenOnly);
 
     if (!layer->hasCompositingDescendant())
         return;
 
 #if !ASSERT_DISABLED
     LayerListMutationDetector mutationChecker(layer->stackingNode());
@@ skipping 73 matching lines @@
 
         detachRootLayer();
     }
 }
 
 void RenderLayerCompositor::clearMappingForRenderLayerIncludingDescendants(RenderLayer* layer)
 {
     if (!layer)
         return;
 
-    if (layer->compositedLayerMapping()) {
+    if (layer->hasCompositedLayerMapping()) {
         removeViewportConstrainedLayer(layer);
         layer->clearCompositedLayerMapping();
     }
 
     for (RenderLayer* currLayer = layer->firstChild(); currLayer; currLayer = currLayer->nextSibling())
         clearMappingForRenderLayerIncludingDescendants(currLayer);
 }
 
 void RenderLayerCompositor::clearMappingForAllRenderLayers()
 {
@@ skipping 91 matching lines @@
     return directReasons;
 }
 
 // Return true if the given layer has some ancestor in the RenderLayer hierarchy that clips,
 // up to the enclosing compositing ancestor. This is required because compositing layers are parented
 // according to the z-order hierarchy, yet clipping goes down the renderer hierarchy.
 // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in the renderer hierarchy,
 // but a sibling in the z-order hierarchy.
 bool RenderLayerCompositor::clippedByAncestor(const RenderLayer* layer) const
 {
-    if (!layer->compositedLayerMapping() || !layer->parent())
+    if (!layer->hasCompositedLayerMapping() || !layer->parent())
         return false;
 
     const RenderLayer* compositingAncestor = layer->ancestorCompositingLayer();
     if (!compositingAncestor)
         return false;
 
     // If the compositingAncestor clips, that will be taken care of by clipsCompositingDescendants(),
     // so we only care about clipping between its first child that is our ancestor (the computeClipRoot),
     // and layer.
     const RenderLayer* computeClipRoot = 0;
@@ skipping 84 matching lines @@
     bool composite = renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing();
     if (!composite)
         return false;
 
     // FIXME: this seems bogus. If we don't know the layout position/size of the plugin yet, would't that be handled elsewhere?
     m_needsToRecomputeCompositingRequirements = true;
 
     RenderWidget* pluginRenderer = toRenderWidget(renderer);
     // If we can't reliably know the size of the plugin yet, don't change compositing state.
     if (pluginRenderer->needsLayout())
-        return pluginRenderer->hasLayer() && pluginRenderer->layer()->compositedLayerMapping();
+        return pluginRenderer->hasLayer() && pluginRenderer->layer()->hasCompositedLayerMapping();
 
     // Don't go into compositing mode if height or width are zero, or size is 1x1.
     IntRect contentBox = pixelSnappedIntRect(pluginRenderer->contentBoxRect());
     return contentBox.height() * contentBox.width() > 1;
 }
 
 bool RenderLayerCompositor::requiresCompositingForFrame(RenderObject* renderer) const
 {
     if (!renderer->isRenderPart())
         return false;
 
     RenderPart* frameRenderer = toRenderPart(renderer);
 
     if (!frameRenderer->requiresAcceleratedCompositing())
         return false;
 
     // FIXME: this seems bogus. If we don't know the layout position/size of the frame yet, wouldn't that be handled elsehwere?
     m_needsToRecomputeCompositingRequirements = true;
 
     RenderLayerCompositor* innerCompositor = frameContentsCompositor(frameRenderer);
     if (!innerCompositor)
         return false;
 
     // If we can't reliably know the size of the iframe yet, don't change compositing state.
     if (renderer->needsLayout())
-        return frameRenderer->hasLayer() && frameRenderer->layer()->compositedLayerMapping();
+        return frameRenderer->hasLayer() && frameRenderer->layer()->hasCompositedLayerMapping();
 
     // Don't go into compositing mode if height or width are zero.
     IntRect contentBox = pixelSnappedIntRect(frameRenderer->contentBoxRect());
     return contentBox.height() * contentBox.width() > 0;
 }
 
 bool RenderLayerCompositor::requiresCompositingForBackfaceVisibilityHidden(RenderObject* renderer) const
 {
     return canRender3DTransforms() && renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden;
 }
@@ skipping 149 matching lines @@
 
     if (!hasScrollableAncestor) {
         if (viewportConstrainedNotCompositedReason)
             *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForUnscrollableAncestors;
         return false;
     }
 
     // Subsequent tests depend on layout. If we can't tell now, just keep things the way they are until layout is done.
     if (!m_inPostLayoutUpdate) {
         m_needsToRecomputeCompositingRequirements = true;
-        return layer->compositedLayerMapping();
+        return layer->hasCompositedLayerMapping();
     }
 
     bool paintsContent = layer->isVisuallyNonEmpty() || layer->hasVisibleDescendant();
     if (!paintsContent) {
         if (viewportConstrainedNotCompositedReason)
             *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForNoVisibleContent;
         return false;
     }
 
     // Fixed position elements that are invisible in the current view don't get their own layer.
@@ skipping 465 matching lines @@
 
 static bool isRootmostFixedOrStickyLayer(RenderLayer* layer)
 {
     if (layer->renderer()->isStickyPositioned())
         return true;
 
     if (layer->renderer()->style()->position() != FixedPosition)
         return false;
 
     for (RenderLayerStackingNode* stackingContainerNode = layer->stackingNode()->ancestorStackingContainerNode(); stackingContainerNode; stackingContainerNode = stackingContainerNode->ancestorStackingContainerNode()) {
-        if (stackingContainerNode->layer()->compositedLayerMapping() && stackingContainerNode->layer()->renderer()->style()->position() == FixedPosition)
+        if (stackingContainerNode->layer()->hasCompositedLayerMapping() && stackingContainerNode->layer()->renderer()->style()->position() == FixedPosition)
             return false;
     }
 
     return true;
 }
 
 void RenderLayerCompositor::updateViewportConstraintStatus(RenderLayer* layer)
 {
     if (isRootmostFixedOrStickyLayer(layer))
         addViewportConstrainedLayer(layer);
     else
         removeViewportConstrainedLayer(layer);
 }
 
 void RenderLayerCompositor::addViewportConstrainedLayer(RenderLayer* layer)
 {
     m_viewportConstrainedLayers.add(layer);
 }
 
 void RenderLayerCompositor::removeViewportConstrainedLayer(RenderLayer* layer)
 {
     if (!m_viewportConstrainedLayers.contains(layer))
         return;
 
     m_viewportConstrainedLayers.remove(layer);
 }
 
 FixedPositionViewportConstraints RenderLayerCompositor::computeFixedViewportConstraints(RenderLayer* layer) const
 {
-    ASSERT(layer->compositedLayerMapping());
+    ASSERT(layer->hasCompositedLayerMapping());
 
     FrameView* frameView = m_renderView->frameView();
     LayoutRect viewportRect = frameView->viewportConstrainedVisibleContentRect();
 
     FixedPositionViewportConstraints constraints;
 
     GraphicsLayer* graphicsLayer = layer->compositedLayerMapping()->mainGraphicsLayer();
 
     constraints.setLayerPositionAtLastLayout(graphicsLayer->position());
     constraints.setViewportRectAtLastLayout(viewportRect);
@@ skipping 17 matching lines @@
 
     // If top and bottom are auto, use top.
     if (style->top().isAuto() && style->bottom().isAuto())
         constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeTop);
 
     return constraints;
 }
 
 StickyPositionViewportConstraints RenderLayerCompositor::computeStickyViewportConstraints(RenderLayer* layer) const
 {
-    ASSERT(layer->compositedLayerMapping());
+    ASSERT(layer->hasCompositedLayerMapping());
 
     FrameView* frameView = m_renderView->frameView();
     LayoutRect viewportRect = frameView->viewportConstrainedVisibleContentRect();
 
     StickyPositionViewportConstraints constraints;
 
     RenderBoxModelObject* renderer = toRenderBoxModelObject(layer->renderer());
 
     renderer->computeStickyPositionConstraints(constraints, viewportRect);
 
@@ skipping 47 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "Frame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore