Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/layout/compositing/PaintLayerCompositor.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 319 matching lines @@
   if (updateType >= CompositingUpdateAfterCompositingInputChange)
     CompositingInputsUpdater(rootLayer()).update();
 
 #if DCHECK_IS_ON()
   CompositingInputsUpdater::assertNeedsCompositingInputsUpdateBitsCleared(
       rootLayer());
 #endif
 }
 
 static void forceRecomputeVisualRectsIncludingNonCompositingDescendants(
-    LayoutObject* layoutObject) {
+    LayoutObject& layoutObject) {
   // We clear the previous visual rect as it's wrong (paint invalidation
   // container changed, ...). Forcing a full invalidation will make us recompute
   // it. Also we are not changing the previous position from our paint
   // invalidation container, which is fine as we want a full paint invalidation
   // anyway.
-  layoutObject->clearPreviousVisualRects();
+  layoutObject.clearPreviousVisualRects();
 
-  for (LayoutObject* child = layoutObject->slowFirstChild(); child;
+  for (LayoutObject* child = layoutObject.slowFirstChild(); child;
        child = child->nextSibling()) {
     if (!child->isPaintInvalidationContainer())
-      forceRecomputeVisualRectsIncludingNonCompositingDescendants(child);
+      forceRecomputeVisualRectsIncludingNonCompositingDescendants(*child);
   }
 }
 
 void PaintLayerCompositor::updateIfNeeded() {
   CompositingUpdateType updateType = m_pendingUpdateType;
   m_pendingUpdateType = CompositingUpdateNone;
 
   if (!hasAcceleratedCompositing()) {
     updateWithoutAcceleratedCompositing(updateType);
     return;
@@ skipping 165 matching lines @@
       // squashing list of its groupedMapping?  Need to create a test where a
       // squashed layer pops into compositing. And also to cover all other sorts
       // of compositingState transitions.
       layer->setLostGroupedMapping(false);
       layer->setGroupedMapping(nullptr,
                                PaintLayer::InvalidateLayerAndRemoveFromMapping);
 
       layer->ensureCompositedLayerMapping();
       compositedLayerMappingChanged = true;
 
-      restartAnimationOnCompositor(*layer->layoutObject());
+      restartAnimationOnCompositor(layer->layoutObject());
 
       // At this time, the ScrollingCoordinator only supports the top-level
       // frame.
       if (layer->isRootLayer() && m_layoutView.frame()->isLocalRoot()) {
         if (ScrollingCoordinator* scrollingCoordinator =
                 this->scrollingCoordinator())
           scrollingCoordinator->frameViewRootLayerDidChange(
               m_layoutView.frameView());
       }
       break;
     case RemoveOwnCompositedLayerMapping:
     // PutInSquashingLayer means you might have to remove the composited layer
     // mapping first.
     case PutInSquashingLayer:
       if (layer->hasCompositedLayerMapping()) {
         layer->clearCompositedLayerMapping();
         compositedLayerMappingChanged = true;
       }
 
       break;
     case RemoveFromSquashingLayer:
     case NoCompositingStateChange:
       // Do nothing.
       break;
   }
 
-  if (compositedLayerMappingChanged && layer->layoutObject()->isLayoutPart()) {
+  if (compositedLayerMappingChanged && layer->layoutObject().isLayoutPart()) {
     PaintLayerCompositor* innerCompositor =
         frameContentsCompositor(toLayoutPart(layer->layoutObject()));
     if (innerCompositor && innerCompositor->staleInCompositingMode())
       innerCompositor->updateRootLayerAttachment();
   }
 
   if (compositedLayerMappingChanged) {
     layer->clipper(PaintLayer::DoNotUseGeometryMapper)
         .clearClipRectsIncludingDescendants(PaintingClipRects);
   }
 
   // If a fixed position layer gained/lost a compositedLayerMapping or the
   // reason not compositing it changed, the scrolling coordinator needs to
   // recalculate whether it can do fast scrolling.
   if (compositedLayerMappingChanged) {
     if (ScrollingCoordinator* scrollingCoordinator =
             this->scrollingCoordinator())
       scrollingCoordinator->frameViewFixedObjectsDidChange(
           m_layoutView.frameView());
   }
 
   return compositedLayerMappingChanged;
 }
 
 void PaintLayerCompositor::paintInvalidationOnCompositingChange(
     PaintLayer* layer) {
   // If the layoutObject is not attached yet, no need to issue paint
   // invalidations.
-  if (layer->layoutObject() != &m_layoutView &&
-      !layer->layoutObject()->parent())
+  if (&layer->layoutObject() != &m_layoutView &&
+      !layer->layoutObject().parent())
     return;
 
   // For querying Layer::compositingState()
   // Eager invalidation here is correct, since we are invalidating with respect
   // to the previous frame's compositing state when changing the compositing
   // backing of the layer.
   DisableCompositingQueryAsserts disabler;
   // FIXME: We should not allow paint invalidation out of paint invalidation
   // state. crbug.com/457415
   DisablePaintInvalidationStateAsserts paintInvalidationAssertisabler;
 
-  ObjectPaintInvalidator(*layer->layoutObject())
+  ObjectPaintInvalidator(layer->layoutObject())
       .invalidatePaintIncludingNonCompositingDescendants();
 }
 
 void PaintLayerCompositor::frameViewDidChangeLocation(
     const IntPoint& contentsOffset) {
   if (m_overflowControlsHostLayer)
     m_overflowControlsHostLayer->setPosition(contentsOffset);
 }
 
 void PaintLayerCompositor::updateContainerSizes() {
@@ skipping 110 matching lines @@
         rootLayer = rootLayer->parent();
     } else {
       rootLayer = rootGraphicsLayer();
     }
   }
 
   return rootLayer->layerTreeAsJSON(flags);
 }
 
 PaintLayerCompositor* PaintLayerCompositor::frameContentsCompositor(
-    LayoutPart* layoutObject) {
-  if (!layoutObject->node()->isFrameOwnerElement())
+    LayoutPart& layoutObject) {
+  if (!layoutObject.node()->isFrameOwnerElement())
     return nullptr;
 
-  HTMLFrameOwnerElement* element =
-      toHTMLFrameOwnerElement(layoutObject->node());
+  HTMLFrameOwnerElement* element = toHTMLFrameOwnerElement(layoutObject.node());
   if (Document* contentDocument = element->contentDocument()) {
     if (LayoutViewItem view = contentDocument->layoutViewItem())
       return view.compositor();
   }
   return nullptr;
 }
 
 bool PaintLayerCompositor::attachFrameContentLayersToIframeLayer(
-    LayoutPart* layoutObject) {
+    LayoutPart& layoutObject) {
   PaintLayerCompositor* innerCompositor = frameContentsCompositor(layoutObject);
   if (!innerCompositor || !innerCompositor->staleInCompositingMode() ||
       innerCompositor->getRootLayerAttachment() !=
           RootLayerAttachedViaEnclosingFrame)
     return false;
 
-  PaintLayer* layer = layoutObject->layer();
+  PaintLayer* layer = layoutObject.layer();
   if (!layer->hasCompositedLayerMapping())
     return false;
 
   layer->compositedLayerMapping()->setSublayers(
       GraphicsLayerVector(1, innerCompositor->rootGraphicsLayer()));
   return true;
 }
 
 static void fullyInvalidatePaintRecursive(PaintLayer* layer) {
   if (layer->compositingState() == PaintsIntoOwnBacking) {
@@ skipping 80 matching lines @@
 }
 
 void PaintLayerCompositor::updatePotentialCompositingReasonsFromStyle(
     PaintLayer* layer) {
   layer->setPotentialCompositingReasonsFromStyle(
       m_compositingReasonFinder.potentialCompositingReasonsFromStyle(
           layer->layoutObject()));
 }
 
 bool PaintLayerCompositor::canBeComposited(const PaintLayer* layer) const {
-  FrameView* frameView = layer->layoutObject()->frameView();
+  FrameView* frameView = layer->layoutObject().frameView();
   // Elements within an invisible frame must not be composited because they are
   // not drawn.
   if (frameView && !frameView->isVisible())
     return false;
 
   const bool hasCompositorAnimation =
       m_compositingReasonFinder.requiresCompositingForAnimation(
-          *layer->layoutObject()->style());
+          *layer->layoutObject().style());
   return m_hasAcceleratedCompositing &&
          (hasCompositorAnimation || !layer->subtreeIsInvisible()) &&
          layer->isSelfPaintingLayer() &&
-         !layer->layoutObject()->isLayoutFlowThread();
+         !layer->layoutObject().isLayoutFlowThread();
 }
 
 // Return true if the given layer is a stacking context and has compositing
 // child layers that it needs to clip. In this case we insert a clipping
 // GraphicsLayer into the hierarchy between this layer and its children in the
 // z-order hierarchy.
 bool PaintLayerCompositor::clipsCompositingDescendants(
     const PaintLayer* layer) const {
   return layer->hasCompositingDescendant() &&
-         layer->layoutObject()->hasClipRelatedProperty();
+         layer->layoutObject().hasClipRelatedProperty();
 }
 
 // If an element has composited negative z-index children, those children paint
 // in front of the layer background, so we need an extra 'contents' layer for
 // the foreground of the layer object.
 bool PaintLayerCompositor::needsContentsCompositingLayer(
     const PaintLayer* layer) const {
   if (!layer->hasCompositingDescendant())
     return false;
   return layer->stackingNode()->hasNegativeZOrderList();
@@ skipping 456 matching lines @@
   } else if (graphicsLayer == m_scrollLayer.get()) {
     name = "Frame Scrolling Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink