Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/paint/PaintLayer.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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 197 matching lines @@
 // need to be moved to the appropriate LayoutObject class, probably to a rare
 // data field to avoid growing all the LayoutObjects.
 //
 // A good example of this is PaintLayerScrollableArea, which can only happen
 // be instanciated for LayoutBoxes. With the current design, it's hard to know
 // that by reading the code.
 class CORE_EXPORT PaintLayer : public DisplayItemClient {
   WTF_MAKE_NONCOPYABLE(PaintLayer);
 
  public:
-  PaintLayer(LayoutBoxModelObject*);
+  PaintLayer(LayoutBoxModelObject&);
   ~PaintLayer() override;
 
   // DisplayItemClient methods
   String debugName() const final;
   LayoutRect visualRect() const final;
 
-  LayoutBoxModelObject* layoutObject() const { return m_layoutObject; }
+  LayoutBoxModelObject& layoutObject() const { return m_layoutObject; }
   LayoutBox* layoutBox() const {
-    return m_layoutObject && m_layoutObject->isBox()
-               ? toLayoutBox(m_layoutObject)
-               : 0;
+    return m_layoutObject.isBox() ? &toLayoutBox(m_layoutObject) : 0;
   }
   PaintLayer* parent() const { return m_parent; }
   PaintLayer* previousSibling() const { return m_previous; }
   PaintLayer* nextSibling() const { return m_next; }
   PaintLayer* firstChild() const { return m_first; }
   PaintLayer* lastChild() const { return m_last; }
 
   // TODO(wangxianzhu): Find a better name for it. 'paintContainer' might be
   // good but we can't use it for now because it conflicts with
   // PaintInfo::paintContainer.
   PaintLayer* compositingContainer() const;
 
   void addChild(PaintLayer* newChild, PaintLayer* beforeChild = 0);
   PaintLayer* removeChild(PaintLayer*);
 
   void removeOnlyThisLayerAfterStyleChange();
   void insertOnlyThisLayerAfterStyleChange();
 
   void styleDidChange(StyleDifference, const ComputedStyle* oldStyle);
 
   // FIXME: Many people call this function while it has out-of-date information.
   bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
 
   bool isTransparent() const {
-    return layoutObject()->isTransparent() ||
-           layoutObject()->style()->hasBlendMode() || layoutObject()->hasMask();
+    return layoutObject().isTransparent() ||
+           layoutObject().style()->hasBlendMode() || layoutObject().hasMask();
   }
 
   const PaintLayer* root() const {
     const PaintLayer* curr = this;
     while (curr->parent())
       curr = curr->parent();
     return curr;
   }
 
   const LayoutPoint& location() const {
@@ skipping 92 matching lines @@
   // Layer::paint*() methods.
   PaintLayer* enclosingLayerForPaintInvalidation() const;
 
   PaintLayer* enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const;
 
   bool hasAncestorWithFilterThatMovesPixels() const;
 
   bool canUseConvertToLayerCoords() const {
     // These LayoutObjects have an impact on their layers without the
     // layoutObjects knowing about it.
-    return !layoutObject()->hasTransformRelatedProperty() &&
-           !layoutObject()->isSVGRoot();
+    return !layoutObject().hasTransformRelatedProperty() &&
+           !layoutObject().isSVGRoot();
   }
 
   void convertToLayerCoords(const PaintLayer* ancestorLayer,
                             LayoutPoint&) const;
   void convertToLayerCoords(const PaintLayer* ancestorLayer, LayoutRect&) const;
 
   // Does the same as convertToLayerCoords() when not in multicol. For multicol,
   // however, convertToLayerCoords() calculates the offset in flow-thread
   // coordinates (what the layout engine uses internally), while this method
   // calculates the visual coordinates; i.e. it figures out which column the
@@ skipping 55 matching lines @@
     m_staticInlinePosition = position;
   }
   void setStaticBlockPosition(LayoutUnit position) {
     m_staticBlockPosition = position;
   }
 
   LayoutSize subpixelAccumulation() const;
   void setSubpixelAccumulation(const LayoutSize&);
 
   bool hasTransformRelatedProperty() const {
-    return layoutObject()->hasTransformRelatedProperty();
+    return layoutObject().hasTransformRelatedProperty();
   }
   // Note that this transform has the transform-origin baked in.
   TransformationMatrix* transform() const {
     return m_rareData ? m_rareData->transform.get() : nullptr;
   }
 
   // currentTransform computes a transform which takes accelerated animations
   // into account. The resulting transform has transform-origin baked in. If the
   // layer does not have a transform, returns the identity matrix.
   TransformationMatrix currentTransform() const;
   TransformationMatrix renderableTransform(GlobalPaintFlags) const;
 
   // Get the perspective transform, which is applied to transformed sublayers.
   // Returns true if the layer has a -webkit-perspective.
   // Note that this transform does not have the perspective-origin baked in.
   TransformationMatrix perspectiveTransform() const;
   FloatPoint perspectiveOrigin() const;
-  bool preserves3D() const { return layoutObject()->style()->preserves3D(); }
+  bool preserves3D() const { return layoutObject().style()->preserves3D(); }
   bool has3DTransform() const {
     return m_rareData && m_rareData->transform &&
            !m_rareData->transform->isAffine();
   }
 
   // FIXME: reflections should force transform-style to be flat in the style:
   // https://bugs.webkit.org/show_bug.cgi?id=106959
   bool shouldPreserve3D() const {
-    return !layoutObject()->hasReflection() &&
-           layoutObject()->style()->preserves3D();
+    return !layoutObject().hasReflection() &&
+           layoutObject().style()->preserves3D();
   }
 
   // Returns |true| if any property that renders using filter operations is
   // used (including, but not limited to, 'filter' and 'box-reflect').
   bool hasFilterInducingProperty() const {
-    return layoutObject()->hasFilterInducingProperty();
+    return layoutObject().hasFilterInducingProperty();
   }
 
   void* operator new(size_t);
   // Only safe to call from LayoutBoxModelObject::destroyLayer()
   void operator delete(void*);
 
   CompositingState compositingState() const;
 
   // This returns true if our document is in a phase of its lifestyle during
   // which compositing state may legally be read.
@@ skipping 195 matching lines @@
 
     // A clip parent is another compositor concept that has leaked into
     // blink so that it may be used as a promotion trigger. Layers with clip
     // parents escape the clip of a stacking tree ancestor. The compositor
     // needs to know about clip parents in order to circumvent its normal
     // clipping logic.
     const PaintLayer* clipParent;
 
     IntRect clippedAbsoluteBoundingBox;
     IntRect unclippedAbsoluteBoundingBox;
-    const LayoutObject* clippingContainer;
+    const LayoutBoxModelObject* clippingContainer;
   };
 
   void setNeedsCompositingInputsUpdate();
   bool childNeedsCompositingInputsUpdate() const {
     return m_childNeedsCompositingInputsUpdate;
   }
   bool needsCompositingInputsUpdate() const {
     return m_needsAncestorDependentCompositingInputsUpdate;
   }
 
@@ skipping 28 matching lines @@
     return m_ancestorDependentCompositingInputs
                ? m_ancestorDependentCompositingInputs->transformAncestor
                : nullptr;
   }
   const PaintLayer* filterAncestor() const {
     DCHECK(!m_needsAncestorDependentCompositingInputsUpdate);
     return m_ancestorDependentCompositingInputs
                ? m_ancestorDependentCompositingInputs->filterAncestor
                : nullptr;
   }
-  const LayoutObject* clippingContainer() const {
+  const LayoutBoxModelObject* clippingContainer() const {
     DCHECK(!m_needsAncestorDependentCompositingInputsUpdate);
     return m_ancestorDependentCompositingInputs->clippingContainer;
   }
   const PaintLayer* ancestorOverflowLayer() const {
     return m_ancestorOverflowLayer;
   }
   const PaintLayer* ancestorScrollingLayer() const {
     DCHECK(!m_needsAncestorDependentCompositingInputsUpdate);
     return m_ancestorDependentCompositingInputs
                ? m_ancestorDependentCompositingInputs->ancestorScrollingLayer
@@ skipping 109 matching lines @@
       const LayoutRect& dirtyRect,
       ClipRectsCacheSlot,
       GeometryMapperOption,
       OverlayScrollbarClipBehavior = IgnoreOverlayScrollbarSize,
       ShouldRespectOverflowClipType = RespectOverflowClip,
       const LayoutPoint* offsetFromRoot = 0,
       const LayoutSize& subPixelAccumulation = LayoutSize(),
       const LayoutRect* layerBoundingBox = 0);
 
   LayoutPoint layoutBoxLocation() const {
-    return layoutObject()->isBox() ? toLayoutBox(layoutObject())->location()
-                                   : LayoutPoint();
+    return layoutObject().isBox() ? toLayoutBox(layoutObject()).location()
+                                  : LayoutPoint();
   }
 
   enum TransparencyClipBoxBehavior {
     PaintingTransparencyClipBox,
     HitTestingTransparencyClipBox
   };
 
   enum TransparencyClipBoxMode {
     DescendantsOfTransparencyClipBox,
     RootOfTransparencyClipBox
@@ skipping 317 matching lines @@
 
   // These bitfields are part of ancestor/descendant dependent compositing
   // inputs.
   unsigned m_hasDescendantWithClipPath : 1;
   unsigned m_hasNonIsolatedDescendantWithBlendMode : 1;
   unsigned m_hasAncestorWithClipPath : 1;
   unsigned m_hasRootScrollerAsDescendant : 1;
 
   unsigned m_selfPaintingStatusChanged : 1;
 
-  LayoutBoxModelObject* m_layoutObject;
+  LayoutBoxModelObject& m_layoutObject;
 
   PaintLayer* m_parent;
   PaintLayer* m_previous;
   PaintLayer* m_next;
   PaintLayer* m_first;
   PaintLayer* m_last;
 
   // Our (x,y) coordinates are in our containing layer's coordinate space.
   LayoutPoint m_location;
 
@@ skipping 32 matching lines @@
 
 }  // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 CORE_EXPORT void showLayerTree(const blink::PaintLayer*);
 CORE_EXPORT void showLayerTree(const blink::LayoutObject*);
 #endif
 
 #endif  // Layer_h