Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/page/scrolling/ScrollingCoordinator.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 266 matching lines @@
 static void clearPositionConstraintExceptForLayer(GraphicsLayer* layer,
                                                   GraphicsLayer* except) {
   if (layer && layer != except && toWebLayer(layer))
     toWebLayer(layer)->setPositionConstraint(WebLayerPositionConstraint());
 }
 
 static WebLayerPositionConstraint computePositionConstraint(
     const PaintLayer* layer) {
   DCHECK(layer->hasCompositedLayerMapping());
   do {
-    if (layer->layoutObject()->style()->position() == EPosition::kFixed) {
-      const LayoutObject* fixedPositionObject = layer->layoutObject();
-      bool fixedToRight = !fixedPositionObject->style()->right().isAuto();
-      bool fixedToBottom = !fixedPositionObject->style()->bottom().isAuto();
+    if (layer->layoutObject().style()->position() == EPosition::kFixed) {
+      const LayoutObject& fixedPositionObject = layer->layoutObject();
+      bool fixedToRight = !fixedPositionObject.style()->right().isAuto();
+      bool fixedToBottom = !fixedPositionObject.style()->bottom().isAuto();
       return WebLayerPositionConstraint::fixedPosition(fixedToRight,
                                                        fixedToBottom);
     }
 
     layer = layer->parent();
 
     // Composited layers that inherit a fixed position state will be positioned
     // with respect to the nearest compositedLayerMapping's GraphicsLayer.
     // So, once we find a layer that has its own compositedLayerMapping, we can
     // stop searching for a fixed position LayoutObject.
@@ skipping 265 matching lines @@
 }
 
 static void projectRectsToGraphicsLayerSpaceRecursive(
     const PaintLayer* curLayer,
     const LayerHitTestRects& layerRects,
     GraphicsLayerHitTestRects& graphicsRects,
     LayoutGeometryMap& geometryMap,
     HashSet<const PaintLayer*>& layersWithRects,
     LayerFrameMap& layerChildFrameMap) {
   // If this layer is throttled, ignore it.
-  if (curLayer->layoutObject()->frameView() &&
-      curLayer->layoutObject()->frameView()->shouldThrottleRendering())
+  if (curLayer->layoutObject().frameView() &&
+      curLayer->layoutObject().frameView()->shouldThrottleRendering())
     return;
   // Project any rects for the current layer
   LayerHitTestRects::const_iterator layerIter = layerRects.find(curLayer);
   if (layerIter != layerRects.end()) {
     // Find the enclosing composited layer when it's in another document (for
     // non-composited iframes).
     const PaintLayer* compositedLayer =
         layerIter->key
             ->enclosingLayerForPaintInvalidationCrossingFrameBoundaries();
     DCHECK(compositedLayer);
 
     // Find the appropriate GraphicsLayer for the composited Layer.
     GraphicsLayer* graphicsLayer =
-        compositedLayer->graphicsLayerBacking(curLayer->layoutObject());
+        compositedLayer->graphicsLayerBacking(&curLayer->layoutObject());
 
     GraphicsLayerHitTestRects::iterator glIter =
         graphicsRects.find(graphicsLayer);
     Vector<LayoutRect>* glRects;
     if (glIter == graphicsRects.end())
       glRects = &graphicsRects.insert(graphicsLayer, Vector<LayoutRect>())
                      .storedValue->value;
     else
       glRects = &glIter->value;
 
     // Transform each rect to the co-ordinate space of the graphicsLayer.
     for (size_t i = 0; i < layerIter->value.size(); ++i) {
       LayoutRect rect = layerIter->value[i];
       if (compositedLayer != curLayer) {
         FloatQuad compositorQuad = geometryMap.mapToAncestor(
-            FloatRect(rect), compositedLayer->layoutObject());
+            FloatRect(rect), &compositedLayer->layoutObject());
         rect = LayoutRect(compositorQuad.boundingBox());
         // If the enclosing composited layer itself is scrolled, we have to undo
         // the subtraction of its scroll offset since we want the offset
         // relative to the scrolling content, not the element itself.
-        if (compositedLayer->layoutObject()->hasOverflowClip())
+        if (compositedLayer->layoutObject().hasOverflowClip())
           rect.move(compositedLayer->layoutBox()->scrolledContentOffset());
       }
       PaintLayer::mapRectInPaintInvalidationContainerToBacking(
-          *compositedLayer->layoutObject(), rect);
+          compositedLayer->layoutObject(), rect);
       rect.move(-graphicsLayer->offsetFromLayoutObject());
 
       glRects->push_back(rect);
     }
   }
 
   // Walk child layers of interest
   for (const PaintLayer* childLayer = curLayer->firstChild(); childLayer;
        childLayer = childLayer->nextSibling()) {
     if (layersWithRects.contains(childLayer)) {
@@ skipping 43 matching lines @@
   for (const auto& layerRect : layerRects) {
     const PaintLayer* layer = layerRect.key;
     do {
       if (!layersWithRects.insert(layer).isNewEntry)
         break;
 
       if (layer->parent()) {
         layer = layer->parent();
       } else {
         LayoutItem parentDocLayoutItem =
-            layer->layoutObject()->frame()->ownerLayoutItem();
+            layer->layoutObject().frame()->ownerLayoutItem();
         if (!parentDocLayoutItem.isNull()) {
           layer = parentDocLayoutItem.enclosingLayer();
           touchHandlerInChildFrame = true;
         }
       }
     } while (layer);
   }
 
   // Now walk the layer projecting rects while maintaining a LayoutGeometryMap
   MapCoordinatesFlags flags = UseTransforms;
@@ skipping 44 matching lines @@
 void ScrollingCoordinator::setTouchEventTargetRects(
     LayerHitTestRects& layerRects) {
   TRACE_EVENT0("input", "ScrollingCoordinator::setTouchEventTargetRects");
 
   // Ensure we have an entry for each composited layer that previously had rects
   // (so that old ones will get cleared out). Note that ideally we'd track this
   // on GraphicsLayer instead of Layer, but we have no good hook into the
   // lifetime of a GraphicsLayer.
   GraphicsLayerHitTestRects graphicsLayerRects;
   for (const PaintLayer* layer : m_layersWithTouchRects) {
-    if (layer->layoutObject()->frameView() &&
-        layer->layoutObject()->frameView()->shouldThrottleRendering()) {
+    if (layer->layoutObject().frameView() &&
+        layer->layoutObject().frameView()->shouldThrottleRendering()) {
       continue;
     }
     GraphicsLayer* mainGraphicsLayer =
-        layer->graphicsLayerBacking(layer->layoutObject());
+        layer->graphicsLayerBacking(&layer->layoutObject());
     if (mainGraphicsLayer)
       graphicsLayerRects.insert(mainGraphicsLayer, Vector<LayoutRect>());
     GraphicsLayer* scrollingContentsLayer = layer->graphicsLayerBacking();
     if (scrollingContentsLayer && scrollingContentsLayer != mainGraphicsLayer)
       graphicsLayerRects.insert(scrollingContentsLayer, Vector<LayoutRect>());
   }
 
   m_layersWithTouchRects.clear();
   for (const auto& layerRect : layerRects) {
     if (!layerRect.value.isEmpty()) {
@@ skipping 427 matching lines @@
           frameView ? toWebLayer(frameView->layoutViewportScrollableArea()
                                      ->layerForScrolling())
                     : nullptr) {
     return WebSize(frameView->layoutViewportScrollableArea()->contentsSize()) !=
            scrollLayer->bounds();
   }
   return false;
 }
 
 }  // namespace blink