Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/layout/compositing/CompositingLayerAssigner.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google 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
@@ skipping 118 matching lines @@
   const PaintLayer& squashingLayer =
       squashingState.mostRecentMapping->owningLayer();
 
   // FIXME: this special case for video exists only to deal with corner cases
   // where a LayoutVideo does not report that it needs to be directly
   // composited.  Video does not currently support sharing a backing, but this
   // could be generalized in the future. The following layout tests fail if we
   // permit the video to share a backing with other layers.
   //
   // compositing/video/video-controls-layer-creation.html
-  if (layer->layoutObject()->isVideo() ||
-      squashingLayer.layoutObject()->isVideo())
+  if (layer->layoutObject().isVideo() ||
+      squashingLayer.layoutObject().isVideo())
     return SquashingDisallowedReasonSquashingVideoIsDisallowed;
 
   // Don't squash iframes, frames or plugins.
   // FIXME: this is only necessary because there is frame code that assumes that
   // composited frames are not squashed.
-  if (layer->layoutObject()->isLayoutPart() ||
-      squashingLayer.layoutObject()->isLayoutPart())
+  if (layer->layoutObject().isLayoutPart() ||
+      squashingLayer.layoutObject().isLayoutPart())
     return SquashingDisallowedReasonSquashingLayoutPartIsDisallowed;
 
   if (squashingWouldExceedSparsityTolerance(layer, squashingState))
     return SquashingDisallowedReasonSquashingSparsityExceeded;
 
-  if (layer->layoutObject()->style()->hasBlendMode() ||
-      squashingLayer.layoutObject()->style()->hasBlendMode())
+  if (layer->layoutObject().style()->hasBlendMode() ||
+      squashingLayer.layoutObject().style()->hasBlendMode())
     return SquashingDisallowedReasonSquashingBlendingIsDisallowed;
 
   // FIXME: this is not efficient, since it walks up the tree. We should store
   // these values on the CompositingInputsCache.
   if (layer->clippingContainer() != squashingLayer.clippingContainer() &&
       !squashingLayer.compositedLayerMapping()->containingSquashedLayer(
           layer->clippingContainer(), squashingState.nextSquashedLayerIndex))
     return SquashingDisallowedReasonClippingContainerMismatch;
 
   // Composited descendants need to be clipped by a child containment graphics
@@ skipping 20 matching lines @@
   if (layer->renderingContextRoot() != squashingLayer.renderingContextRoot())
     return SquashingDisallowedReasonRenderingContextMismatch;
 
   if (layer->hasFilterInducingProperty() ||
       layer->filterAncestor() != squashingLayer.filterAncestor())
     return SquashingDisallowedReasonFilterMismatch;
 
   if (layer->nearestFixedPositionLayer() !=
       squashingLayer.nearestFixedPositionLayer())
     return SquashingDisallowedReasonNearestFixedPositionMismatch;
-  DCHECK(layer->layoutObject()->style()->position() != EPosition::kFixed);
+  DCHECK(layer->layoutObject().style()->position() != EPosition::kFixed);
 
-  if ((squashingLayer.layoutObject()->style()->subtreeWillChangeContents() &&
+  if ((squashingLayer.layoutObject().style()->subtreeWillChangeContents() &&
        squashingLayer.layoutObject()
-           ->style()
+           .style()
            ->isRunningAnimationOnCompositor()) ||
       squashingLayer.layoutObject()
-          ->style()
+          .style()
           ->shouldCompositeForCurrentAnimations())
     return SquashingDisallowedReasonSquashingLayerIsAnimating;
 
   if (layer->enclosingPaginationLayer())
     return SquashingDisallowedReasonFragmentedContent;
 
   return SquashingDisallowedReasonsNone;
 }
 
 void CompositingLayerAssigner::updateSquashingAssignment(
@@ skipping 51 matching lines @@
         layer,
         InspectorLayerInvalidationTrackingEvent::RemovedFromSquashingLayer);
     layersNeedingPaintInvalidation.push_back(layer);
     m_layersChanged = true;
 
     layer->setLostGroupedMapping(false);
   }
 }
 
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(PaintLayer& layer) {
-  Page* page = layer.layoutObject()->frame()->page();
+  Page* page = layer.layoutObject().frame()->page();
   return (!page) ? nullptr : page->scrollingCoordinator();
 }
 
 void CompositingLayerAssigner::assignLayersToBackingsInternal(
     PaintLayer* layer,
     SquashingState& squashingState,
     Vector<PaintLayer*>& layersNeedingPaintInvalidation) {
   if (requiresSquashing(layer->getCompositingReasons())) {
     SquashingDisallowedReasons reasonsPreventingSquashing =
         getReasonsPreventingSquashing(layer, squashingState);
     if (reasonsPreventingSquashing) {
       layer->setCompositingReasons(layer->getCompositingReasons() |
                                    CompositingReasonSquashingDisallowed);
       layer->setSquashingDisallowedReasons(reasonsPreventingSquashing);
     }
   }
 
   CompositingStateTransitionType compositedLayerUpdate =
       computeCompositedLayerUpdate(layer);
 
   if (m_compositor->allocateOrClearCompositedLayerMapping(
           layer, compositedLayerUpdate)) {
     TRACE_LAYER_INVALIDATION(
         layer, InspectorLayerInvalidationTrackingEvent::NewCompositedLayer);
     layersNeedingPaintInvalidation.push_back(layer);
     m_layersChanged = true;
     if (ScrollingCoordinator* scrollingCoordinator =
             scrollingCoordinatorFromLayer(*layer)) {
-      if (layer->layoutObject()->style()->hasViewportConstrainedPosition())
+      if (layer->layoutObject().style()->hasViewportConstrainedPosition()) {
         scrollingCoordinator->frameViewFixedObjectsDidChange(
-            layer->layoutObject()->view()->frameView());
+            layer->layoutObject().view()->frameView());
+      }
     }
   }
 
   // Add this layer to a squashing backing if needed.
   updateSquashingAssignment(layer, squashingState, compositedLayerUpdate,
                             layersNeedingPaintInvalidation);
 
   const bool layerIsSquashed =
       compositedLayerUpdate == PutInSquashingLayer ||
       (compositedLayerUpdate == NoCompositingStateChange &&
@@ skipping 33 matching lines @@
   while (PaintLayerStackingNode* curNode = iterator.next())
     assignLayersToBackingsInternal(curNode->layer(), squashingState,
                                    layersNeedingPaintInvalidation);
 
   if (squashingState.hasMostRecentMapping &&
       &squashingState.mostRecentMapping->owningLayer() == layer)
     squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree = true;
 }
 
 }  // namespace blink