Change PaintLayer::m_layoutObject to a reference.

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/compositing/CompositingInputsUpdater.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutBlock.h"
@@ skipping 10 matching lines @@
 
 CompositingInputsUpdater::~CompositingInputsUpdater() {}
 
 void CompositingInputsUpdater::update() {
   TRACE_EVENT0("blink", "CompositingInputsUpdater::update");
   updateRecursive(m_rootLayer, DoNotForceUpdate, AncestorInfo());
 }
 
 static const PaintLayer* findParentLayerOnClippingContainerChain(
     const PaintLayer* layer) {
-  LayoutObject* current = layer->layoutObject();
+  LayoutObject* current = &layer->layoutObject();
   while (current) {
     if (current->style()->position() == EPosition::kFixed) {
       for (current = current->parent();
            current && !current->canContainFixedPositionObjects();
            current = current->parent()) {
         // CSS clip applies to fixed position elements even for ancestors that
         // are not what the fixed element is positioned with respect to.
         if (current->hasClip()) {
           DCHECK(current->hasLayer());
           return static_cast<const LayoutBoxModelObject*>(current)->layer();
@@ skipping 24 matching lines @@
   }
   ASSERT_NOT_REACHED();
   return nullptr;
 }
 
 static bool hasClippedStackingAncestor(const PaintLayer* layer,
                                        const PaintLayer* clippingLayer) {
   if (layer == clippingLayer)
     return false;
   bool foundInterveningClip = false;
-  const LayoutObject* clippingLayoutObject = clippingLayer->layoutObject();
+  const LayoutObject& clippingLayoutObject = clippingLayer->layoutObject();
   for (const PaintLayer* current = layer->compositingContainer(); current;
        current = current->compositingContainer()) {
     if (current == clippingLayer)
       return foundInterveningClip;
 
-    if (current->layoutObject()->hasClipRelatedProperty() &&
-        !clippingLayoutObject->isDescendantOf(current->layoutObject()))
+    if (current->layoutObject().hasClipRelatedProperty() &&
+        !clippingLayoutObject.isDescendantOf(&current->layoutObject()))
       foundInterveningClip = true;
 
     if (const LayoutObject* container = current->clippingContainer()) {
-      if (clippingLayoutObject != container &&
-          !clippingLayoutObject->isDescendantOf(container))
+      if (&clippingLayoutObject != container &&
+          !clippingLayoutObject.isDescendantOf(container))
         foundInterveningClip = true;
     }
   }
   return false;
 }
 
 void CompositingInputsUpdater::updateRecursive(PaintLayer* layer,
                                                UpdateType updateType,
                                                AncestorInfo info) {
   if (!layer->childNeedsCompositingInputsUpdate() && updateType != ForceUpdate)
     return;
 
   const PaintLayer* previousOverflowLayer = layer->ancestorOverflowLayer();
   layer->updateAncestorOverflowLayer(info.lastOverflowClipLayer);
   if (info.lastOverflowClipLayer && layer->needsCompositingInputsUpdate() &&
-      layer->layoutObject()->style()->position() == EPosition::kSticky) {
+      layer->layoutObject().style()->position() == EPosition::kSticky) {
     if (info.lastOverflowClipLayer != previousOverflowLayer &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       // Old ancestor scroller should no longer have these constraints.
       ASSERT(!previousOverflowLayer ||
              !previousOverflowLayer->getScrollableArea()
                   ->stickyConstraintsMap()
                   .contains(layer));
 
-      if (info.lastOverflowClipLayer->isRootLayer())
+      if (info.lastOverflowClipLayer->isRootLayer()) {
+        layer->layoutObject().view()->frameView()->addViewportConstrainedObject(
+            layer->layoutObject());
+      } else if (previousOverflowLayer &&
+                 previousOverflowLayer->isRootLayer()) {
         layer->layoutObject()
-            ->view()
-            ->frameView()
-            ->addViewportConstrainedObject(layer->layoutObject());
-      else if (previousOverflowLayer && previousOverflowLayer->isRootLayer())
-        layer->layoutObject()
-            ->view()
+            .view()
             ->frameView()
             ->removeViewportConstrainedObject(layer->layoutObject());
+      }
     }
-    layer->layoutObject()->updateStickyPositionConstraints();
+    layer->layoutObject().updateStickyPositionConstraints();
 
     // Sticky position constraints and ancestor overflow scroller affect
     // the sticky layer position, so we need to update it again here.
     // TODO(flackr): This should be refactored in the future to be clearer
     // (i.e. update layer position and ancestor inputs updates in the
     // same walk)
     layer->updateLayerPosition();
   }
 
   m_geometryMap.pushMappingsToAncestor(layer, layer->parent());
@@ skipping 34 matching lines @@
 
       const PaintLayer* parent = layer->parent();
       properties.opacityAncestor =
           parent->isTransparent() ? parent : parent->opacityAncestor();
       properties.transformAncestor =
           parent->transform() ? parent : parent->transformAncestor();
       properties.filterAncestor = parent->hasFilterInducingProperty()
                                       ? parent
                                       : parent->filterAncestor();
       bool layerIsFixedPosition =
-          layer->layoutObject()->style()->position() == EPosition::kFixed;
+          layer->layoutObject().style()->position() == EPosition::kFixed;
       properties.nearestFixedPositionLayer =
           layerIsFixedPosition ? layer : parent->nearestFixedPositionLayer();
 
       if (info.hasAncestorWithClipRelatedProperty) {
         const PaintLayer* parentLayerOnClippingContainerChain =
             findParentLayerOnClippingContainerChain(layer);
         const bool parentHasClipRelatedProperty =
             parentLayerOnClippingContainerChain->layoutObject()
-                ->hasClipRelatedProperty();
+                .hasClipRelatedProperty();
         properties.clippingContainer =
             parentHasClipRelatedProperty
-                ? parentLayerOnClippingContainerChain->layoutObject()
+                ? &parentLayerOnClippingContainerChain->layoutObject()
                 : parentLayerOnClippingContainerChain->clippingContainer();
 
-        if (layer->layoutObject()->isOutOfFlowPositioned() &&
+        if (layer->layoutObject().isOutOfFlowPositioned() &&
             !layer->subtreeIsInvisible()) {
           const PaintLayer* clippingLayer =
               properties.clippingContainer
                   ? properties.clippingContainer->enclosingLayer()
                   : layer->compositor()->rootLayer();
           if (hasClippedStackingAncestor(layer, clippingLayer))
             properties.clipParent = clippingLayer;
         }
       }
 
       if (info.lastScrollingAncestor) {
         const LayoutObject* containingBlock =
-            layer->layoutObject()->containingBlock();
+            layer->layoutObject().containingBlock();
         const PaintLayer* parentLayerOnContainingBlockChain =
             findParentLayerOnContainingBlockChain(containingBlock);
 
         properties.ancestorScrollingLayer =
             parentLayerOnContainingBlockChain->ancestorScrollingLayer();
         if (parentLayerOnContainingBlockChain->scrollsOverflow())
           properties.ancestorScrollingLayer = parentLayerOnContainingBlockChain;
 
         if (layer->stackingNode()->isStacked() &&
             properties.ancestorScrollingLayer &&
-            !info.ancestorStackingContext->layoutObject()->isDescendantOf(
-                properties.ancestorScrollingLayer->layoutObject()))
+            !info.ancestorStackingContext->layoutObject().isDescendantOf(
+                &properties.ancestorScrollingLayer->layoutObject()))
           properties.scrollParent = properties.ancestorScrollingLayer;
       }
     }
 
     layer->updateAncestorDependentCompositingInputs(
         properties, info.hasAncestorWithClipPath);
   }
 
   if (layer->stackingNode()->isStackingContext())
     info.ancestorStackingContext = layer;
 
-  if (layer->isRootLayer() || layer->layoutObject()->hasOverflowClip())
+  if (layer->isRootLayer() || layer->layoutObject().hasOverflowClip())
     info.lastOverflowClipLayer = layer;
 
   if (layer->scrollsOverflow())
     info.lastScrollingAncestor = layer;
 
-  if (layer->layoutObject()->hasClipRelatedProperty())
+  if (layer->layoutObject().hasClipRelatedProperty())
     info.hasAncestorWithClipRelatedProperty = true;
 
-  if (layer->layoutObject()->hasClipPath())
+  if (layer->layoutObject().hasClipPath())
     info.hasAncestorWithClipPath = true;
 
   for (PaintLayer* child = layer->firstChild(); child;
        child = child->nextSibling())
     updateRecursive(child, updateType, info);
 
   layer->didUpdateCompositingInputs();
 
   m_geometryMap.popMappingsToAncestor(layer->parent());
 
   if (layer->selfPaintingStatusChanged()) {
     layer->clearSelfPaintingStatusChanged();
     // If the floating object becomes non-self-painting, so some ancestor should
     // paint it; if it becomes self-painting, it should paint itself and no
     // ancestor should paint it.
-    if (layer->layoutObject()->isFloating()) {
+    if (layer->layoutObject().isFloating()) {
       LayoutBlockFlow::updateAncestorShouldPaintFloatingObject(
           *layer->layoutBox());
     }
   }
 }
 
 #if DCHECK_IS_ON()
 
 void CompositingInputsUpdater::assertNeedsCompositingInputsUpdateBitsCleared(
     PaintLayer* layer) {
   ASSERT(!layer->childNeedsCompositingInputsUpdate());
   ASSERT(!layer->needsCompositingInputsUpdate());
 
   for (PaintLayer* child = layer->firstChild(); child;
        child = child->nextSibling())
     assertNeedsCompositingInputsUpdateBitsCleared(child);
 }
 
 #endif
 
 }  // namespace blink