Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/paint/PaintLayer.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 109 matching lines @@
 
 PaintLayerRareData::PaintLayerRareData()
     : enclosingPaginationLayer(nullptr),
       potentialCompositingReasonsFromStyle(CompositingReasonNone),
       compositingReasons(CompositingReasonNone),
       squashingDisallowedReasons(SquashingDisallowedReasonsNone),
       groupedMapping(nullptr) {}
 
 PaintLayerRareData::~PaintLayerRareData() {}
 
-PaintLayer::PaintLayer(LayoutBoxModelObject* layoutObject)
+PaintLayer::PaintLayer(LayoutBoxModelObject& layoutObject)
     : m_hasSelfPaintingLayerDescendant(false),
       m_hasSelfPaintingLayerDescendantDirty(false),
-      m_isRootLayer(layoutObject->isLayoutView()),
+      m_isRootLayer(layoutObject.isLayoutView()),
       m_hasVisibleContent(false),
       m_needsDescendantDependentFlagsUpdate(true),
       m_hasVisibleDescendant(false),
 #if DCHECK_IS_ON()
       m_needsPositionUpdate(true),
 #endif
       m_has3DTransformedDescendant(false),
       m_containsDirtyOverlayScrollbars(false),
       m_needsAncestorDependentCompositingInputsUpdate(true),
       m_childNeedsCompositingInputsUpdate(true),
@@ skipping 25 matching lines @@
       m_ancestorOverflowLayer(nullptr) {
   updateStackingNode();
 
   m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
 
   updateScrollableArea();
 }
 
 PaintLayer::~PaintLayer() {
   if (m_rareData && m_rareData->resourceInfo) {
-    const ComputedStyle& style = layoutObject()->styleRef();
+    const ComputedStyle& style = layoutObject().styleRef();
     if (style.hasFilter())
       style.filter().removeClient(m_rareData->resourceInfo);
     if (isReferenceClipPath(style.clipPath())) {
       toReferenceClipPathOperation(style.clipPath())
           ->removeClient(m_rareData->resourceInfo);
     }
     m_rareData->resourceInfo->clearLayer();
   }
-  if (layoutObject()->frame() && layoutObject()->frame()->page()) {
+  if (layoutObject().frame() && layoutObject().frame()->page()) {
     if (ScrollingCoordinator* scrollingCoordinator =
-            layoutObject()->frame()->page()->scrollingCoordinator())
+            layoutObject().frame()->page()->scrollingCoordinator())
       scrollingCoordinator->willDestroyLayer(this);
   }
 
   if (groupedMapping()) {
     DisableCompositingQueryAsserts disabler;
     setGroupedMapping(0, InvalidateLayerAndRemoveFromMapping);
   }
 
   // Child layers will be deleted by their corresponding layout objects, so
   // we don't need to delete them ourselves.
 
   clearCompositedLayerMapping(true);
 
   if (m_scrollableArea)
     m_scrollableArea->dispose();
 }
 
 String PaintLayer::debugName() const {
-  return layoutObject()->debugName();
+  return layoutObject().debugName();
 }
 
 LayoutRect PaintLayer::visualRect() const {
-  return m_layoutObject->visualRect();
+  return m_layoutObject.visualRect();
 }
 
 PaintLayerCompositor* PaintLayer::compositor() const {
-  if (!layoutObject()->view())
+  if (!layoutObject().view())
     return 0;
-  return layoutObject()->view()->compositor();
+  return layoutObject().view()->compositor();
 }
 
 void PaintLayer::contentChanged(ContentChangeType changeType) {
   // updateLayerCompositingState will query compositingReasons for accelerated
   // overflow scrolling.  This is tripped by
   // LayoutTests/compositing/content-changed-chicken-egg.html
   DisableCompositingQueryAsserts disabler;
 
   if (changeType == CanvasChanged)
     compositor()->setNeedsCompositingUpdate(
@@ skipping 11 matching lines @@
       compositedLayerMapping()->setNeedsGraphicsLayerUpdate(
           GraphicsLayerUpdateSubtree);
   }
 
   if (CompositedLayerMapping* compositedLayerMapping =
           this->compositedLayerMapping())
     compositedLayerMapping->contentChanged(changeType);
 }
 
 bool PaintLayer::paintsWithFilters() const {
-  if (!layoutObject()->hasFilterInducingProperty())
+  if (!layoutObject().hasFilterInducingProperty())
     return false;
 
   // https://code.google.com/p/chromium/issues/detail?id=343759
   DisableCompositingQueryAsserts disabler;
   return !compositedLayerMapping() ||
          compositingState() != PaintsIntoOwnBacking;
 }
 
 bool PaintLayer::paintsWithBackdropFilters() const {
-  if (!layoutObject()->hasBackdropFilter())
+  if (!layoutObject().hasBackdropFilter())
     return false;
 
   // https://code.google.com/p/chromium/issues/detail?id=343759
   DisableCompositingQueryAsserts disabler;
   return !compositedLayerMapping() ||
          compositingState() != PaintsIntoOwnBacking;
 }
 
 LayoutSize PaintLayer::subpixelAccumulation() const {
   return m_rareData ? m_rareData->subpixelAccumulation : LayoutSize();
@@ skipping 51 matching lines @@
     // ancestors further.
     if (layer->isSelfPaintingLayer()) {
       DCHECK(!parent() || parent()->m_hasSelfPaintingLayerDescendantDirty ||
              parent()->m_hasSelfPaintingLayerDescendant);
       break;
     }
   }
 }
 
 bool PaintLayer::sticksToViewport() const {
-  if (layoutObject()->style()->position() != EPosition::kFixed &&
-      layoutObject()->style()->position() != EPosition::kSticky)
+  if (layoutObject().style()->position() != EPosition::kFixed &&
+      layoutObject().style()->position() != EPosition::kSticky)
     return false;
 
   // TODO(pdr): This approach of calculating the nearest scroll node is O(n).
   // An option for improving this is to cache the nearest scroll node in
   // the local border box properties.
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
-    const auto* viewProperties = layoutObject()->view()->paintProperties();
+    const auto* viewProperties = layoutObject().view()->paintProperties();
     const ScrollPaintPropertyNode* ancestorTargetScrollNode;
-    if (layoutObject()->style()->position() == EPosition::kFixed) {
+    if (layoutObject().style()->position() == EPosition::kFixed) {
       ancestorTargetScrollNode = viewProperties->localBorderBoxProperties()
                                      ->transform()
                                      ->findEnclosingScrollNode();
     } else {
       ancestorTargetScrollNode = viewProperties->contentsProperties()
                                      ->transform()
                                      ->findEnclosingScrollNode();
     }
 
-    const auto* properties = layoutObject()->paintProperties();
+    const auto* properties = layoutObject().paintProperties();
     const auto* transform = properties->localBorderBoxProperties()->transform();
     return transform->findEnclosingScrollNode() == ancestorTargetScrollNode;
   }
 
-  return (layoutObject()->style()->position() == EPosition::kFixed &&
-          layoutObject()->containerForFixedPosition() ==
-              layoutObject()->view()) ||
-         (layoutObject()->style()->position() == EPosition::kSticky &&
+  return (layoutObject().style()->position() == EPosition::kFixed &&
+          layoutObject().containerForFixedPosition() ==
+              layoutObject().view()) ||
+         (layoutObject().style()->position() == EPosition::kSticky &&
           (!ancestorScrollingLayer() || ancestorScrollingLayer() == root()));
 }
 
 bool PaintLayer::scrollsWithRespectTo(const PaintLayer* other) const {
   if (sticksToViewport() != other->sticksToViewport())
     return true;
   return ancestorScrollingLayer() != other->ancestorScrollingLayer();
 }
 
 void PaintLayer::updateLayerPositionsAfterOverflowScroll() {
@@ skipping 16 matching lines @@
 }
 
 void PaintLayer::updateTransform(const ComputedStyle* oldStyle,
                                  const ComputedStyle& newStyle) {
   if (oldStyle && newStyle.transformDataEquivalent(*oldStyle))
     return;
 
   // hasTransform() on the layoutObject is also true when there is
   // transform-style: preserve-3d or perspective set, so check style too.
   bool hasTransform =
-      layoutObject()->hasTransformRelatedProperty() && newStyle.hasTransform();
+      layoutObject().hasTransformRelatedProperty() && newStyle.hasTransform();
   bool had3DTransform = has3DTransform();
 
   bool hadTransform = transform();
   if (hasTransform != hadTransform) {
     if (hasTransform)
       ensureRareData().transform = TransformationMatrix::create();
     else
       m_rareData->transform.reset();
 
     // PaintLayers with transforms act as clip rects roots, so clear the cached
     // clip rects here.
     clipper(PaintLayer::DoNotUseGeometryMapper)
         .clearClipRectsIncludingDescendants();
   } else if (hasTransform) {
     clipper(PaintLayer::DoNotUseGeometryMapper)
         .clearClipRectsIncludingDescendants(AbsoluteClipRects);
   }
 
   updateTransformationMatrix();
 
   if (had3DTransform != has3DTransform())
     markAncestorChainForDescendantDependentFlagsUpdate();
 
-  if (FrameView* frameView = layoutObject()->document().view())
+  if (FrameView* frameView = layoutObject().document().view())
     frameView->setNeedsUpdateWidgetGeometries();
 }
 
 static PaintLayer* enclosingLayerForContainingBlock(PaintLayer* layer) {
-  if (LayoutObject* containingBlock = layer->layoutObject()->containingBlock())
+  if (LayoutObject* containingBlock = layer->layoutObject().containingBlock())
     return containingBlock->enclosingLayer();
   return 0;
 }
 
 static const PaintLayer* enclosingLayerForContainingBlock(
     const PaintLayer* layer) {
   if (const LayoutObject* containingBlock =
-          layer->layoutObject()->containingBlock())
+          layer->layoutObject().containingBlock())
     return containingBlock->enclosingLayer();
   return 0;
 }
 
 PaintLayer* PaintLayer::renderingContextRoot() {
   PaintLayer* renderingContext = 0;
 
   if (shouldPreserve3D())
     renderingContext = this;
 
@@ skipping 38 matching lines @@
   }
 
   return *transform;
 }
 
 void PaintLayer::convertFromFlowThreadToVisualBoundingBoxInAncestor(
     const PaintLayer* ancestorLayer,
     LayoutRect& rect) const {
   PaintLayer* paginationLayer = enclosingPaginationLayer();
   DCHECK(paginationLayer);
-  LayoutFlowThread* flowThread =
+  LayoutFlowThread& flowThread =
       toLayoutFlowThread(paginationLayer->layoutObject());
 
   // First make the flow thread rectangle relative to the flow thread, not to
   // |layer|.
   LayoutPoint offsetWithinPaginationLayer;
   convertToLayerCoords(paginationLayer, offsetWithinPaginationLayer);
   rect.moveBy(offsetWithinPaginationLayer);
 
   // Then make the rectangle visual, relative to the fragmentation context.
   // Split our box up into the actual fragment boxes that layout in the
   // columns/pages and unite those together to get our true bounding box.
-  rect = flowThread->fragmentsBoundingBox(rect);
+  rect = flowThread.fragmentsBoundingBox(rect);
 
   // Finally, make the visual rectangle relative to |ancestorLayer|.
   if (ancestorLayer->enclosingPaginationLayer() != paginationLayer) {
     rect.moveBy(paginationLayer->visualOffsetFromAncestor(ancestorLayer));
     return;
   }
   // The ancestor layer is inside the same pagination layer as |layer|, so we
   // need to subtract the visual distance from the ancestor layer to the
   // pagination layer.
   rect.moveBy(-ancestorLayer->visualOffsetFromAncestor(paginationLayer));
 }
 
 void PaintLayer::updatePaginationRecursive(bool needsPaginationUpdate) {
   if (m_rareData)
     m_rareData->enclosingPaginationLayer = nullptr;
 
-  if (layoutObject()->isLayoutFlowThread())
+  if (layoutObject().isLayoutFlowThread())
     needsPaginationUpdate = true;
 
   if (needsPaginationUpdate) {
     // Each paginated layer has to paint on its own. There is no recurring into
     // child layers. Each layer has to be checked individually and genuinely
     // know if it is going to have to split itself up when painting only its
     // contents (and not any other descendant layers). We track an
     // enclosingPaginationLayer instead of using a simple bit, since we want to
     // be able to get back to that layer easily.
     if (LayoutFlowThread* containingFlowThread =
-            layoutObject()->flowThreadContainingBlock())
+            layoutObject().flowThreadContainingBlock())
       ensureRareData().enclosingPaginationLayer = containingFlowThread->layer();
   }
 
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling())
     child->updatePaginationRecursive(needsPaginationUpdate);
 }
 
 void PaintLayer::clearPaginationRecursive() {
   if (m_rareData)
     m_rareData->enclosingPaginationLayer = nullptr;
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling())
     child->clearPaginationRecursive();
 }
 
 void PaintLayer::mapPointInPaintInvalidationContainerToBacking(
     const LayoutBoxModelObject& paintInvalidationContainer,
     FloatPoint& point) {
   PaintLayer* paintInvalidationLayer = paintInvalidationContainer.layer();
   if (!paintInvalidationLayer->groupedMapping())
     return;
 
-  LayoutBoxModelObject* transformedAncestor =
+  LayoutBoxModelObject& transformedAncestor =
       paintInvalidationLayer->enclosingTransformedAncestor()->layoutObject();

[chrishtr, 2017/02/17 17:23:07]

This looks like a bug in the old code. I think it's supposed to be:

LayoutBoxModelObject*  transformedAncestor =
paintInvalidationLayer->enclosingTransformedAncestor();

if (!transformedAncestor)
  return;

[chrishtr, 2017/02/17 17:24:07]

Make that:

PaintLayer*  transformedAncestorPaintLayer =
paintInvalidationLayer->enclosingTransformedAncestor();
if (!transformedAncestorPaintLayer)
   return;

[szager1, 2017/02/17 18:06:26]

How about putting this in a separate patch?  I don't want to mix functional
changes into this big refactor.

-  if (!transformedAncestor)
-    return;
 
   // |paintInvalidationContainer| may have a local 2D transform on it, so take
   // that into account when mapping into the space of the transformed ancestor.
   point = paintInvalidationContainer.localToAncestorPoint(point,
-                                                          transformedAncestor);
+                                                          &transformedAncestor);
 
   point.moveBy(-paintInvalidationLayer->groupedMapping()
                     ->squashingOffsetFromTransformedAncestor());
 }
 
 void PaintLayer::mapRectInPaintInvalidationContainerToBacking(
     const LayoutBoxModelObject& paintInvalidationContainer,
     LayoutRect& rect) {
   PaintLayer* paintInvalidationLayer = paintInvalidationContainer.layer();
   if (!paintInvalidationLayer->groupedMapping())
     return;
 
-  LayoutBoxModelObject* transformedAncestor =
+  LayoutBoxModelObject& transformedAncestor =
       paintInvalidationLayer->enclosingTransformedAncestor()->layoutObject();
-  if (!transformedAncestor)

[chrishtr, 2017/02/17 17:23:07]

ditto

-    return;
 
   // |paintInvalidationContainer| may have a local 2D transform on it, so take
   // that into account when mapping into the space of the transformed ancestor.
   rect =
       LayoutRect(paintInvalidationContainer
-                     .localToAncestorQuad(FloatRect(rect), transformedAncestor)
+                     .localToAncestorQuad(FloatRect(rect), &transformedAncestor)
                      .boundingBox());
 
   rect.moveBy(-paintInvalidationLayer->groupedMapping()
                    ->squashingOffsetFromTransformedAncestor());
 }
 
 void PaintLayer::mapRectToPaintInvalidationBacking(
     const LayoutObject& layoutObject,
     const LayoutBoxModelObject& paintInvalidationContainer,
     LayoutRect& rect) {
@@ skipping 25 matching lines @@
     parent()->dirtyVisibleContentStatus();
 }
 
 void PaintLayer::markAncestorChainForDescendantDependentFlagsUpdate() {
   for (PaintLayer* layer = this; layer; layer = layer->parent()) {
     if (layer->m_needsDescendantDependentFlagsUpdate)
       break;
     layer->m_needsDescendantDependentFlagsUpdate = true;
 
     if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
-      layer->layoutObject()->setNeedsPaintPropertyUpdate();
+      layer->layoutObject().setNeedsPaintPropertyUpdate();
   }
 }
 
 // FIXME: this is quite brute-force. We could be more efficient if we were to
 // track state and update it as appropriate as changes are made in the layout
 // tree.
 void PaintLayer::updateScrollingStateAfterCompositingChange() {
   TRACE_EVENT0("blink",
                "PaintLayer::updateScrollingStateAfterCompositingChange");
   m_isAllScrollingContentComposited = true;
-  for (LayoutObject* r = layoutObject()->slowFirstChild(); r;
+  for (LayoutObject* r = layoutObject().slowFirstChild(); r;
        r = r->nextSibling()) {
     if (!r->hasLayer()) {
       m_isAllScrollingContentComposited = false;
       return;
     }
   }
 
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling()) {
     if (child->compositingState() == NotComposited) {
       m_isAllScrollingContentComposited = false;
@@ skipping 19 matching lines @@
     for (PaintLayer* child = firstChild(); child;
          child = child->nextSibling()) {
       child->updateDescendantDependentFlags();
 
       if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
         m_hasVisibleDescendant = true;
 
       m_hasNonIsolatedDescendantWithBlendMode |=
           (!child->stackingNode()->isStackingContext() &&
            child->hasNonIsolatedDescendantWithBlendMode()) ||
-          child->layoutObject()->styleRef().hasBlendMode();
+          child->layoutObject().styleRef().hasBlendMode();
 
       m_hasDescendantWithClipPath |= child->hasDescendantWithClipPath() ||
-                                     child->layoutObject()->hasClipPath();
+                                     child->layoutObject().hasClipPath();
 
       m_hasRootScrollerAsDescendant |= child->hasRootScrollerAsDescendant() ||
                                        (child ==
                                         child->layoutObject()
-                                            ->document()
+                                            .document()
                                             .rootScrollerController()
                                             .rootScrollerPaintLayer());
     }
 
     if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
         oldHasNonIsolatedDescendantWithBlendMode !=
             static_cast<bool>(m_hasNonIsolatedDescendantWithBlendMode))
-      layoutObject()->setNeedsPaintPropertyUpdate();
+      layoutObject().setNeedsPaintPropertyUpdate();
     m_needsDescendantDependentFlagsUpdate = false;
   }
 
   bool previouslyHasVisibleContent = m_hasVisibleContent;
-  if (layoutObject()->style()->visibility() == EVisibility::kVisible) {
+  if (layoutObject().style()->visibility() == EVisibility::kVisible) {
     m_hasVisibleContent = true;
   } else {
     // layer may be hidden but still have some visible content, check for this
     m_hasVisibleContent = false;
-    LayoutObject* r = layoutObject()->slowFirstChild();
+    LayoutObject* r = layoutObject().slowFirstChild();
     while (r) {
       if (r->style()->visibility() == EVisibility::kVisible &&
           (!r->hasLayer() || !r->enclosingLayer()->isSelfPaintingLayer())) {
         m_hasVisibleContent = true;
         break;
       }
       LayoutObject* layoutObjectFirstChild = r->slowFirstChild();
       if (layoutObjectFirstChild &&
           (!r->hasLayer() || !r->enclosingLayer()->isSelfPaintingLayer())) {
         r = layoutObjectFirstChild;
       } else if (r->nextSibling()) {
         r = r->nextSibling();
       } else {
         do {
           r = r->parent();
-          if (r == layoutObject())
+          if (r == &layoutObject())
             r = 0;
         } while (r && !r->nextSibling());
         if (r)
           r = r->nextSibling();
       }
     }
   }
 
   if (hasVisibleContent() != previouslyHasVisibleContent) {
     setNeedsCompositingInputsUpdateInternal();
     // We need to tell m_layoutObject to recheck its rect because we
     // pretend that invisible LayoutObjects have 0x0 rects. Changing
     // visibility therefore changes our rect and we need to visit
     // this LayoutObject during the invalidateTreeIfNeeded walk.
-    m_layoutObject->setMayNeedPaintInvalidation();
+    m_layoutObject.setMayNeedPaintInvalidation();
   }
 
   update3DTransformedDescendantStatus();
 }
 
 void PaintLayer::update3DTransformedDescendantStatus() {
   m_has3DTransformedDescendant = false;
 
   m_stackingNode->updateZOrderLists();
 
@@ skipping 16 matching lines @@
       m_has3DTransformedDescendant = true;
       break;
     }
   }
 }
 
 void PaintLayer::updateLayerPosition() {
   LayoutPoint localPoint;
 
   bool didResize = false;
-  if (layoutObject()->isInline() && layoutObject()->isLayoutInline()) {
-    LayoutInline* inlineFlow = toLayoutInline(layoutObject());
-    IntRect lineBox = enclosingIntRect(inlineFlow->linesBoundingBox());
+  if (layoutObject().isInline() && layoutObject().isLayoutInline()) {
+    LayoutInline& inlineFlow = toLayoutInline(layoutObject());
+    IntRect lineBox = enclosingIntRect(inlineFlow.linesBoundingBox());
     m_size = lineBox.size();
   } else if (LayoutBox* box = layoutBox()) {
     IntSize newSize = pixelSnappedIntSize(box->size(), box->location());
     didResize = newSize != m_size;
     m_size = newSize;
     localPoint.moveBy(box->physicalLocation());
   }
 
-  if (!layoutObject()->isOutOfFlowPositioned() &&
-      !layoutObject()->isColumnSpanAll()) {
+  if (!layoutObject().isOutOfFlowPositioned() &&
+      !layoutObject().isColumnSpanAll()) {
     // We must adjust our position by walking up the layout tree looking for the
     // nearest enclosing object with a layer.
-    LayoutObject* curr = layoutObject()->container();
+    LayoutObject* curr = layoutObject().container();
     while (curr && !curr->hasLayer()) {
       if (curr->isBox() && !curr->isTableRow()) {
         // Rows and cells share the same coordinate space (that of the section).
         // Omit them when computing our xpos/ypos.
         localPoint.moveBy(toLayoutBox(curr)->physicalLocation());
       }
       curr = curr->container();
     }
     if (curr && curr->isTableRow()) {
       // Put ourselves into the row coordinate space.
       localPoint.moveBy(-toLayoutBox(curr)->physicalLocation());
     }
   }
 
   if (PaintLayer* containingLayer = this->containingLayer()) {
-    if (containingLayer->layoutObject()->hasOverflowClip()) {
+    if (containingLayer->layoutObject().hasOverflowClip()) {
       // Subtract our container's scroll offset.
       IntSize offset = containingLayer->layoutBox()->scrolledContentOffset();
       localPoint -= offset;
-    } else if (layoutObject()->isAbsolutePositioned() &&
-               containingLayer->layoutObject()->isInFlowPositioned() &&
-               containingLayer->layoutObject()->isLayoutInline()) {
+    } else if (layoutObject().isAbsolutePositioned() &&
+               containingLayer->layoutObject().isInFlowPositioned() &&
+               containingLayer->layoutObject().isLayoutInline()) {
       // Adjust offset for absolute under in-flow positioned inline.
       LayoutSize offset =
           toLayoutInline(containingLayer->layoutObject())
-              ->offsetForInFlowPositionedInline(*toLayoutBox(layoutObject()));
+              .offsetForInFlowPositionedInline(toLayoutBox(layoutObject()));
       localPoint += offset;
     }
   }
 
-  if (layoutObject()->isInFlowPositioned()) {
-    LayoutSize newOffset = layoutObject()->offsetForInFlowPosition();
+  if (layoutObject().isInFlowPositioned()) {
+    LayoutSize newOffset = layoutObject().offsetForInFlowPosition();
     if (m_rareData || !newOffset.isZero())
       ensureRareData().offsetForInFlowPosition = newOffset;
     localPoint.move(newOffset);
   } else if (m_rareData) {
     m_rareData->offsetForInFlowPosition = LayoutSize();
   }
 
   m_location = localPoint;
 
   if (m_scrollableArea && didResize)
     m_scrollableArea->visibleSizeChanged();
 
 #if DCHECK_IS_ON()
   m_needsPositionUpdate = false;
 #endif
 }
 
 TransformationMatrix PaintLayer::perspectiveTransform() const {
-  if (!layoutObject()->hasTransformRelatedProperty())
+  if (!layoutObject().hasTransformRelatedProperty())
     return TransformationMatrix();
 
-  const ComputedStyle& style = layoutObject()->styleRef();
+  const ComputedStyle& style = layoutObject().styleRef();
   if (!style.hasPerspective())
     return TransformationMatrix();
 
   TransformationMatrix t;
   t.applyPerspective(style.perspective());
   return t;
 }
 
 FloatPoint PaintLayer::perspectiveOrigin() const {
-  if (!layoutObject()->hasTransformRelatedProperty())
+  if (!layoutObject().hasTransformRelatedProperty())
     return FloatPoint();
 
-  const LayoutRect borderBox = toLayoutBox(layoutObject())->borderBoxRect();
-  const ComputedStyle& style = layoutObject()->styleRef();
+  const LayoutRect borderBox = toLayoutBox(layoutObject()).borderBoxRect();
+  const ComputedStyle& style = layoutObject().styleRef();
 
   return FloatPoint(floatValueForLength(style.perspectiveOriginX(),
                                         borderBox.width().toFloat()),
                     floatValueForLength(style.perspectiveOriginY(),
                                         borderBox.height().toFloat()));
 }
 
 PaintLayer* PaintLayer::containingLayer(const PaintLayer* ancestor,
                                         bool* skippedAncestor) const {
   // If we have specified an ancestor, surely the caller needs to know whether
   // we skipped it.
   DCHECK(!ancestor || skippedAncestor);
   if (skippedAncestor)
     *skippedAncestor = false;
 
-  LayoutObject* layoutObject = this->layoutObject();
-  if (layoutObject->isColumnSpanAll() ||
-      layoutObject->isFloatingWithNonContainingBlockParent()) {
+  LayoutObject& layoutObject = this->layoutObject();
+  if (layoutObject.isColumnSpanAll() ||
+      layoutObject.isFloatingWithNonContainingBlockParent()) {
     Optional<LayoutObject::AncestorSkipInfo> skipInfo;
     if (skippedAncestor)
-      skipInfo.emplace(ancestor->layoutObject());
-    if (auto containingBlock = layoutObject->containingBlock(
+      skipInfo.emplace(&ancestor->layoutObject());
+    if (auto containingBlock = layoutObject.containingBlock(
             skippedAncestor ? &*skipInfo : nullptr)) {
       if (skippedAncestor && skipInfo->ancestorSkipped())
         *skippedAncestor = true;
       return containingBlock->enclosingLayer();
     }
     return nullptr;
   }
 
-  if (layoutObject->isOutOfFlowPositioned()) {
+  if (layoutObject.isOutOfFlowPositioned()) {
     auto canContainThisLayer =
-        layoutObject->isFixedPositioned()
+        layoutObject.isFixedPositioned()
             ? &LayoutObject::canContainFixedPositionObjects
             : &LayoutObject::canContainAbsolutePositionObjects;
 
     PaintLayer* curr = parent();
-    while (curr && !(curr->layoutObject()->*canContainThisLayer)()) {
+    while (curr && !((&curr->layoutObject())->*canContainThisLayer)()) {
       if (skippedAncestor && curr == ancestor)
         *skippedAncestor = true;
       curr = curr->parent();
     }
     return curr;
   }
 
   return parent();
 }
 
 PaintLayer* PaintLayer::enclosingTransformedAncestor() const {
   PaintLayer* curr = parent();
   while (curr && !curr->isRootLayer() && !curr->transform())
     curr = curr->parent();
 
   return curr;
 }
 
 LayoutPoint PaintLayer::computeOffsetFromTransformedAncestor() const {
   TransformState transformState(TransformState::ApplyTransformDirection,
                                 FloatPoint());
-  layoutObject()->mapLocalToAncestor(
-      transformAncestor() ? transformAncestor()->layoutObject() : nullptr,
+  layoutObject().mapLocalToAncestor(
+      transformAncestor() ? &transformAncestor()->layoutObject() : nullptr,
       transformState, 0);
   transformState.flatten();
   return LayoutPoint(transformState.lastPlanarPoint());
 }
 
 PaintLayer* PaintLayer::compositingContainer() const {
   if (!stackingNode()->isStacked())
     return isSelfPaintingLayer() ? parent() : containingLayer();
   if (PaintLayerStackingNode* ancestorStackingNode =
           stackingNode()->ancestorStackingContextNode())
@@ skipping 29 matching lines @@
 
 // Return the enclosingCompositedLayerForPaintInvalidation for the given Layer
 // including crossing frame boundaries.
 PaintLayer*
 PaintLayer::enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const {
   const PaintLayer* layer = this;
   PaintLayer* compositedLayer = 0;
   while (!compositedLayer) {
     compositedLayer = layer->enclosingLayerForPaintInvalidation();
     if (!compositedLayer) {
-      CHECK(layer->layoutObject()->frame());
-      LayoutItem owner = layer->layoutObject()->frame()->ownerLayoutItem();
+      CHECK(layer->layoutObject().frame());
+      LayoutItem owner = layer->layoutObject().frame()->ownerLayoutItem();
       if (owner.isNull())
         break;
       layer = owner.enclosingLayer();
     }
   }
   return compositedLayer;
 }
 
 PaintLayer* PaintLayer::enclosingLayerForPaintInvalidation() const {
   DCHECK(isAllowedToQueryCompositingState());
@@ skipping 44 matching lines @@
 void PaintLayer::didUpdateCompositingInputs() {
   DCHECK(!needsCompositingInputsUpdate());
   m_childNeedsCompositingInputsUpdate = false;
   if (m_scrollableArea)
     m_scrollableArea->updateNeedsCompositedScrolling();
 }
 
 bool PaintLayer::hasNonIsolatedDescendantWithBlendMode() const {
   if (m_hasNonIsolatedDescendantWithBlendMode)
     return true;
-  if (layoutObject()->isSVGRoot())
-    return toLayoutSVGRoot(layoutObject())->hasNonIsolatedBlendingDescendants();
+  if (layoutObject().isSVGRoot())
+    return toLayoutSVGRoot(layoutObject()).hasNonIsolatedBlendingDescendants();
   return false;
 }
 
 void PaintLayer::setCompositingReasons(CompositingReasons reasons,
                                        CompositingReasons mask) {
   CompositingReasons oldReasons =
       m_rareData ? m_rareData->compositingReasons : CompositingReasonNone;
   if ((oldReasons & mask) == (reasons & mask))
     return;
   CompositingReasons newReasons = (reasons & mask) | (oldReasons & ~mask);
@@ skipping 47 matching lines @@
 
 static void expandClipRectForDescendants(
     LayoutRect& clipRect,
     const PaintLayer* layer,
     const PaintLayer* rootLayer,
     PaintLayer::TransparencyClipBoxBehavior transparencyBehavior,
     const LayoutSize& subPixelAccumulation,
     GlobalPaintFlags globalPaintFlags) {
   // If we have a mask, then the clip is limited to the border box area (and
   // there is no need to examine child layers).
-  if (!layer->layoutObject()->hasMask()) {
+  if (!layer->layoutObject().hasMask()) {
     // Note: we don't have to walk z-order lists since transparent elements
     // always establish a stacking container. This means we can just walk the
     // layer tree directly.
     for (PaintLayer* curr = layer->firstChild(); curr;
          curr = curr->nextSibling())
       clipRect.unite(PaintLayer::transparencyClipBox(
           curr, rootLayer, transparencyBehavior,
           PaintLayer::DescendantsOfTransparencyClipBox, subPixelAccumulation,
           globalPaintFlags));
   }
@@ skipping 40 matching lines @@
     expandClipRectForDescendants(clipRect, layer, layer, transparencyBehavior,
                                  subPixelAccumulation, globalPaintFlags);
     LayoutRect result = enclosingLayoutRect(
         transform.mapRect(layer->mapRectForFilter(FloatRect(clipRect))));
     if (!paginationLayer)
       return result;
 
     // We have to break up the transformed extent across our columns.
     // Split our box up into the actual fragment boxes that layout in the
     // columns/pages and unite those together to get our true bounding box.
-    LayoutFlowThread* enclosingFlowThread =
+    LayoutFlowThread& enclosingFlowThread =
         toLayoutFlowThread(paginationLayer->layoutObject());
-    result = enclosingFlowThread->fragmentsBoundingBox(result);
+    result = enclosingFlowThread.fragmentsBoundingBox(result);
 
     LayoutPoint rootLayerDelta;
     paginationLayer->convertToLayerCoords(rootLayer, rootLayerDelta);
     result.moveBy(rootLayerDelta);
     return result;
   }
 
   LayoutRect clipRect = layer->shouldFragmentCompositedBounds(rootLayer)
                             ? layer->fragmentsBoundingBox(rootLayer)
                             : layer->physicalBoundingBox(rootLayer);
@@ skipping 50 matching lines @@
 
   child->m_parent = this;
 
   // The ancestor overflow layer is calculated during compositing inputs update
   // and should not be set yet.
   CHECK(!child->ancestorOverflowLayer());
 
   setNeedsCompositingInputsUpdate();
 
   if (!child->stackingNode()->isStacked() &&
-      !layoutObject()->documentBeingDestroyed())
+      !layoutObject().documentBeingDestroyed())
     compositor()->setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
 
   if (child->stackingNode()->isStacked() || child->firstChild()) {
     // Dirty the z-order list in which we are contained. The
     // ancestorStackingContextNode() can be null in the case where we're
     // building up generated content layers. This is ok, since the lists will
     // start off dirty in that case anyway.
     child->stackingNode()->dirtyStackingContextZOrderLists();
   }
 
@@ skipping 13 matching lines @@
     oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());
   if (oldChild->nextSibling())
     oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());
 
   if (m_first == oldChild)
     m_first = oldChild->nextSibling();
   if (m_last == oldChild)
     m_last = oldChild->previousSibling();
 
   if (!oldChild->stackingNode()->isStacked() &&
-      !layoutObject()->documentBeingDestroyed())
+      !layoutObject().documentBeingDestroyed())
     compositor()->setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
 
   if (oldChild->stackingNode()->isStacked() || oldChild->firstChild()) {
     // Dirty the z-order list in which we are contained.  When called via the
     // reattachment process in removeOnlyThisLayer, the layer may already be
     // disconnected from the main layer tree, so we need to null-check the
     // |stackingContext| value.
     oldChild->stackingNode()->dirtyStackingContextZOrderLists();
   }
 
-  if (layoutObject()->style()->visibility() != EVisibility::kVisible)
+  if (layoutObject().style()->visibility() != EVisibility::kVisible)
     dirtyVisibleContentStatus();
 
   oldChild->setPreviousSibling(0);
   oldChild->setNextSibling(0);
   oldChild->m_parent = 0;
 
   // Remove any ancestor overflow layers which descended into the removed child.
   if (oldChild->ancestorOverflowLayer())
     oldChild->removeAncestorOverflowLayer(oldChild->ancestorOverflowLayer());
 
@@ skipping 16 matching lines @@
 
   bool didSetPaintInvalidation = false;
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     DisableCompositingQueryAsserts
         disabler;  // We need the current compositing status.
     if (isPaintInvalidationContainer()) {
       // Our children will be reparented and contained by a new paint
       // invalidation container, so need paint invalidation. CompositingUpdate
       // can't see this layer (which has been removed) so won't do this for us.
       DisablePaintInvalidationStateAsserts disabler;
-      ObjectPaintInvalidator(*layoutObject())
+      ObjectPaintInvalidator(layoutObject())
           .invalidatePaintIncludingNonCompositingDescendants();
       layoutObject()
-          ->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
+          .setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
       didSetPaintInvalidation = true;
     }
   }
 
   if (!didSetPaintInvalidation && isSelfPaintingLayer()) {
     if (PaintLayer* enclosingSelfPaintingLayer =
             m_parent->enclosingSelfPaintingLayer())
       enclosingSelfPaintingLayer->mergeNeedsPaintPhaseFlagsFrom(*this);
   }
 
   clipper(PaintLayer::DoNotUseGeometryMapper)
       .clearClipRectsIncludingDescendants();
 
   PaintLayer* nextSib = nextSibling();
 
   // Now walk our kids and reattach them to our parent.
   PaintLayer* current = m_first;
   while (current) {
     PaintLayer* next = current->nextSibling();
     removeChild(current);
     m_parent->addChild(current, nextSib);
 
     // FIXME: We should call a specialized version of this function.
     current->updateLayerPositionsAfterLayout();
     current = next;
   }
 
   // Remove us from the parent.
   m_parent->removeChild(this);
-  m_layoutObject->destroyLayer();
+  m_layoutObject.destroyLayer();
 }
 
 void PaintLayer::insertOnlyThisLayerAfterStyleChange() {
-  if (!m_parent && layoutObject()->parent()) {
+  if (!m_parent && layoutObject().parent()) {
     // We need to connect ourselves when our layoutObject() has a parent.
     // Find our enclosingLayer and add ourselves.
-    PaintLayer* parentLayer = layoutObject()->parent()->enclosingLayer();
+    PaintLayer* parentLayer = layoutObject().parent()->enclosingLayer();
     DCHECK(parentLayer);
     PaintLayer* beforeChild =
-        layoutObject()->parent()->findNextLayer(parentLayer, layoutObject());
+        layoutObject().parent()->findNextLayer(parentLayer, &layoutObject());
     parentLayer->addChild(this, beforeChild);
   }
 
   // Remove all descendant layers from the hierarchy and add them to the new
   // position.
-  for (LayoutObject* curr = layoutObject()->slowFirstChild(); curr;
+  for (LayoutObject* curr = layoutObject().slowFirstChild(); curr;
        curr = curr->nextSibling())
     curr->moveLayers(m_parent, this);
 
   // If the previous paint invalidation container is not a stacking context and
   // this object is stacked content, creating this layer may cause this object
   // and its descendants to change paint invalidation container.
   bool didSetPaintInvalidation = false;
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
-      !layoutObject()->isLayoutView() && layoutObject()->isRooted() &&
-      layoutObject()->styleRef().isStacked()) {
+      !layoutObject().isLayoutView() && layoutObject().isRooted() &&
+      layoutObject().styleRef().isStacked()) {
     const LayoutBoxModelObject& previousPaintInvalidationContainer =
-        layoutObject()->parent()->containerForPaintInvalidation();
+        layoutObject().parent()->containerForPaintInvalidation();
     if (!previousPaintInvalidationContainer.styleRef().isStackingContext()) {
-      ObjectPaintInvalidator(*layoutObject())
+      ObjectPaintInvalidator(layoutObject())
           .invalidatePaintIncludingNonSelfPaintingLayerDescendants(
               previousPaintInvalidationContainer);
       // Set needsRepaint along the original compositingContainer chain.
-      layoutObject()->parent()->enclosingLayer()->setNeedsRepaint();
+      layoutObject().parent()->enclosingLayer()->setNeedsRepaint();
       didSetPaintInvalidation = true;
     }
   }
 
   if (!didSetPaintInvalidation && isSelfPaintingLayer() && m_parent) {
     if (PaintLayer* enclosingSelfPaintingLayer =
             m_parent->enclosingSelfPaintingLayer())
       mergeNeedsPaintPhaseFlagsFrom(*enclosingSelfPaintingLayer);
   }
 
   // Clear out all the clip rects.
   clipper(PaintLayer::DoNotUseGeometryMapper)
       .clearClipRectsIncludingDescendants();
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
 static inline const PaintLayer* accumulateOffsetTowardsAncestor(
     const PaintLayer* layer,
     const PaintLayer* ancestorLayer,
     LayoutPoint& location) {
   DCHECK(ancestorLayer != layer);
 
-  const LayoutBoxModelObject* layoutObject = layer->layoutObject();
+  const LayoutBoxModelObject& layoutObject = layer->layoutObject();
 
-  if (layoutObject->isFixedPositioned() &&
-      (!ancestorLayer || ancestorLayer == layoutObject->view()->layer())) {
+  if (layoutObject.isFixedPositioned() &&
+      (!ancestorLayer || ancestorLayer == layoutObject.view()->layer())) {
     // If the fixed layer's container is the root, just add in the offset of the
     // view. We can obtain this by calling localToAbsolute() on the LayoutView.
-    FloatPoint absPos = layoutObject->localToAbsolute();
+    FloatPoint absPos = layoutObject.localToAbsolute();
     location += LayoutSize(absPos.x(), absPos.y());
     return ancestorLayer;
   }
 
   bool foundAncestorFirst;
   PaintLayer* containingLayer =
       layer->containingLayer(ancestorLayer, &foundAncestorFirst);
 
   if (foundAncestorFirst) {
     // Found ancestorLayer before the containing layer, so compute offset of
@@ skipping 39 matching lines @@
   if (ancestorLayer == this)
     return offset;
   PaintLayer* paginationLayer = enclosingPaginationLayer();
   if (paginationLayer == this)
     paginationLayer = parent()->enclosingPaginationLayer();
   if (!paginationLayer) {
     convertToLayerCoords(ancestorLayer, offset);
     return offset;
   }
 
-  LayoutFlowThread* flowThread =
+  LayoutFlowThread& flowThread =
       toLayoutFlowThread(paginationLayer->layoutObject());
   convertToLayerCoords(paginationLayer, offset);
-  offset = flowThread->flowThreadPointToVisualPoint(offset);
+  offset = flowThread.flowThreadPointToVisualPoint(offset);
   if (ancestorLayer == paginationLayer)
     return offset;
 
   if (ancestorLayer->enclosingPaginationLayer() != paginationLayer) {
     offset.moveBy(paginationLayer->visualOffsetFromAncestor(ancestorLayer));
   } else {
     // The ancestor layer is also inside the pagination layer, so we need to
     // subtract the visual distance from the ancestor layer to the pagination
     // layer.
     offset.moveBy(-ancestorLayer->visualOffsetFromAncestor(paginationLayer));
@@ skipping 15 matching lines @@
 
 void PaintLayer::updateScrollableArea() {
   DCHECK(!m_scrollableArea);
   if (requiresScrollableArea())
     m_scrollableArea = PaintLayerScrollableArea::create(*this);
 }
 
 bool PaintLayer::hasOverflowControls() const {
   return m_scrollableArea && (m_scrollableArea->hasScrollbar() ||
                               m_scrollableArea->scrollCorner() ||
-                              layoutObject()->style()->resize() != RESIZE_NONE);
+                              layoutObject().style()->resize() != RESIZE_NONE);
 }
 
 void PaintLayer::appendSingleFragmentIgnoringPagination(
     PaintLayerFragments& fragments,
     const PaintLayer* rootLayer,
     const LayoutRect& dirtyRect,
     ClipRectsCacheSlot clipRectsCacheSlot,
     PaintLayer::GeometryMapperOption geometryMapperOption,
     OverlayScrollbarClipBehavior overlayScrollbarClipBehavior,
     ShouldRespectOverflowClipType respectOverflowClip,
@@ skipping 62 matching lines @@
                       LayoutRect(LayoutRect::infiniteIntRect()),
                       layerBoundsInFlowThread, backgroundRectInFlowThread,
                       foregroundRectInFlowThread, &offsetWithinPaginatedLayer);
 
   // Take our bounding box within the flow thread and clip it.
   LayoutRect layerBoundingBoxInFlowThread =
       layerBoundingBox ? *layerBoundingBox
                        : physicalBoundingBox(offsetWithinPaginatedLayer);
   layerBoundingBoxInFlowThread.intersect(backgroundRectInFlowThread.rect());
 
-  LayoutFlowThread* enclosingFlowThread =
+  LayoutFlowThread& enclosingFlowThread =
       toLayoutFlowThread(enclosingPaginationLayer()->layoutObject());
   // Visual offset from the root layer to the nearest fragmentation context.
   LayoutPoint offsetOfPaginationLayerFromRoot;
   bool rootLayerIsInsidePaginationLayer =
       rootLayer->enclosingPaginationLayer() == enclosingPaginationLayer();
   if (rootLayerIsInsidePaginationLayer) {
     // The root layer is in the same fragmentation context as this layer, so we
     // need to look inside it and subtract the offset between the fragmentation
     // context and the root layer.
     offsetOfPaginationLayerFromRoot =
         -rootLayer->visualOffsetFromAncestor(enclosingPaginationLayer());
   } else {
     offsetOfPaginationLayerFromRoot =
         enclosingPaginationLayer()->visualOffsetFromAncestor(rootLayer);
   }
   // Make the dirty rect relative to the fragmentation context (multicol
   // container, etc.).
   LayoutRect dirtyRectInMulticolContainer(dirtyRect);
-  dirtyRectInMulticolContainer.move(enclosingFlowThread->physicalLocation() -
+  dirtyRectInMulticolContainer.move(enclosingFlowThread.physicalLocation() -
                                     offsetOfPaginationLayerFromRoot);
 
   // Slice the layer into fragments. Each fragment needs to be processed (e.g.
   // painted) separately. We pass enough information to walk a minimal number of
   // fragments based on the pages/columns that intersect the actual dirtyRect as
   // well as the pages/columns that intersect our layer's bounding box.
-  FragmentainerIterator iterator(*enclosingFlowThread,
+  FragmentainerIterator iterator(enclosingFlowThread,
                                  layerBoundingBoxInFlowThread,
                                  dirtyRectInMulticolContainer);
   if (iterator.atEnd())
     return;
 
   // Get the parent clip rects of the pagination layer, since we need to
   // intersect with that when painting column contents.
   ClipRect ancestorClipRect = dirtyRect;
   if (const PaintLayer* paginationParentLayer =
           enclosingPaginationLayer()->parent()) {
@@ skipping 40 matching lines @@
     fragment.intersect(fragment.paginationClip);
 
     // TODO(mstensho): Don't add empty fragments. We've always done that in some
     // cases, but there should be no reason to do so. Either filter them out
     // here, or, even better: pass a better clip rectangle to the fragmentainer
     // iterator, so that we won't end up with empty fragments here.
     fragments.push_back(fragment);
   }
 }
 
-static inline LayoutRect frameVisibleRect(LayoutObject* layoutObject) {
-  FrameView* frameView = layoutObject->document().view();
+static inline LayoutRect frameVisibleRect(LayoutObject& layoutObject) {
+  FrameView* frameView = layoutObject.document().view();
   if (!frameView)
     return LayoutRect();
 
   return LayoutRect(frameView->visibleContentRect());
 }
 
 bool PaintLayer::hitTest(HitTestResult& result) {
   DCHECK(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
 
   // LayoutView should make sure to update layout before entering hit testing
-  DCHECK(!layoutObject()->frame()->view()->layoutPending());
-  DCHECK(!layoutObject()->document().layoutViewItem().needsLayout());
+  DCHECK(!layoutObject().frame()->view()->layoutPending());
+  DCHECK(!layoutObject().document().layoutViewItem().needsLayout());
 
   const HitTestRequest& request = result.hitTestRequest();
   const HitTestLocation& hitTestLocation = result.hitTestLocation();
 
   // Start with frameVisibleRect to ensure we include the scrollbars.
   LayoutRect hitTestArea = frameVisibleRect(layoutObject());
   if (request.ignoreClipping())
-    hitTestArea.unite(LayoutRect(layoutObject()->view()->documentRect()));
+    hitTestArea.unite(LayoutRect(layoutObject().view()->documentRect()));
 
   PaintLayer* insideLayer =
       hitTestLayer(this, 0, result, hitTestArea, hitTestLocation, false);
   if (!insideLayer && isRootLayer()) {
     IntRect hitRect = hitTestLocation.boundingBox();
     bool fallback = false;
     // If we didn't hit any layers but are still inside the document
     // bounds, then we should fallback to hitting the document.
     // For rect-based hit test, we do the fallback only when the hit-rect
     // is totally within the document bounds.
     if (hitTestArea.contains(LayoutRect(hitRect))) {
       fallback = true;
 
       // Mouse dragging outside the main document should also be
       // delivered to the document.
       // TODO(miletus): Capture behavior inconsistent with iframes
       // crbug.com/522109.
       // TODO(majidvp): This should apply more consistently across different
       // event types and we should not use RequestType for it. Perhaps best for
       // it to be done at a higher level. See http://crbug.com/505825
     } else if ((request.active() || request.release()) &&
                !request.isChildFrameHitTest()) {
       fallback = true;
     }
     if (fallback) {
-      layoutObject()->updateHitTestResult(
+      layoutObject().updateHitTestResult(
           result, toLayoutView(layoutObject())
-                      ->flipForWritingMode(hitTestLocation.point()));
+                      .flipForWritingMode(hitTestLocation.point()));
       insideLayer = this;
 
       // Don't cache this result since it really wasn't a true hit.
       result.setCacheable(false);
     }
   }
 
   // Now determine if the result is inside an anchor - if the urlElement isn't
   // already set.
   Node* node = result.innerNode();
   if (node && !result.URLElement())
     result.setURLElement(node->enclosingLinkEventParentOrSelf());
 
   // Now return whether we were inside this layer (this will always be true for
   // the root layer).
   return insideLayer;
 }
 
 Node* PaintLayer::enclosingNode() const {
-  for (LayoutObject* r = layoutObject(); r; r = r->parent()) {
+  for (LayoutObject* r = &layoutObject(); r; r = r->parent()) {
     if (Node* e = r->node())
       return e;
   }
   ASSERT_NOT_REACHED();
   return 0;
 }
 
 bool PaintLayer::isInTopLayer() const {
-  Node* node = layoutObject()->node();
+  Node* node = layoutObject().node();
   return node && node->isElementNode() && toElement(node)->isInTopLayer();
 }
 
 // Compute the z-offset of the point in the transformState.
 // This is effectively projecting a ray normal to the plane of ancestor, finding
 // where that ray intersects target, and computing the z delta between those two
 // points.
 static double computeZOffset(const HitTestingTransformState& transformState) {
   // We got an affine transform, so no z-offset
   if (transformState.m_accumulatedTransform.isAffine())
@@ skipping 26 matching lines @@
     // If this is the first time we need to make transform state, then base it
     // off of hitTestLocation, which is relative to rootLayer.
     transformState = HitTestingTransformState::create(
         hitTestLocation.transformedPoint(), hitTestLocation.transformedRect(),
         FloatQuad(FloatRect(hitTestRect)));
     convertToLayerCoords(rootLayer, offset);
   }
   offset.moveBy(translationOffset);
 
   LayoutObject* containerLayoutObject =
-      containerLayer ? containerLayer->layoutObject() : 0;
-  if (layoutObject()->shouldUseTransformFromContainer(containerLayoutObject)) {
+      containerLayer ? &containerLayer->layoutObject() : 0;
+  if (layoutObject().shouldUseTransformFromContainer(containerLayoutObject)) {
     TransformationMatrix containerTransform;
-    layoutObject()->getTransformFromContainer(
+    layoutObject().getTransformFromContainer(
         containerLayoutObject, toLayoutSize(offset), containerTransform);
     transformState->applyTransform(
         containerTransform, HitTestingTransformState::AccumulateTransform);
   } else {
     transformState->translate(offset.x().toInt(), offset.y().toInt(),
                               HitTestingTransformState::AccumulateTransform);
   }
 
   return transformState;
 }
@@ skipping 40 matching lines @@
 // the containing flattening layer.
 PaintLayer* PaintLayer::hitTestLayer(
     PaintLayer* rootLayer,
     PaintLayer* containerLayer,
     HitTestResult& result,
     const LayoutRect& hitTestRect,
     const HitTestLocation& hitTestLocation,
     bool appliedTransform,
     const HitTestingTransformState* transformState,
     double* zOffset) {
-  DCHECK(layoutObject()->document().lifecycle().state() >=
+  DCHECK(layoutObject().document().lifecycle().state() >=
          DocumentLifecycle::CompositingClean);
 
   if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
     return nullptr;
 
   ClipRectsCacheSlot clipRectsCacheSlot =
       result.hitTestRequest().ignoreClipping()
           ? RootRelativeClipRectsIgnoringViewportClip
           : RootRelativeClipRects;
 
@@ skipping 34 matching lines @@
   } else if (transformState || m_has3DTransformedDescendant || preserves3D()) {
     // We need transform state for the first time, or to offset the container
     // state, so create it here.
     localTransformState =
         createLocalTransformState(rootLayer, containerLayer, hitTestRect,
                                   hitTestLocation, transformState);
   }
 
   // Check for hit test on backface if backface-visibility is 'hidden'
   if (localTransformState &&
-      layoutObject()->style()->backfaceVisibility() ==
+      layoutObject().style()->backfaceVisibility() ==
           BackfaceVisibilityHidden) {
     TransformationMatrix invertedMatrix =
         localTransformState->m_accumulatedTransform.inverse();
     // If the z-vector of the matrix is negative, the back is facing towards the
     // viewer.
     if (invertedMatrix.m33() < 0)
       return nullptr;
   }
 
   RefPtr<HitTestingTransformState> unflattenedTransformState =
@@ skipping 61 matching lines @@
         PaintLayer::DoNotUseGeometryMapper,
         ExcludeOverlayScrollbarSizeForHitTesting);
   else
     collectFragments(layerFragments, rootLayer, hitTestRect, clipRectsCacheSlot,
                      PaintLayer::DoNotUseGeometryMapper,
                      ExcludeOverlayScrollbarSizeForHitTesting);
 
   if (m_scrollableArea &&
       m_scrollableArea->hitTestResizerInFragments(layerFragments,
                                                   hitTestLocation)) {
-    layoutObject()->updateHitTestResult(result, hitTestLocation.point());
+    layoutObject().updateHitTestResult(result, hitTestLocation.point());
     return this;
   }
 
   // Next we want to see if the mouse pos is inside the child LayoutObjects of
   // the layer. Check every fragment in reverse order.
   if (isSelfPaintingLayer()) {
     // Hit test with a temporary HitTestResult, because we only want to commit
     // to 'result' if we know we're frontmost.
     HitTestResult tempResult(result.hitTestRequest(), result.hitTestLocation());
     bool insideFragmentForegroundRect = false;
@@ skipping 175 matching lines @@
                       newHitTestLocation, true, newTransformState.get(),
                       zOffset);
 }
 
 bool PaintLayer::hitTestContents(HitTestResult& result,
                                  const LayoutRect& layerBounds,
                                  const HitTestLocation& hitTestLocation,
                                  HitTestFilter hitTestFilter) const {
   DCHECK(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
 
-  if (!layoutObject()->hitTest(
+  if (!layoutObject().hitTest(
           result, hitTestLocation,
           toLayoutPoint(layerBounds.location() - layoutBoxLocation()),
           hitTestFilter)) {
     // It's wrong to set innerNode, but then claim that you didn't hit anything,
     // unless it is a rect-based test.
     DCHECK(!result.innerNode() || (result.hitTestRequest().listBased() &&
                                    result.listBasedTestResult().size()));
     return false;
   }
 
   if (!result.innerNode()) {
     // We hit something anonymous, and we didn't find a DOM node ancestor in
     // this layer.
 
-    if (layoutObject()->isLayoutFlowThread()) {
+    if (layoutObject().isLayoutFlowThread()) {
       // For a flow thread it's safe to just say that we didn't hit anything.
       // That means that we'll continue as normally, and eventually hit a column
       // set sibling instead. Column sets are also anonymous, but, unlike flow
       // threads, they don't establish layers, so we'll fall back and hit the
       // multicol container parent (which should have a DOM node).
       return false;
     }
 
     Node* e = enclosingNode();
     // FIXME: should be a call to result.setNodeAndPosition. What we would
@@ skipping 52 matching lines @@
   return resultLayer;
 }
 
 FloatRect PaintLayer::boxForFilterOrMask() const {
   return FloatRect(physicalBoundingBoxIncludingStackingChildren(
       LayoutPoint(), PaintLayer::CalculateBoundsOptions::
                          IncludeTransformsAndCompositedChildLayers));
 }
 
 LayoutRect PaintLayer::boxForClipPath() const {
-  if (!layoutObject()->isBox()) {
-    SECURITY_DCHECK(layoutObject()->isLayoutInline());
-    const LayoutInline& layoutInline = toLayoutInline(*layoutObject());
+  if (!layoutObject().isBox()) {
+    SECURITY_DCHECK(layoutObject().isLayoutInline());
+    const LayoutInline& layoutInline = toLayoutInline(layoutObject());
     // This somewhat convoluted computation matches what Gecko does.
     // See crbug.com/641907.
     LayoutRect inlineBBox = layoutInline.linesBoundingBox();
     const InlineFlowBox* flowBox = layoutInline.firstLineBox();
     inlineBBox.setHeight(flowBox ? flowBox->frameRect().height()
                                  : LayoutUnit(0));
     return inlineBBox;
   }
-  return toLayoutBox(layoutObject())->borderBoxRect();
+  return toLayoutBox(layoutObject()).borderBoxRect();
 }
 
 bool PaintLayer::hitTestClippedOutByClipPath(
     PaintLayer* rootLayer,
     const HitTestLocation& hitTestLocation) const {
-  if (!layoutObject()->hasClipPath())
+  if (!layoutObject().hasClipPath())
     return false;
   DCHECK(isSelfPaintingLayer());
   DCHECK(rootLayer);
 
   LayoutRect referenceBox(boxForClipPath());
   if (enclosingPaginationLayer())
     convertFromFlowThreadToVisualBoundingBoxInAncestor(rootLayer, referenceBox);
   else
     convertToLayerCoords(rootLayer, referenceBox);
 
   FloatPoint point(hitTestLocation.point());
 
-  ClipPathOperation* clipPathOperation = layoutObject()->style()->clipPath();
+  ClipPathOperation* clipPathOperation = layoutObject().style()->clipPath();
   DCHECK(clipPathOperation);
   if (clipPathOperation->type() == ClipPathOperation::SHAPE) {
     ShapeClipPathOperation* clipPath =
         toShapeClipPathOperation(clipPathOperation);
     return !clipPath->path(FloatRect(referenceBox)).contains(point);
   }
   DCHECK_EQ(clipPathOperation->type(), ClipPathOperation::REFERENCE);
-  Node* targetNode = layoutObject()->node();
+  Node* targetNode = layoutObject().node();
   if (!targetNode)
     return false;
   const ReferenceClipPathOperation& referenceClipPathOperation =
       toReferenceClipPathOperation(*clipPathOperation);
   SVGElement* element =
       referenceClipPathOperation.findElement(targetNode->treeScope());
   if (!isSVGClipPathElement(element) || !element->layoutObject())
     return false;
   LayoutSVGResourceClipper* clipper = toLayoutSVGResourceClipper(
       toLayoutSVGResourceContainer(element->layoutObject()));
   // If the clipPath is using "userspace on use" units, then the origin of
   // the coordinate system is the top-left of the reference box, so adjust
   // the point accordingly.
   if (clipper->clipPathUnits() == SVGUnitTypes::kSvgUnitTypeUserspaceonuse)
     point.moveBy(-referenceBox.location());
   return !clipper->hitTestClipContent(FloatRect(referenceBox), point);
 }
 
 bool PaintLayer::intersectsDamageRect(const LayoutRect& layerBounds,
                                       const LayoutRect& damageRect,
                                       const LayoutPoint& offsetFromRoot) const {
   // Always examine the canvas and the root.
   // FIXME: Could eliminate the isDocumentElement() check if we fix background
   // painting so that the LayoutView paints the root's background.
-  if (isRootLayer() || layoutObject()->isDocumentElement())
+  if (isRootLayer() || layoutObject().isDocumentElement())
     return true;
 
   // If we aren't an inline flow, and our layer bounds do intersect the damage
   // rect, then we can go ahead and return true.
-  LayoutView* view = layoutObject()->view();
+  LayoutView* view = layoutObject().view();
   DCHECK(view);
-  if (view && !layoutObject()->isLayoutInline()) {
+  if (view && !layoutObject().isLayoutInline()) {
     if (layerBounds.intersects(damageRect))
       return true;
   }
 
   // Otherwise we need to compute the bounding box of this single layer and see
   // if it intersects the damage rect.
   return physicalBoundingBox(offsetFromRoot).intersects(damageRect);
 }
 
 LayoutRect PaintLayer::logicalBoundingBox() const {
-  LayoutRect rect = layoutObject()->visualOverflowRect();
+  LayoutRect rect = layoutObject().visualOverflowRect();
 
   if (isRootLayer()) {
     rect.unite(
-        LayoutRect(rect.location(), layoutObject()->view()->viewRect().size()));
+        LayoutRect(rect.location(), layoutObject().view()->viewRect().size()));
   }
 
   return rect;
 }
 
 static inline LayoutRect flippedLogicalBoundingBox(LayoutRect boundingBox,
-                                                   LayoutObject* layoutObject) {
+                                                   LayoutObject& layoutObject) {
   LayoutRect result = boundingBox;
-  if (layoutObject->isBox())
-    toLayoutBox(layoutObject)->flipForWritingMode(result);
+  if (layoutObject.isBox())
+    toLayoutBox(layoutObject).flipForWritingMode(result);
   else
-    layoutObject->containingBlock()->flipForWritingMode(result);
+    layoutObject.containingBlock()->flipForWritingMode(result);
   return result;
 }
 
 LayoutRect PaintLayer::physicalBoundingBox(
     const PaintLayer* ancestorLayer) const {
   LayoutPoint offsetFromRoot;
   convertToLayerCoords(ancestorLayer, offsetFromRoot);
   return physicalBoundingBox(offsetFromRoot);
 }
 
@@ skipping 88 matching lines @@
 
   // FIXME: This could be improved to do a check like
   // hasVisibleNonCompositingDescendantLayers() (bug 92580).
   if (this != &compositedLayer && !hasVisibleContent() &&
       !hasVisibleDescendant())
     return LayoutRect();
 
   // The root layer is the size of the document, plus any additional area due
   // to layout viewport being different than initial containing block.
   if (isRootLayer()) {
-    IntRect documentRect = layoutObject()->view()->documentRect();
+    IntRect documentRect = layoutObject().view()->documentRect();
 
-    if (FrameView* frameView = layoutObject()->document().view()) {
+    if (FrameView* frameView = layoutObject().document().view()) {
       documentRect.unite(IntRect(IntPoint(), frameView->visibleContentSize()));
     }
 
     return LayoutRect(documentRect);
   }
 
   // The layer created for the LayoutFlowThread is just a helper for painting
   // and hit-testing, and should not contribute to the bounding box. The
   // LayoutMultiColumnSets will contribute the correct size for the layout
   // content of the multicol container.
-  if (layoutObject()->isLayoutFlowThread())
+  if (layoutObject().isLayoutFlowThread())
     return LayoutRect();
 
   const_cast<PaintLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
   // If there is a clip applied by an ancestor to this PaintLayer but below or
   // equal to |ancestorLayer|, apply that clip.
   LayoutRect result = clipper(PaintLayer::DoNotUseGeometryMapper)
                           .localClipRect(compositedLayer);
 
   result.intersect(physicalBoundingBox(LayoutPoint()));
@@ skipping 39 matching lines @@
   if (!compositedLayerMapping())
     return NotComposited;
 
   return PaintsIntoOwnBacking;
 }
 
 bool PaintLayer::isAllowedToQueryCompositingState() const {
   if (gCompositingQueryMode == CompositingQueriesAreAllowed ||
       RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return true;
-  return layoutObject()->document().lifecycle().state() >=
+  return layoutObject().document().lifecycle().state() >=
          DocumentLifecycle::InCompositingUpdate;
 }
 
 CompositedLayerMapping* PaintLayer::compositedLayerMapping() const {
   DCHECK(isAllowedToQueryCompositingState());
   return m_rareData ? m_rareData->compositedLayerMapping.get() : nullptr;
 }
 
 GraphicsLayer* PaintLayer::graphicsLayerBacking(const LayoutObject* obj) const {
   switch (compositingState()) {
     case NotComposited:
       return nullptr;
     case PaintsIntoGroupedBacking:
       return groupedMapping()->squashingLayer();
     default:
-      return (obj != layoutObject() &&
+      return (obj != &layoutObject() &&
               compositedLayerMapping()->scrollingContentsLayer())
                  ? compositedLayerMapping()->scrollingContentsLayer()
                  : compositedLayerMapping()->mainGraphicsLayer();
   }
 }
 
 BackgroundPaintLocation PaintLayer::backgroundPaintLocation(
     uint32_t* reasons) const {
   BackgroundPaintLocation location;
   if (!scrollsOverflow()) {
     location = BackgroundPaintInGraphicsLayer;
   } else if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
-    location = layoutObject()->backgroundPaintLocation(reasons);
+    location = layoutObject().backgroundPaintLocation(reasons);
   } else {
     location = isRootLayer() ? BackgroundPaintInGraphicsLayer
-                             : layoutObject()->backgroundPaintLocation(reasons);
+                             : layoutObject().backgroundPaintLocation(reasons);
   }
   m_stackingNode->updateLayerListsIfNeeded();
   if (m_stackingNode->hasNegativeZOrderList())
     location = BackgroundPaintInGraphicsLayer;
   return location;
 }
 
 void PaintLayer::ensureCompositedLayerMapping() {
   if (m_rareData && m_rareData->compositedLayerMapping)
     return;
@@ skipping 42 matching lines @@
   if (m_rareData || groupedMapping)
     ensureRareData().groupedMapping = groupedMapping;
 #if DCHECK_IS_ON()
   DCHECK(!groupedMapping || groupedMapping->verifyLayerInSquashingVector(this));
 #endif
   if (options == InvalidateLayerAndRemoveFromMapping && groupedMapping)
     groupedMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
 }
 
 bool PaintLayer::maskBlendingAppliedByCompositor() const {
-  DCHECK(m_layoutObject->hasMask());
+  DCHECK(m_layoutObject.hasMask());
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return true;
   return m_rareData && m_rareData->compositedLayerMapping &&
          m_rareData->compositedLayerMapping->hasMaskLayer();
 }
 
 bool PaintLayer::hasCompositedClippingMask() const {
   return m_rareData && m_rareData->compositedLayerMapping &&
          m_rareData->compositedLayerMapping->hasChildClippingMaskLayer();
 }
 
 bool PaintLayer::paintsWithTransform(GlobalPaintFlags globalPaintFlags) const {
   if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()) {
     return transform() &&
            ((globalPaintFlags & GlobalPaintFlattenCompositingLayers) ||
             compositingState() != PaintsIntoOwnBacking);
   }
 
   return (transform() ||
-          layoutObject()->style()->position() == EPosition::kFixed) &&
+          layoutObject().style()->position() == EPosition::kFixed) &&
          ((globalPaintFlags & GlobalPaintFlattenCompositingLayers) ||
           compositingState() != PaintsIntoOwnBacking);
 }
 
 bool PaintLayer::compositesWithTransform() const {
   return transformAncestor() || transform();
 }
 
 bool PaintLayer::compositesWithOpacity() const {
-  return opacityAncestor() || layoutObject()->style()->hasOpacity();
+  return opacityAncestor() || layoutObject().style()->hasOpacity();
 }
 
 bool PaintLayer::backgroundIsKnownToBeOpaqueInRect(
     const LayoutRect& localRect) const {
   if (paintsWithTransparency(GlobalPaintNormalPhase))
     return false;
 
   // We can't use hasVisibleContent(), because that will be true if our
   // layoutObject is hidden, but some child is visible and that child doesn't
   // cover the entire rect.
-  if (layoutObject()->style()->visibility() != EVisibility::kVisible)
+  if (layoutObject().style()->visibility() != EVisibility::kVisible)
     return false;
 
   if (paintsWithFilters() &&
-      layoutObject()->style()->filter().hasFilterThatAffectsOpacity())
+      layoutObject().style()->filter().hasFilterThatAffectsOpacity())
     return false;
 
   // FIXME: Handle simple transforms.
   if (transform() && compositingState() != PaintsIntoOwnBacking)
     return false;
 
   if (!RuntimeEnabledFeatures::compositeOpaqueFixedPositionEnabled() &&
-      layoutObject()->style()->position() == EPosition::kFixed &&
+      layoutObject().style()->position() == EPosition::kFixed &&
       compositingState() != PaintsIntoOwnBacking)
     return false;
 
   // This function should not be called when layer-lists are dirty.
   // TODO(schenney) This check never hits in layout tests or most platforms, but
   // does hit in PopupBlockerBrowserTest.AllowPopupThroughContentSetting on
   // Win 7 Test Builder.
   if (m_stackingNode->zOrderListsDirty())
     return false;
 
   // FIXME: We currently only check the immediate layoutObject,
   // which will miss many cases where additional layout objects paint
   // into this layer.
-  if (layoutObject()->backgroundIsKnownToBeOpaqueInRect(localRect))
+  if (layoutObject().backgroundIsKnownToBeOpaqueInRect(localRect))
     return true;
 
   // We can't consult child layers if we clip, since they might cover
   // parts of the rect that are clipped out.
-  if (layoutObject()->hasClipRelatedProperty())
+  if (layoutObject().hasClipRelatedProperty())
     return false;
 
   // TODO(schenney): This could be improved by unioning the opaque regions of
   // all the children.  That would require a refactoring because currently
   // children just check they at least cover the given rect, but a unioning
   // method would require children to compute and report their rects.
   return childBackgroundIsKnownToBeOpaqueInRect(localRect);
 }
 
 bool PaintLayer::childBackgroundIsKnownToBeOpaqueInRect(
@@ skipping 15 matching lines @@
     childLayer->convertToLayerCoords(this, childOffset);
     childLocalRect.moveBy(-childOffset);
 
     if (childLayer->backgroundIsKnownToBeOpaqueInRect(childLocalRect))
       return true;
   }
   return false;
 }
 
 bool PaintLayer::shouldBeSelfPaintingLayer() const {
-  if (layoutObject()->isLayoutPart() &&
-      toLayoutPart(layoutObject())->requiresAcceleratedCompositing())
+  if (layoutObject().isLayoutPart() &&
+      toLayoutPart(layoutObject()).requiresAcceleratedCompositing())
     return true;
 
-  return layoutObject()->layerTypeRequired() == NormalPaintLayer ||
+  return layoutObject().layerTypeRequired() == NormalPaintLayer ||
          (m_scrollableArea && m_scrollableArea->hasOverlayScrollbars()) ||
          needsCompositedScrolling();
 }
 
 void PaintLayer::updateSelfPaintingLayer() {
   bool isSelfPaintingLayer = shouldBeSelfPaintingLayer();
   if (this->isSelfPaintingLayer() == isSelfPaintingLayer)
     return;
 
   m_isSelfPaintingLayer = isSelfPaintingLayer;
@@ skipping 18 matching lines @@
     layer = layer->parent();
   return layer;
 }
 
 bool PaintLayer::hasNonEmptyChildLayoutObjects() const {
   // Some HTML can cause whitespace text nodes to have layoutObjects, like:
   // <div>
   // <img src=...>
   // </div>
   // so test for 0x0 LayoutTexts here
-  for (LayoutObject* child = layoutObject()->slowFirstChild(); child;
+  for (LayoutObject* child = layoutObject().slowFirstChild(); child;
        child = child->nextSibling()) {
     if (!child->hasLayer()) {
       if (child->isLayoutInline() || !child->isBox())
         return true;
 
       if (toLayoutBox(child)->size().width() > 0 ||
           toLayoutBox(child)->size().height() > 0)
         return true;
     }
   }
   return false;
 }
 
 bool PaintLayer::hasBoxDecorationsOrBackground() const {
-  return layoutObject()->style()->hasBoxDecorations() ||
-         layoutObject()->style()->hasBackground();
+  return layoutObject().style()->hasBoxDecorations() ||
+         layoutObject().style()->hasBackground();
 }
 
 bool PaintLayer::hasVisibleBoxDecorations() const {
   if (!hasVisibleContent())
     return false;
 
   return hasBoxDecorationsOrBackground() || hasOverflowControls();
 }
 
 void PaintLayer::updateFilters(const ComputedStyle* oldStyle,
@@ skipping 60 matching lines @@
   // the overlap map.
   if (diff.transformChanged() &&
       (!m_rareData ||
        !(m_rareData->compositingReasons & CompositingReasonInlineTransform)))
     return false;
 
   // We composite transparent Layers differently from non-transparent
   // Layers even when the non-transparent Layers are already a
   // stacking context.
   if (diff.opacityChanged() &&
-      m_layoutObject->style()->hasOpacity() != oldStyle->hasOpacity())
+      m_layoutObject.style()->hasOpacity() != oldStyle->hasOpacity())
     return false;
 
   // Changes in pointer-events affect hit test visibility of the scrollable
   // area and its |m_scrollsOverflow| value which determines if the layer
   // requires composited scrolling or not.
   if (m_scrollableArea &&
-      m_layoutObject->style()->pointerEvents() != oldStyle->pointerEvents())
+      m_layoutObject.style()->pointerEvents() != oldStyle->pointerEvents())
     return false;
 
-  updateTransform(oldStyle, layoutObject()->styleRef());
+  updateTransform(oldStyle, layoutObject().styleRef());
 
   // FIXME: Consider introducing a smaller graphics layer update scope
   // that just handles transforms and opacity. GraphicsLayerUpdateLocal
   // will also program bounds, clips, and many other properties that could
   // not possibly have changed.
   m_rareData->compositedLayerMapping->setNeedsGraphicsLayerUpdate(
       GraphicsLayerUpdateLocal);
   compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterGeometryChange);
 
   if (m_scrollableArea)
     m_scrollableArea->updateAfterStyleChange(oldStyle);
 
   return true;
 }
 
 void PaintLayer::styleDidChange(StyleDifference diff,
                                 const ComputedStyle* oldStyle) {
   if (attemptDirectCompositingUpdate(diff, oldStyle))
     return;
 
   m_stackingNode->styleDidChange(oldStyle);
 
   if (m_scrollableArea)
     m_scrollableArea->updateAfterStyleChange(oldStyle);
 
   // Overlay scrollbars can make this layer self-painting so we need
   // to recompute the bit once scrollbars have been updated.
   updateSelfPaintingLayer();
 
-  updateTransform(oldStyle, layoutObject()->styleRef());
-  updateFilters(oldStyle, layoutObject()->styleRef());
-  updateClipPath(oldStyle, layoutObject()->styleRef());
+  updateTransform(oldStyle, layoutObject().styleRef());
+  updateFilters(oldStyle, layoutObject().styleRef());
+  updateClipPath(oldStyle, layoutObject().styleRef());
 
   setNeedsCompositingInputsUpdate();
-  layoutObject()->setNeedsPaintPropertyUpdate();
+  layoutObject().setNeedsPaintPropertyUpdate();
 }
 
 PaintLayerClipper PaintLayer::clipper(
     GeometryMapperOption geometryMapperOption) const {
   GeometryMapper* geometryMapper = nullptr;
   if (geometryMapperOption == UseGeometryMapper) {
     DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
-    if (FrameView* frameView = m_layoutObject->document().view())
+    if (FrameView* frameView = m_layoutObject.document().view())
       geometryMapper = &frameView->geometryMapper();
   }
   return PaintLayerClipper(*this, geometryMapper);
 }
 
 bool PaintLayer::scrollsOverflow() const {
   if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea())
     return scrollableArea->scrollsOverflow();
 
   return false;
 }
 
 FilterOperations PaintLayer::addReflectionToFilterOperations(
     const ComputedStyle& style) const {
   FilterOperations filterOperations = style.filter();
-  if (layoutObject()->hasReflection() && layoutObject()->isBox()) {
+  if (layoutObject().hasReflection() && layoutObject().isBox()) {
     BoxReflection reflection = boxReflectionForPaintLayer(*this, style);
     filterOperations.operations().push_back(
         BoxReflectFilterOperation::create(reflection));
   }
   return filterOperations;
 }
 
 CompositorFilterOperations
 PaintLayer::createCompositorFilterOperationsForFilter(
     const ComputedStyle& style) {
@@ skipping 48 matching lines @@
 FilterEffect* PaintLayer::lastFilterEffect() const {
   // TODO(chrishtr): ensure (and assert) that compositing is clean here.
   if (!paintsWithFilters())
     return nullptr;
   PaintLayerResourceInfo* resourceInfo = this->resourceInfo();
   DCHECK(resourceInfo);
 
   if (resourceInfo->lastEffect())
     return resourceInfo->lastEffect();
 
-  const ComputedStyle& style = layoutObject()->styleRef();
+  const ComputedStyle& style = layoutObject().styleRef();
   FloatRect zoomedReferenceBox;
   if (style.filter().hasReferenceFilter())
     zoomedReferenceBox = boxForFilterOrMask();
   FilterEffectBuilder builder(enclosingNode(), zoomedReferenceBox,
                               style.effectiveZoom());
   resourceInfo->setLastEffect(
       builder.buildFilterEffect(addReflectionToFilterOperations(style)));
   return resourceInfo->lastEffect();
 }
 
 FloatRect PaintLayer::mapRectForFilter(const FloatRect& rect) const {
   if (!hasFilterThatMovesPixels())
     return rect;
 
   // Ensure the filter-chain is refreshed wrt reference filters.
   // TODO(fs): Avoid having this side-effect inducing call.
   lastFilterEffect();
 
   FilterOperations filterOperations =
-      addReflectionToFilterOperations(layoutObject()->styleRef());
+      addReflectionToFilterOperations(layoutObject().styleRef());
   return filterOperations.mapRect(rect);
 }
 
 LayoutRect PaintLayer::mapLayoutRectForFilter(const LayoutRect& rect) const {
   if (!hasFilterThatMovesPixels())
     return rect;
   return enclosingLayoutRect(mapRectForFilter(FloatRect(rect)));
 }
 
 bool PaintLayer::hasFilterThatMovesPixels() const {
   if (!hasFilterInducingProperty())
     return false;
-  const ComputedStyle& style = layoutObject()->styleRef();
+  const ComputedStyle& style = layoutObject().styleRef();
   if (style.hasFilter() && style.filter().hasFilterThatMovesPixels())
     return true;
   if (style.hasBoxReflect())
     return true;
   return false;
 }
 
 void PaintLayer::addLayerHitTestRects(LayerHitTestRects& rects) const {
   computeSelfHitTestRects(rects);
   for (PaintLayer* child = firstChild(); child; child = child->nextSibling())
@@ skipping 56 matching lines @@
     if (CompositedLayerMapping* groupedMapping = layer->groupedMapping()) {
       // TODO(wkorman): As we clean up the CompositedLayerMapping needsRepaint
       // logic to delegate to scrollbars, we may be able to remove the line
       // below as well.
       groupedMapping->owningLayer().setNeedsRepaint();
       return;
     }
 
     PaintLayer* container = layer->compositingContainer();
     if (!container) {
-      LayoutItem owner = layer->layoutObject()->frame()->ownerLayoutItem();
+      LayoutItem owner = layer->layoutObject().frame()->ownerLayoutItem();
       if (owner.isNull())
         break;
       container = owner.enclosingLayer();
     }
 
     if (container->m_needsRepaint)
       break;
 
     container->setNeedsRepaintInternal();
     layer = container;
@@ skipping 21 matching lines @@
 
 #ifndef NDEBUG
 // FIXME: Rename?
 void showLayerTree(const blink::PaintLayer* layer) {
   blink::DisableCompositingQueryAsserts disabler;
   if (!layer) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
 
-  if (blink::LocalFrame* frame = layer->layoutObject()->frame()) {
+  if (blink::LocalFrame* frame = layer->layoutObject().frame()) {
     WTF::String output = externalRepresentation(
         frame,
         blink::LayoutAsTextShowAllLayers | blink::LayoutAsTextShowLayerNesting |
             blink::LayoutAsTextShowCompositedLayers |
             blink::LayoutAsTextShowAddresses |
             blink::LayoutAsTextShowIDAndClass |
             blink::LayoutAsTextDontUpdateLayout |
             blink::LayoutAsTextShowLayoutState,
         layer);
     LOG(INFO) << output.utf8().data();
   }
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif