Put rare PaintLayer fields into PaintLayerRareData

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

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 72 matching lines @@
 // FIXME: remove this once the compositing query ASSERTS are no longer hit.
 class CORE_EXPORT DisableCompositingQueryAsserts {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(DisableCompositingQueryAsserts);
 public:
     DisableCompositingQueryAsserts();
 private:
     TemporaryChange<CompositingQueryMode> m_disabler;
 };
 
+struct PaintLayerRareData {
+    PaintLayerRareData();
+    ~PaintLayerRareData();
+
+    // Our current relative position offset.
+    LayoutSize offsetForInFlowPosition;
+
+    OwnPtr<TransformationMatrix> transform;
+
+    // Pointer to the enclosing Layer that caused us to be paginated. It is 0 if we are not paginated.
+    //
+    // See LayoutMultiColumnFlowThread and
+    // https://sites.google.com/a/chromium.org/dev/developers/design-documents/multi-column-layout
+    // for more information about the multicol implementation. It's important to understand the
+    // difference between flow thread coordinates and visual coordinates when working with multicol
+    // in Layer, since Layer is one of the few places where we have to worry about the
+    // visual ones. Internally we try to use flow-thread coordinates whenever possible.
+    PaintLayer* enclosingPaginationLayer;
+
+    // These compositing reasons are updated whenever style changes, not while updating compositing layers.
+    // They should not be used to infer the compositing state of this layer.
+    CompositingReasons potentialCompositingReasonsFromStyle;
+
+    // Once computed, indicates all that a layer needs to become composited using the CompositingReasons enum bitfield.
+    CompositingReasons compositingReasons;
+
+    // If the layer paints into its own backings, this keeps track of the backings.
+    // It's nullptr if the layer is not composited or paints into grouped backing.
+    OwnPtr<CompositedLayerMapping> compositedLayerMapping;
+
+    // If the layer paints into grouped backing (i.e. squashed), this points to the
+    // grouped CompositedLayerMapping. It's null if the layer is not composited or
+    // paints into its own backing.
+    CompositedLayerMapping* groupedMapping;
+
+    IntRect blockSelectionGapsBounds;
+
+    OwnPtr<PaintLayerReflectionInfo> reflectionInfo;
+
+    // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
+    LayoutSize subpixelAccumulation;
+};
+
 // PaintLayer is an old object that handles lots of unrelated operations.
 //
 // We want it to die at some point and be replaced by more focused objects,
 // which would remove (or at least compartimentalize) a lot of complexity.
 // See the STATUS OF PAINTLAYER section below.
 //
 // The class is central to painting and hit-testing. That's because it handles
 // a lot of tasks (we included ones done by associated satellite objects for
 // historical reasons):
 // - Complex painting operations (opacity, clipping, filters, reflections, ...).
@@ skipping 51 matching lines @@
 // need to be moved to the appropriate LayoutObject class, probably to a rare
 // data field to avoid growing all the LayoutObjects.
 //
 // A good example of this is PaintLayerScrollableArea, which can only happen
 // be instanciated for LayoutBoxes. With the current design, it's hard to know
 // that by reading the code.
 class CORE_EXPORT PaintLayer : public DisplayItemClient {
     WTF_MAKE_NONCOPYABLE(PaintLayer);
 public:
     PaintLayer(LayoutBoxModelObject*, PaintLayerType);
-    ~PaintLayer();
+    ~PaintLayer() override;
 
     // DisplayItemClient methods
     String debugName() const final;
-    IntRect visualRect() const override;
+    IntRect visualRect() const final;
 
     LayoutBoxModelObject* layoutObject() const { return m_layoutObject; }
     LayoutBox* layoutBox() const { return m_layoutObject && m_layoutObject->isBox() ? toLayoutBox(m_layoutObject) : 0; }
     PaintLayer* parent() const { return m_parent; }
     PaintLayer* previousSibling() const { return m_previous; }
     PaintLayer* nextSibling() const { return m_next; }
     PaintLayer* firstChild() const { return m_first; }
     PaintLayer* lastChild() const { return m_last; }
 
     // TODO(wangxianzhu): Find a better name for it. 'paintContainer' might be good but
     // we can't use it for now because it conflicts with PaintInfo::paintContainer.
     PaintLayer* compositingContainer() const;
 
     void addChild(PaintLayer* newChild, PaintLayer* beforeChild = 0);
     PaintLayer* removeChild(PaintLayer*);
 
     void removeOnlyThisLayer();
     void insertOnlyThisLayer();
 
     void styleChanged(StyleDifference, const ComputedStyle* oldStyle);
 
     // FIXME: Many people call this function while it has out-of-date information.
     bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
 
-    void setLayerType(PaintLayerType layerType) { m_layerType = layerType; }
+    void setLayerType(PaintLayerType layerType) { m_layerType = layerType; ASSERT(static_cast<PaintLayerType>(m_layerType) == layerType); }
 
     bool isTransparent() const { return layoutObject()->isTransparent() || layoutObject()->style()->hasBlendMode() || layoutObject()->hasMask(); }
 
     bool isReflection() const { return layoutObject()->isReplica(); }
-    PaintLayerReflectionInfo* reflectionInfo() { return m_reflectionInfo.get(); }
-    const PaintLayerReflectionInfo* reflectionInfo() const { return m_reflectionInfo.get(); }
+    PaintLayerReflectionInfo* reflectionInfo() { return m_rareData ? m_rareData->reflectionInfo.get() : nullptr; }
+    const PaintLayerReflectionInfo* reflectionInfo() const { return const_cast<PaintLayer*>(this)->reflectionInfo(); }
 
     const PaintLayer* root() const
     {
         const PaintLayer* curr = this;
         while (curr->parent())
             curr = curr->parent();
         return curr;
     }
 
     const LayoutPoint& location() const { ASSERT(!m_needsPositionUpdate); return m_location; }
     // FIXME: size() should ASSERT(!m_needsPositionUpdate) as well, but that fails in some tests,
     // for example, fast/repaint/clipped-relative.html.
     const IntSize& size() const { return m_size; }
     void setSizeHackForLayoutTreeAsText(const IntSize& size) { m_size = size; }
 
     LayoutRect rect() const { return LayoutRect(location(), LayoutSize(size())); }
 
     bool isRootLayer() const { return m_isRootLayer; }
 
     PaintLayerCompositor* compositor() const;
 
     // Notification from the layoutObject that its content changed (e.g. current frame of image changed).
     // Allows updates of layer content without invalidating paint.
     void contentChanged(ContentChangeType);
 
     void updateLayerPositionsAfterLayout();
     void updateLayerPositionsAfterOverflowScroll(const DoubleSize& scrollDelta);
 
-    PaintLayer* enclosingPaginationLayer() const { return m_enclosingPaginationLayer; }
+    PaintLayer* enclosingPaginationLayer() const { return m_rareData ? m_rareData->enclosingPaginationLayer : nullptr; }
 
     void updateTransformationMatrix();
     PaintLayer* renderingContextRoot();
 
-    const LayoutSize& offsetForInFlowPosition() const { return m_offsetForInFlowPosition; }
+    LayoutSize offsetForInFlowPosition() const { return m_rareData ? m_rareData->offsetForInFlowPosition : LayoutSize(); }
 
     void addBlockSelectionGapsBounds(const LayoutRect&);
     void clearBlockSelectionGapsBounds();
     void invalidatePaintForBlockSelectionGaps();
     IntRect blockSelectionGapsBounds() const;
     bool hasBlockSelectionGapBounds() const;
 
     PaintLayerStackingNode* stackingNode() { return m_stackingNode.get(); }
     const PaintLayerStackingNode* stackingNode() const { return m_stackingNode.get(); }
 
@@ skipping 90 matching lines @@
     LayoutUnit staticBlockPosition() const { return m_staticBlockPosition; }
 
     void setStaticInlinePosition(LayoutUnit position) { m_staticInlinePosition = position; }
     void setStaticBlockPosition(LayoutUnit position) { m_staticBlockPosition = position; }
 
     LayoutSize subpixelAccumulation() const;
     void setSubpixelAccumulation(const LayoutSize&);
 
     bool hasTransformRelatedProperty() const { return layoutObject()->hasTransformRelatedProperty(); }
     // Note that this transform has the transform-origin baked in.
-    TransformationMatrix* transform() const { return m_transform.get(); }
-    void setTransform(PassOwnPtr<TransformationMatrix> transform) { m_transform = transform; }
-    void clearTransform() { m_transform.clear(); }
+    TransformationMatrix* transform() const { return m_rareData ? m_rareData->transform.get() : nullptr; }
 
     // currentTransform computes a transform which takes accelerated animations into account. The
     // resulting transform has transform-origin baked in. If the layer does not have a transform,
     // returns the identity matrix.
     TransformationMatrix currentTransform() const;
     TransformationMatrix renderableTransform(GlobalPaintFlags) const;
 
     // Get the perspective transform, which is applied to transformed sublayers.
     // Returns true if the layer has a -webkit-perspective.
     // Note that this transform does not have the perspective-origin baked in.
     TransformationMatrix perspectiveTransform() const;
     FloatPoint perspectiveOrigin() const;
     bool preserves3D() const { return layoutObject()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
-    bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
+    bool has3DTransform() const { return m_rareData && m_rareData->transform && !m_rareData->transform->isAffine(); }
 
     // FIXME: reflections should force transform-style to be flat in the style: https://bugs.webkit.org/show_bug.cgi?id=106959
     bool shouldPreserve3D() const { return !layoutObject()->hasReflection() && layoutObject()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
 
     void filterNeedsPaintInvalidation();
     bool hasFilter() const { return layoutObject()->hasFilter(); }
 
     void* operator new(size_t);
     // Only safe to call from LayoutBoxModelObject::destroyLayer()
     void operator delete(void*);
 
     CompositingState compositingState() const;
 
     // This returns true if our document is in a phase of its lifestyle during which
     // compositing state may legally be read.
     bool isAllowedToQueryCompositingState() const;
 
     // Don't null check this.
     // FIXME: Rename.
     CompositedLayerMapping* compositedLayerMapping() const;
     GraphicsLayer* graphicsLayerBacking() const;
     GraphicsLayer* graphicsLayerBackingForScrolling() const;
     // NOTE: If you are using hasCompositedLayerMapping to determine the state of compositing for this layer,
     // (and not just to do bookkeeping related to the mapping like, say, allocating or deallocating a mapping),
     // then you may have incorrect logic. Use compositingState() instead.
     // FIXME: This is identical to null checking compositedLayerMapping(), why not just call that?
-    bool hasCompositedLayerMapping() const { return m_compositedLayerMapping.get(); }
+    bool hasCompositedLayerMapping() const { return m_rareData && m_rareData->compositedLayerMapping; }
     void ensureCompositedLayerMapping();
     void clearCompositedLayerMapping(bool layerBeingDestroyed = false);
-    CompositedLayerMapping* groupedMapping() const { return m_groupedMapping; }
+    CompositedLayerMapping* groupedMapping() const { return m_rareData ? m_rareData->groupedMapping : nullptr; }
     enum SetGroupMappingOptions {
         InvalidateLayerAndRemoveFromMapping,
         DoNotInvalidateLayerAndRemoveFromMapping
     };
     void setGroupedMapping(CompositedLayerMapping*, SetGroupMappingOptions);
 
     bool hasCompositedMask() const;
     bool hasCompositedClippingMask() const;
     bool needsCompositedScrolling() const { return m_scrollableArea && m_scrollableArea->needsCompositedScrolling(); }
 
@@ skipping 58 matching lines @@
     // Compute rects only for this layer
     void computeSelfHitTestRects(LayerHitTestRects&) const;
 
     // FIXME: This should probably return a ScrollableArea but a lot of internal methods are mistakenly exposed.
     PaintLayerScrollableArea* scrollableArea() const { return m_scrollableArea.get(); }
     PaintLayerClipper& clipper() { return m_clipper; }
     const PaintLayerClipper& clipper() const { return m_clipper; }
 
     bool scrollsOverflow() const;
 
-    CompositingReasons potentialCompositingReasonsFromStyle() const { return m_potentialCompositingReasonsFromStyle; }
-    void setPotentialCompositingReasonsFromStyle(CompositingReasons reasons) { ASSERT(reasons == (reasons & CompositingReasonComboAllStyleDeterminedReasons)); m_potentialCompositingReasonsFromStyle = reasons; }
+    CompositingReasons potentialCompositingReasonsFromStyle() const { return m_rareData ? m_rareData->potentialCompositingReasonsFromStyle : CompositingReasonNone; }
+    void setPotentialCompositingReasonsFromStyle(CompositingReasons reasons)
+    {
+        ASSERT(reasons == (reasons & CompositingReasonComboAllStyleDeterminedReasons));
+        if (m_rareData || reasons != CompositingReasonNone)
+            ensureRareData().potentialCompositingReasonsFromStyle = reasons;
+    }
 
-    bool hasStyleDeterminedDirectCompositingReasons() const { return m_potentialCompositingReasonsFromStyle & CompositingReasonComboAllDirectStyleDeterminedReasons; }
+    bool hasStyleDeterminedDirectCompositingReasons() const { return potentialCompositingReasonsFromStyle() & CompositingReasonComboAllDirectStyleDeterminedReasons; }
 
     class AncestorDependentCompositingInputs {
         DISALLOW_NEW();
     public:
         AncestorDependentCompositingInputs()
-            : opacityAncestor(0)
-            , transformAncestor(0)
-            , filterAncestor(0)
-            , clippingContainer(0)
-            , ancestorScrollingLayer(0)
-            , nearestFixedPositionLayer(0)
-            , scrollParent(0)
-            , clipParent(0)
-            , hasAncestorWithClipPath(false)
+            : clippingContainer(nullptr)
         { }
 
         IntRect clippedAbsoluteBoundingBox;
+        const LayoutObject* clippingContainer;
+    };
+
+    class RareAncestorDependentCompositingInputs {
+    public:
+        RareAncestorDependentCompositingInputs()
+            : opacityAncestor(nullptr)
+            , transformAncestor(nullptr)
+            , filterAncestor(nullptr)
+            , ancestorScrollingLayer(nullptr)
+            , nearestFixedPositionLayer(nullptr)
+            , scrollParent(nullptr)
+            , clipParent(nullptr)
+        { }
+
+        bool isDefault() const { return !opacityAncestor && !transformAncestor && !filterAncestor && !ancestorScrollingLayer && !nearestFixedPositionLayer && !scrollParent && !clipParent; }
+
         const PaintLayer* opacityAncestor;
         const PaintLayer* transformAncestor;
         const PaintLayer* filterAncestor;
-        const LayoutObject* clippingContainer;
         const PaintLayer* ancestorScrollingLayer;
         const PaintLayer* nearestFixedPositionLayer;
 
         // A scroll parent is a compositor concept. It's only needed in blink
         // because we need to use it as a promotion trigger. A layer has a
         // scroll parent if neither its compositor scrolling ancestor, nor any
         // other layer scrolled by this ancestor, is a stacking ancestor of this
         // layer. Layers with scroll parents must be scrolled with the main
         // scrolling layer by the compositor.
         const PaintLayer* scrollParent;
 
         // A clip parent is another compositor concept that has leaked into
         // blink so that it may be used as a promotion trigger. Layers with clip
         // parents escape the clip of a stacking tree ancestor. The compositor
         // needs to know about clip parents in order to circumvent its normal
         // clipping logic.
         const PaintLayer* clipParent;
-
-        unsigned hasAncestorWithClipPath : 1;
-    };
-
-    class DescendantDependentCompositingInputs {
-        DISALLOW_NEW();
-    public:
-        DescendantDependentCompositingInputs()
-            : hasDescendantWithClipPath(false)
-            , hasNonIsolatedDescendantWithBlendMode(false)
-        { }
-
-        unsigned hasDescendantWithClipPath : 1;
-        unsigned hasNonIsolatedDescendantWithBlendMode : 1;
     };
 
     void setNeedsCompositingInputsUpdate();
     bool childNeedsCompositingInputsUpdate() const { return m_childNeedsCompositingInputsUpdate; }
     bool needsCompositingInputsUpdate() const
     {
         // While we're updating the compositing inputs, these values may differ.
         // We should never be asking for this value when that is the case.
         ASSERT(m_needsDescendantDependentCompositingInputsUpdate == m_needsAncestorDependentCompositingInputsUpdate);
         return m_needsDescendantDependentCompositingInputsUpdate;
     }
 
-    void updateAncestorDependentCompositingInputs(const AncestorDependentCompositingInputs&);
-    void updateDescendantDependentCompositingInputs(const DescendantDependentCompositingInputs&);
+    void updateAncestorDependentCompositingInputs(const AncestorDependentCompositingInputs&, const RareAncestorDependentCompositingInputs&, bool hasAncestorWithClipPath);
+    void updateDescendantDependentCompositingInputs(bool hasDescendantWithClipPath, bool hasNonIsolatedDescendantWithBlendMode);
     void didUpdateCompositingInputs();
 
-    const AncestorDependentCompositingInputs& ancestorDependentCompositingInputs() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_ancestorDependentCompositingInputs; }
-    const DescendantDependentCompositingInputs& descendantDependentCompositingInputs() const { ASSERT(!m_needsDescendantDependentCompositingInputsUpdate); return m_descendantDependentCompositingInputs; }
-
-    IntRect clippedAbsoluteBoundingBox() const { return ancestorDependentCompositingInputs().clippedAbsoluteBoundingBox; }
-    const PaintLayer* opacityAncestor() const { return ancestorDependentCompositingInputs().opacityAncestor; }
-    const PaintLayer* transformAncestor() const { return ancestorDependentCompositingInputs().transformAncestor; }
-    const PaintLayer* filterAncestor() const { return ancestorDependentCompositingInputs().filterAncestor; }
-    const LayoutObject* clippingContainer() const { return ancestorDependentCompositingInputs().clippingContainer; }
-    const PaintLayer* ancestorScrollingLayer() const { return ancestorDependentCompositingInputs().ancestorScrollingLayer; }
-    const PaintLayer* nearestFixedPositionLayer() const { return ancestorDependentCompositingInputs().nearestFixedPositionLayer; }
-    PaintLayer* scrollParent() const { return const_cast<PaintLayer*>(ancestorDependentCompositingInputs().scrollParent); }
-    PaintLayer* clipParent() const { return const_cast<PaintLayer*>(ancestorDependentCompositingInputs().clipParent); }
-    bool hasAncestorWithClipPath() const { return ancestorDependentCompositingInputs().hasAncestorWithClipPath; }
-    bool hasDescendantWithClipPath() const { return descendantDependentCompositingInputs().hasDescendantWithClipPath; }
+    IntRect clippedAbsoluteBoundingBox() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_ancestorDependentCompositingInputs.clippedAbsoluteBoundingBox; }
+    const PaintLayer* opacityAncestor() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_rareAncestorDependentCompositingInputs ? m_rareAncestorDependentCompositingInputs->opacityAncestor : nullptr; }
+    const PaintLayer* transformAncestor() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_rareAncestorDependentCompositingInputs ? m_rareAncestorDependentCompositingInputs->transformAncestor : nullptr; }
+    const PaintLayer* filterAncestor() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_rareAncestorDependentCompositingInputs ? m_rareAncestorDependentCompositingInputs->filterAncestor : nullptr; }
+    const LayoutObject* clippingContainer() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_ancestorDependentCompositingInputs.clippingContainer; }
+    const PaintLayer* ancestorScrollingLayer() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_rareAncestorDependentCompositingInputs ? m_rareAncestorDependentCompositingInputs->ancestorScrollingLayer : nullptr; }
+    const PaintLayer* nearestFixedPositionLayer() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_rareAncestorDependentCompositingInputs ? m_rareAncestorDependentCompositingInputs->nearestFixedPositionLayer : nullptr; }
+    const PaintLayer* scrollParent() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_rareAncestorDependentCompositingInputs ? m_rareAncestorDependentCompositingInputs->scrollParent : nullptr; }
+    const PaintLayer* clipParent() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_rareAncestorDependentCompositingInputs ? m_rareAncestorDependentCompositingInputs->clipParent : nullptr; }
+    bool hasAncestorWithClipPath() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_hasAncestorWithClipPath; }
+    bool hasDescendantWithClipPath() const { ASSERT(!m_needsDescendantDependentCompositingInputsUpdate); return m_hasDescendantWithClipPath; }
     bool hasNonIsolatedDescendantWithBlendMode() const;
 
     bool lostGroupedMapping() const { ASSERT(isAllowedToQueryCompositingState()); return m_lostGroupedMapping; }
     void setLostGroupedMapping(bool b) { m_lostGroupedMapping = b; }
 
-    CompositingReasons compositingReasons() const { ASSERT(isAllowedToQueryCompositingState()); return m_compositingReasons; }
+    CompositingReasons compositingReasons() const { ASSERT(isAllowedToQueryCompositingState()); return m_rareData ? m_rareData->compositingReasons : CompositingReasonNone; }
     void setCompositingReasons(CompositingReasons, CompositingReasons mask = CompositingReasonAll);
 
     bool hasCompositingDescendant() const { ASSERT(isAllowedToQueryCompositingState()); return m_hasCompositingDescendant; }
     void setHasCompositingDescendant(bool);
 
     bool shouldIsolateCompositedDescendants() const { ASSERT(isAllowedToQueryCompositingState()); return m_shouldIsolateCompositedDescendants; }
     void setShouldIsolateCompositedDescendants(bool);
 
     void updateDescendantDependentFlags();
 
@@ skipping 135 matching lines @@
 
     void updateOrRemoveFilterClients();
 
     void updatePaginationRecursive(bool needsPaginationUpdate = false);
     void clearPaginationRecursive();
 
     void blockSelectionGapsBoundsChanged();
 
     void markCompositingContainerChainForNeedsRepaint();
 
-    PaintLayerType m_layerType;
+    PaintLayerRareData& ensureRareData()
+    {
+        if (!m_rareData)
+            m_rareData = adoptPtr(new PaintLayerRareData);
+        return *m_rareData;
+    }
+
+    unsigned m_layerType : 2; // PaintLayerType
 
     // Self-painting layer is an optimization where we avoid the heavy Layer painting
     // machinery for a Layer allocated only to handle the overflow clip case.
     // FIXME(crbug.com/332791): Self-painting layer should be merged into the overflow-only concept.
     unsigned m_isSelfPaintingLayer : 1;
 
     // If have no self-painting descendants, we don't have to walk our children during painting. This can lead to
     // significant savings, especially if the tree has lots of non-self-painting layers grouped together (e.g. table cells).
     mutable unsigned m_hasSelfPaintingLayerDescendant : 1;
     mutable unsigned m_hasSelfPaintingLayerDescendantDirty : 1;
@@ skipping 36 matching lines @@
     // True if this layout layer just lost its grouped mapping due to the CompositedLayerMapping being destroyed,
     // and we don't yet know to what graphics layer this Layer will be assigned.
     unsigned m_lostGroupedMapping : 1;
 
     unsigned m_needsRepaint : 1;
     unsigned m_previousPaintResult : 1; // PaintLayerPainter::PaintResult
 
     unsigned m_needsPaintPhaseDescendantOutlines : 1;
     unsigned m_needsPaintPhaseFloat : 1;
 
+    // These bitfields are part of ancestor/descendant dependent compositing inputs.
+    unsigned m_hasDescendantWithClipPath : 1;
+    unsigned m_hasNonIsolatedDescendantWithBlendMode : 1;
+    unsigned m_hasAncestorWithClipPath : 1;
+
     LayoutBoxModelObject* m_layoutObject;
 
     PaintLayer* m_parent;
     PaintLayer* m_previous;
     PaintLayer* m_next;
     PaintLayer* m_first;
     PaintLayer* m_last;
 
-    // Our current relative position offset.
-    LayoutSize m_offsetForInFlowPosition;
-
     // Our (x,y) coordinates are in our parent layer's coordinate space.
     LayoutPoint m_location;
 
     // The layer's size.
     //
     // If the associated LayoutBoxModelObject is a LayoutBox, it's its border
     // box. Otherwise, this is the LayoutInline's lines' bounding box.
     IntSize m_size;
 
     // Cached normal flow values for absolute positioned elements with static left/top values.
     LayoutUnit m_staticInlinePosition;
     LayoutUnit m_staticBlockPosition;
 
-    OwnPtr<TransformationMatrix> m_transform;
+    AncestorDependentCompositingInputs m_ancestorDependentCompositingInputs;
+    OwnPtr<RareAncestorDependentCompositingInputs> m_rareAncestorDependentCompositingInputs;
 
-    // Pointer to the enclosing Layer that caused us to be paginated. It is 0 if we are not paginated.
-    //
-    // See LayoutMultiColumnFlowThread and
-    // https://sites.google.com/a/chromium.org/dev/developers/design-documents/multi-column-layout
-    // for more information about the multicol implementation. It's important to understand the
-    // difference between flow thread coordinates and visual coordinates when working with multicol
-    // in Layer, since Layer is one of the few places where we have to worry about the
-    // visual ones. Internally we try to use flow-thread coordinates whenever possible.
-    PaintLayer* m_enclosingPaginationLayer;
-
-    // These compositing reasons are updated whenever style changes, not while updating compositing layers.
-    // They should not be used to infer the compositing state of this layer.
-    CompositingReasons m_potentialCompositingReasonsFromStyle;
-
-    // Once computed, indicates all that a layer needs to become composited using the CompositingReasons enum bitfield.
-    CompositingReasons m_compositingReasons;
-
-    DescendantDependentCompositingInputs m_descendantDependentCompositingInputs;
-    AncestorDependentCompositingInputs m_ancestorDependentCompositingInputs;
-
-    IntRect m_blockSelectionGapsBounds;
-
-    OwnPtr<CompositedLayerMapping> m_compositedLayerMapping;
     OwnPtrWillBePersistent<PaintLayerScrollableArea> m_scrollableArea;
 
-    CompositedLayerMapping* m_groupedMapping;
-
     PaintLayerClipper m_clipper; // FIXME: Lazily allocate?
     OwnPtr<PaintLayerStackingNode> m_stackingNode;
-    OwnPtr<PaintLayerReflectionInfo> m_reflectionInfo;
-
-    LayoutSize m_subpixelAccumulation; // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
 
     IntSize m_previousScrollOffsetAccumulationForPainting;
     RefPtr<ClipRects> m_previousPaintingClipRects;
     LayoutRect m_previousPaintDirtyRect;
+
+    OwnPtr<PaintLayerRareData> m_rareData;
 };
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const blink::PaintLayer*);
 void showLayerTree(const blink::LayoutObject*);
 #endif
 
 #endif // Layer_h