Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp

 /*
  * Copyright (C) 2012 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 172 matching lines @@
   AutoReset<size_t> positionChange(&m_insertionPosition, m_mapping.size());
   do {
     layoutObject =
         layoutObject->pushMappingToContainer(ancestorLayoutObject, *this);
   } while (layoutObject && layoutObject != ancestorLayoutObject);
 
   ASSERT(m_mapping.isEmpty() ||
          isTopmostLayoutView(m_mapping[0].m_layoutObject));
 }
 
-static bool canMapBetweenLayoutObjects(const LayoutObject* layoutObject,
-                                       const LayoutObject* ancestor) {
-  for (const LayoutObject* current = layoutObject;;
+static bool canMapBetweenLayoutObjects(const LayoutObject& layoutObject,
+                                       const LayoutObject& ancestor) {
+  for (const LayoutObject* current = &layoutObject;;
        current = current->parent()) {
     const ComputedStyle& style = current->styleRef();
     if (style.position() == EPosition::kFixed ||
         style.isFlippedBlocksWritingMode())
       return false;
 
     if (current->style()->canContainFixedPositionObjects() ||
         current->isLayoutFlowThread() || current->isSVGRoot())
       return false;
 
-    if (current == ancestor)
+    if (current == &ancestor)
       break;
 
     if (current->isFloatingWithNonContainingBlockParent())
       return false;
   }
 
   return true;
 }
 
 void LayoutGeometryMap::pushMappingsToAncestor(
     const PaintLayer* layer,
     const PaintLayer* ancestorLayer) {
-  const LayoutObject* layoutObject = layer->layoutObject();
+  const LayoutObject& layoutObject = layer->layoutObject();
 
   bool crossDocument =
       ancestorLayer &&
-      layer->layoutObject()->frame() != ancestorLayer->layoutObject()->frame();
+      layoutObject.frame() != ancestorLayer->layoutObject().frame();
   ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
 
   // We have to visit all the layoutObjects to detect flipped blocks. This might
   // defeat the gains from mapping via layers.
   bool canConvertInLayerTree =
       (ancestorLayer && !crossDocument)
-          ? canMapBetweenLayoutObjects(layer->layoutObject(),
+          ? canMapBetweenLayoutObjects(layoutObject,
                                        ancestorLayer->layoutObject())
           : false;
 
   LAYOUT_GEOMETRY_MAP_LOG(
       "LayoutGeometryMap::pushMappingsToAncestor from layer %p to layer %p, "
       "canConvertInLayerTree=%d\n",
       layer, ancestorLayer, canConvertInLayerTree);
 
   if (canConvertInLayerTree) {
     LayoutPoint layerOffset;
     layer->convertToLayerCoords(ancestorLayer, layerOffset);
 
     // The LayoutView must be pushed first.
     if (!m_mapping.size()) {
-      ASSERT(ancestorLayer->layoutObject()->isLayoutView());
-      pushMappingsToAncestor(ancestorLayer->layoutObject(), 0);
+      DCHECK(ancestorLayer->layoutObject().isLayoutView());
+      pushMappingsToAncestor(&ancestorLayer->layoutObject(), 0);
     }
 
     AutoReset<size_t> positionChange(&m_insertionPosition, m_mapping.size());
     bool accumulatingTransform =
-        layer->layoutObject()->style()->preserves3D() ||
-        ancestorLayer->layoutObject()->style()->preserves3D();
-    push(layoutObject, toLayoutSize(layerOffset),
+        layoutObject.style()->preserves3D() ||
+        ancestorLayer->layoutObject().style()->preserves3D();
+    push(&layoutObject, toLayoutSize(layerOffset),
          accumulatingTransform ? AccumulatingTransform : 0);
     return;
   }
   const LayoutBoxModelObject* ancestorLayoutObject =
-      ancestorLayer ? ancestorLayer->layoutObject() : 0;
-  pushMappingsToAncestor(layoutObject, ancestorLayoutObject);
+      ancestorLayer ? &ancestorLayer->layoutObject() : 0;
+  pushMappingsToAncestor(&layoutObject, ancestorLayoutObject);
 }
 
 void LayoutGeometryMap::push(const LayoutObject* layoutObject,
                              const LayoutSize& offsetFromContainer,
                              GeometryInfoFlags flags,
                              LayoutSize offsetForFixedPosition) {
   LAYOUT_GEOMETRY_MAP_LOG("LayoutGeometryMap::push %p %d,%d isNonUniform=%d\n",
                           layoutObject, offsetFromContainer.width().toInt(),
                           offsetFromContainer.height().toInt(), isNonUniform);
 
@@ skipping 51 matching lines @@
   }
   if (UNLIKELY(mightBeSaturated)) {
     m_accumulatedOffset = LayoutSize();
     for (const auto& step : m_mapping)
       m_accumulatedOffset += step.m_offset;
   }
 }
 
 void LayoutGeometryMap::popMappingsToAncestor(const PaintLayer* ancestorLayer) {
   const LayoutBoxModelObject* ancestorLayoutObject =
-      ancestorLayer ? ancestorLayer->layoutObject() : 0;
+      ancestorLayer ? &ancestorLayer->layoutObject() : 0;
   popMappingsToAncestor(ancestorLayoutObject);
 }
 
 void LayoutGeometryMap::stepInserted(const LayoutGeometryMapStep& step) {
   m_accumulatedOffset += step.m_offset;
 
   if (step.m_flags & IsNonUniform)
     ++m_nonUniformStepsCount;
 
   if (step.m_transform)
@@ skipping 31 matching lines @@
   // If we're not working with multiple LayoutViews, then any view is considered
   // "topmost" (to preserve original behavior).
   if (!(m_mapCoordinatesFlags & TraverseDocumentBoundaries))
     return true;
 
   return layoutObject->frame()->isMainFrame();
 }
 #endif
 
 }  // namespace blink