Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/paint/PaintLayerClipper.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>
@@ skipping 61 matching lines @@
 static void applyClipRects(const ClipRectsContext& context,
                            const LayoutBoxModelObject& layoutObject,
                            LayoutPoint offset,
                            ClipRects& clipRects) {
   DCHECK(layoutObject.isBox());
   const LayoutBox& box = *toLayoutBox(&layoutObject);
 
   DCHECK(box.shouldClipOverflow() || box.hasClip());
   LayoutView* view = box.view();
   DCHECK(view);
-  if (clipRects.fixed() && context.rootLayer->layoutObject() == view)
+  if (clipRects.fixed() && &context.rootLayer->layoutObject() == view)
     offset -= LayoutSize(view->frameView()->getScrollOffset());
 
   if (box.shouldClipOverflow()) {
     ClipRect newOverflowClip =
         box.overflowClipRect(offset, context.overlayScrollbarClipBehavior);
     newOverflowClip.setHasRadius(box.styleRef().hasBorderRadius());
     clipRects.setOverflowClipRect(
         intersection(newOverflowClip, clipRects.overflowClipRect()));
     if (box.isPositioned())
       clipRects.setPosClipRect(
@@ skipping 109 matching lines @@
 LayoutRect PaintLayerClipper::localClipRect(
     const PaintLayer& clippingRootLayer) const {
   ClipRectsContext context(&clippingRootLayer, PaintingClipRects);
   if (m_geometryMapper) {
     ClipRect clipRect = clipRectWithGeometryMapper(context, false);
     applyOverflowClipToBackgroundRectWithGeometryMapper(context, clipRect);
     LayoutRect premappedRect = clipRect.rect();
 
     // The rect now needs to be transformed to the local space of this
     // PaintLayer.
-    premappedRect.moveBy(context.rootLayer->layoutObject()->paintOffset());
+    premappedRect.moveBy(context.rootLayer->layoutObject().paintOffset());
 
     const auto* clipRootLayerTransform = clippingRootLayer.layoutObject()
-                                             ->paintProperties()
+                                             .paintProperties()
                                              ->localBorderBoxProperties()
                                              ->transform();
     const auto* layerTransform = m_layer.layoutObject()
-                                     ->paintProperties()
+                                     .paintProperties()
                                      ->localBorderBoxProperties()
                                      ->transform();
     FloatRect clippedRectInLocalSpace =
         m_geometryMapper->sourceToDestinationRect(
             FloatRect(premappedRect), clipRootLayerTransform, layerTransform);
     clippedRectInLocalSpace.moveBy(
-        -FloatPoint(m_layer.layoutObject()->paintOffset()));
+        -FloatPoint(m_layer.layoutObject().paintOffset()));
 
     return LayoutRect(clippedRectInLocalSpace);
   }
 
   LayoutRect layerBounds;
   ClipRect backgroundRect, foregroundRect;
   calculateRects(context, LayoutRect(LayoutRect::infiniteIntRect()),
                  layerBounds, backgroundRect, foregroundRect);
 
   LayoutRect clipRect = backgroundRect.rect();
@@ skipping 21 matching lines @@
     }                                                                   \
   } while (false);
 #endif
 
 void PaintLayerClipper::mapLocalToRootWithGeometryMapper(
     const ClipRectsContext& context,
     LayoutRect& rectToMap) const {
   DCHECK(m_geometryMapper);
 
   const auto* layerTransform = m_layer.layoutObject()
-                                   ->paintProperties()
+                                   .paintProperties()
                                    ->localBorderBoxProperties()
                                    ->transform();
   const auto* rootTransform = context.rootLayer->layoutObject()
-                                  ->paintProperties()
+                                  .paintProperties()
                                   ->localBorderBoxProperties()
                                   ->transform();
 
   FloatRect localRect(rectToMap);
-  localRect.moveBy(FloatPoint(m_layer.layoutObject()->paintOffset()));
+  localRect.moveBy(FloatPoint(m_layer.layoutObject().paintOffset()));
   rectToMap = LayoutRect(m_geometryMapper->sourceToDestinationRect(
       localRect, layerTransform, rootTransform));
-  rectToMap.moveBy(-context.rootLayer->layoutObject()->paintOffset());
+  rectToMap.moveBy(-context.rootLayer->layoutObject().paintOffset());
   rectToMap.move(context.subPixelAccumulation);
 }
 
 void PaintLayerClipper::calculateRectsWithGeometryMapper(
     const ClipRectsContext& context,
     const LayoutRect& paintDirtyRect,
     LayoutRect& layerBounds,
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
-  const auto* properties = m_layer.layoutObject()->paintProperties();
+  const auto* properties = m_layer.layoutObject().paintProperties();
   // TODO(chrishtr): fix the underlying bug that causes this situation.
   if (!properties) {
     backgroundRect = ClipRect(LayoutRect(LayoutRect::infiniteIntRect()));
     foregroundRect = ClipRect(LayoutRect(LayoutRect::infiniteIntRect()));
   } else {
     backgroundRect = clipRectWithGeometryMapper(context, false);
 
     backgroundRect.move(context.subPixelAccumulation);
     backgroundRect.intersect(paintDirtyRect);
 
@@ skipping 31 matching lines @@
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
   if (m_geometryMapper) {
     calculateRectsWithGeometryMapper(context, paintDirtyRect, layerBounds,
                                      backgroundRect, foregroundRect,
                                      offsetFromRoot);
     return;
   }
 
   bool isClippingRoot = &m_layer == context.rootLayer;
-  LayoutBoxModelObject& layoutObject = *m_layer.layoutObject();
+  LayoutBoxModelObject& layoutObject = m_layer.layoutObject();
 
   if (!isClippingRoot && m_layer.parent()) {
     backgroundRect = backgroundClipRect(context);
     backgroundRect.move(context.subPixelAccumulation);
     backgroundRect.intersect(paintDirtyRect);
   } else {
     backgroundRect = paintDirtyRect;
   }
 
   foregroundRect = backgroundRect;
@@ skipping 35 matching lines @@
   if (layoutObject.hasClip()) {
     // Clip applies to *us* as well, so go ahead and update the damageRect.
     LayoutRect newPosClip = toLayoutBox(layoutObject).clipRect(offset);
     backgroundRect.intersect(newPosClip);
     foregroundRect.intersect(newPosClip);
   }
 }
 
 void PaintLayerClipper::calculateClipRects(const ClipRectsContext& context,
                                            ClipRects& clipRects) const {
-  const LayoutBoxModelObject& layoutObject = *m_layer.layoutObject();
+  const LayoutBoxModelObject& layoutObject = m_layer.layoutObject();
   if (!m_layer.parent() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // The root layer's clip rect is always infinite.
     clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
     return;
   }
 
   bool isClippingRoot = &m_layer == context.rootLayer;
 
   // For transformed layers, the root layer was shifted to be us, so there is no
@@ skipping 11 matching lines @@
 
   adjustClipRectsForChildren(layoutObject, clipRects);
 
   if (shouldClipOverflow(context) || layoutObject.hasClip()) {
     // This offset cannot use convertToLayerCoords, because sometimes our
     // rootLayer may be across some transformed layer boundary, for example, in
     // the PaintLayerCompositor overlapMap, where clipRects are needed in view
     // space.
     applyClipRects(context, layoutObject,
                    LayoutPoint(layoutObject.localToAncestorPoint(
-                       FloatPoint(), context.rootLayer->layoutObject())),
+                       FloatPoint(), &context.rootLayer->layoutObject())),
                    clipRects);
   }
 }
 
 static ClipRect backgroundClipRectForPosition(const ClipRects& parentRects,
                                               EPosition position) {
   if (position == EPosition::kFixed)
     return parentRects.fixedClipRect();
 
   if (position == EPosition::kAbsolute)
     return parentRects.posClipRect();
 
   return parentRects.overflowClipRect();
 }
 
 ClipRect PaintLayerClipper::clipRectWithGeometryMapper(
     const ClipRectsContext& context,
     bool isForeground) const {
   DCHECK(m_geometryMapper);
-  const auto* properties = m_layer.layoutObject()->paintProperties();
+  const auto* properties = m_layer.layoutObject().paintProperties();
   DCHECK(properties && properties->localBorderBoxProperties());
 
   PropertyTreeState propertyTreeState = *properties->localBorderBoxProperties();
   const auto* ancestorProperties =
-      context.rootLayer->layoutObject()->paintProperties();
+      context.rootLayer->layoutObject().paintProperties();
   DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
   PropertyTreeState destinationPropertyTreeState =
       *ancestorProperties->localBorderBoxProperties();
 
   if (&m_layer == context.rootLayer) {
     // Set the overflow clip for |propertyTreeState| so that it differs from
     // |destinationPropertyTreeState| in its clip.
     if (isForeground && context.respectOverflowClip == RespectOverflowClip &&
         properties->overflowClip())
       propertyTreeState.setClip(properties->overflowClip());
@@ skipping 10 matching lines @@
       propertyTreeState.setClip(properties->overflowClip());
   }
 
   FloatClipRect clippedRectInRootLayerSpace =
       m_geometryMapper->sourceToDestinationClipRect(
           propertyTreeState, destinationPropertyTreeState);
   ClipRect clipRect(LayoutRect(clippedRectInRootLayerSpace.rect()));
   if (clippedRectInRootLayerSpace.hasRadius())
     clipRect.setHasRadius(true);
 
-  clipRect.moveBy(-context.rootLayer->layoutObject()->paintOffset());
+  clipRect.moveBy(-context.rootLayer->layoutObject().paintOffset());
   return clipRect;
 }
 
 void PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
     const ClipRectsContext& context,
     ClipRect& clip) const {
-  const LayoutObject& layoutObject = *m_layer.layoutObject();
+  const LayoutObject& layoutObject = m_layer.layoutObject();
   if (!shouldClipOverflow(context))
     return;
   LayoutRect layerBoundsWithVisualOverflow =
       layoutObject.isLayoutView()
           ? toLayoutView(layoutObject).viewRect()
           : toLayoutBox(layoutObject).visualOverflowRect();
   toLayoutBox(layoutObject)
       .flipForWritingMode(
           // PaintLayer are in physical coordinates, so the overflow has to be
           // flipped.
           layerBoundsWithVisualOverflow);
   mapLocalToRootWithGeometryMapper(context, layerBoundsWithVisualOverflow);
   clip.intersect(layerBoundsWithVisualOverflow);
 }
 
 ClipRect PaintLayerClipper::backgroundClipRect(
     const ClipRectsContext& context) const {
   if (m_geometryMapper) {
     ClipRect backgroundClipRect = clipRectWithGeometryMapper(context, false);
 #ifdef CHECK_CLIP_RECTS
     ClipRect testBackgroundClipRect =
         PaintLayerClipper(m_layer, nullptr).backgroundClipRect(context);
     CHECK_RECTS_EQ(testBackgroundClipRect, backgroundClipRect);
 #endif
     return backgroundClipRect;
   }
   DCHECK(m_layer.parent());
-  LayoutView* layoutView = m_layer.layoutObject()->view();
+  LayoutView* layoutView = m_layer.layoutObject().view();
   DCHECK(layoutView);
 
   RefPtr<ClipRects> parentClipRects = ClipRects::create();
   if (&m_layer == context.rootLayer) {
     parentClipRects->reset(LayoutRect(LayoutRect::infiniteIntRect()));
   } else {
     PaintLayerClipper(*m_layer.parent(), m_geometryMapper)
         .getOrCalculateClipRects(context, *parentClipRects);
   }
 
   ClipRect result = backgroundClipRectForPosition(
-      *parentClipRects, m_layer.layoutObject()->styleRef().position());
+      *parentClipRects, m_layer.layoutObject().styleRef().position());
 
   // Note: infinite clipRects should not be scrolled here, otherwise they will
   // accidentally no longer be considered infinite.
   if (parentClipRects->fixed() &&
-      context.rootLayer->layoutObject() == layoutView &&
+      &context.rootLayer->layoutObject() == layoutView &&
       result != LayoutRect(LayoutRect::infiniteIntRect()))
     result.move(LayoutSize(layoutView->frameView()->getScrollOffset()));
 
   return result;
 }
 
 void PaintLayerClipper::getOrCalculateClipRects(const ClipRectsContext& context,
                                                 ClipRects& clipRects) const {
   DCHECK(!m_geometryMapper);
 
   if (context.usesCache())
     clipRects = getClipRects(context);
   else
     calculateClipRects(context, clipRects);
 }
 
 bool PaintLayerClipper::shouldClipOverflow(
     const ClipRectsContext& context) const {
-  if (!m_layer.layoutObject()->isBox())
+  if (!m_layer.layoutObject().isBox())
     return false;
-  const LayoutBox& box = *toLayoutBox(m_layer.layoutObject());
+  const LayoutBox& box = toLayoutBox(m_layer.layoutObject());
 
   if (!shouldRespectOverflowClip(context))
     return false;
 
   return box.shouldClipOverflow();
 }
 
 bool PaintLayerClipper::shouldRespectOverflowClip(
     const ClipRectsContext& context) const {
   if (&m_layer != context.rootLayer)
@@ skipping 15 matching lines @@
     const LayoutSize& subpixelAccumulation) const {
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnoreOverlayScrollbarSize, subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink