Move all ancestor-dependent properties out of PaintLayer and into an aux. struct.

third_party/WebKit/Source/core/layout/compositing/CompositingInputsUpdater.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/compositing/CompositingInputsUpdater.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutView.h"
@@ skipping 126 matching lines @@
 
   if (layer->needsCompositingInputsUpdate()) {
     if (info.enclosingCompositedLayer)
       info.enclosingCompositedLayer->compositedLayerMapping()
           ->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
     updateType = ForceUpdate;
   }
 
   if (updateType == ForceUpdate) {
     PaintLayer::AncestorDependentCompositingInputs properties;
-    PaintLayer::RareAncestorDependentCompositingInputs rareProperties;
 
     if (!layer->isRootLayer()) {
       if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         properties.unclippedAbsoluteBoundingBox =
             enclosingIntRect(m_geometryMap.absoluteRect(
                 FloatRect(layer->boundingBoxForCompositingOverlapTest())));
         // FIXME: Setting the absBounds to 1x1 instead of 0x0 makes very little
         // sense, but removing this code will make JSGameBench sad.
         // See https://codereview.chromium.org/13912020/
         if (properties.unclippedAbsoluteBoundingBox.isEmpty())
           properties.unclippedAbsoluteBoundingBox.setSize(IntSize(1, 1));
 
         IntRect clipRect =
             pixelSnappedIntRect(layer->clipper()
                                     .backgroundClipRect(ClipRectsContext(
                                         m_rootLayer, AbsoluteClipRects))
                                     .rect());
         properties.clippedAbsoluteBoundingBox =
             properties.unclippedAbsoluteBoundingBox;
         properties.clippedAbsoluteBoundingBox.intersect(clipRect);
       }
 
       const PaintLayer* parent = layer->parent();
-      rareProperties.opacityAncestor =
+      properties.opacityAncestor =
           parent->isTransparent() ? parent : parent->opacityAncestor();
-      rareProperties.transformAncestor =
+      properties.transformAncestor =
           parent->transform() ? parent : parent->transformAncestor();
-      rareProperties.filterAncestor = parent->hasFilterInducingProperty()
-                                          ? parent
-                                          : parent->filterAncestor();
+      properties.filterAncestor = parent->hasFilterInducingProperty()
+                                      ? parent
+                                      : parent->filterAncestor();
       bool layerIsFixedPosition =
           layer->layoutObject()->style()->position() == FixedPosition;
-      rareProperties.nearestFixedPositionLayer =
+      properties.nearestFixedPositionLayer =
           layerIsFixedPosition ? layer : parent->nearestFixedPositionLayer();
 
       if (info.hasAncestorWithClipRelatedProperty) {
         const PaintLayer* parentLayerOnClippingContainerChain =
             findParentLayerOnClippingContainerChain(layer);
         const bool parentHasClipRelatedProperty =
             parentLayerOnClippingContainerChain->layoutObject()
                 ->hasClipRelatedProperty();
         properties.clippingContainer =
             parentHasClipRelatedProperty
                 ? parentLayerOnClippingContainerChain->layoutObject()
                 : parentLayerOnClippingContainerChain->clippingContainer();
 
         if (layer->layoutObject()->isOutOfFlowPositioned() &&
             !layer->subtreeIsInvisible()) {
           const PaintLayer* clippingLayer =
               properties.clippingContainer
                   ? properties.clippingContainer->enclosingLayer()
                   : layer->compositor()->rootLayer();
           if (hasClippedStackingAncestor(layer, clippingLayer))
-            rareProperties.clipParent = clippingLayer;
+            properties.clipParent = clippingLayer;
         }
       }
 
       if (info.lastScrollingAncestor) {
         const LayoutObject* containingBlock =
             layer->layoutObject()->containingBlock();
         const PaintLayer* parentLayerOnContainingBlockChain =
             findParentLayerOnContainingBlockChain(containingBlock);
 
-        rareProperties.ancestorScrollingLayer =
+        properties.ancestorScrollingLayer =
             parentLayerOnContainingBlockChain->ancestorScrollingLayer();
         if (parentLayerOnContainingBlockChain->scrollsOverflow())
-          rareProperties.ancestorScrollingLayer =
-              parentLayerOnContainingBlockChain;
+          properties.ancestorScrollingLayer = parentLayerOnContainingBlockChain;
 
         if (layer->stackingNode()->isStacked() &&
-            rareProperties.ancestorScrollingLayer &&
+            properties.ancestorScrollingLayer &&
             !info.ancestorStackingContext->layoutObject()->isDescendantOf(
-                rareProperties.ancestorScrollingLayer->layoutObject()))
-          rareProperties.scrollParent = rareProperties.ancestorScrollingLayer;
+                properties.ancestorScrollingLayer->layoutObject()))
+          properties.scrollParent = properties.ancestorScrollingLayer;
       }
     }
 
     layer->updateAncestorDependentCompositingInputs(
-        properties, rareProperties, info.hasAncestorWithClipPath);
+        properties, info.hasAncestorWithClipPath);
   }
 
   if (layer->stackingNode()->isStackingContext())
     info.ancestorStackingContext = layer;
 
   if (layer->isRootLayer() || layer->layoutObject()->hasOverflowClip())
     info.lastOverflowClipLayer = layer;
 
   if (layer->scrollsOverflow())
     info.lastScrollingAncestor = layer;
@@ skipping 41 matching lines @@
   ASSERT(!layer->needsCompositingInputsUpdate());
 
   for (PaintLayer* child = layer->firstChild(); child;
        child = child->nextSibling())
     assertNeedsCompositingInputsUpdateBitsCleared(child);
 }
 
 #endif
 
 }  // namespace blink