Store local border box property cache outside ObjectPaintProperties

third_party/WebKit/Source/core/layout/LayoutObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 47 matching lines @@
 class HitTestLocation;
 class HitTestRequest;
 class HitTestResult;
 class InlineBox;
 class LayoutBoxModelObject;
 class LayoutBlock;
 class LayoutFlowThread;
 class LayoutGeometryMap;
 class LayoutMultiColumnSpannerPlaceholder;
 class LayoutView;
+class PropertyTreeState;
 class ObjectPaintProperties;
 class PaintInvalidationState;
 class PaintLayer;
 class PseudoStyleRequest;
 
 struct PaintInfo;
 struct PaintInvalidatorContext;
 
 enum VisualRectFlags { DefaultVisualRectFlags = 0, EdgeInclusive = 1 };
 
@@ skipping 316 matching lines @@
 
   // For SlimmingPaintInvalidation/SPv2 only.
   // The ObjectPaintProperties structure holds references to the property tree
   // nodes that are created by the layout object. The property nodes should only
   // be updated during InPrePaint phase of the document lifecycle.
   const ObjectPaintProperties* paintProperties() const {
     DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
     return m_rarePaintData ? m_rarePaintData->paintProperties() : nullptr;
   }
 
+  // The complete set of property nodes that should be used as a starting point
+  // to paint this LayoutObject. See: m_localBorderBoxProperties comment.
+  const PropertyTreeState* localBorderBoxProperties() const {
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
+    if (m_rarePaintData)
+      return m_rarePaintData->localBorderBoxProperties();
+    return nullptr;
+  }
+
+  // The complete set of property nodes that should be used as a starting point
+  // to paint contents of this LayoutObject. See: m_contentsProperties comment.
+  const PropertyTreeState* contentsProperties() const {
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
+    if (m_rarePaintData)
+      return m_rarePaintData->contentsProperties();
+    return nullptr;
+  }
+
  private:
   // This is for paint-related data that is not needed on all LayoutObjects.
   // TODO(pdr): Store LayoutBoxModelObject's m_paintLayer in this structure.
-  // TODO(pdr): Store ObjectPaintProperties::LocalBorderBoxProperties here.
   struct CORE_EXPORT RarePaintData {
     WTF_MAKE_NONCOPYABLE(RarePaintData);
     USING_FAST_MALLOC(RarePaintData);
 
    public:
     RarePaintData();
 
     ObjectPaintProperties* paintProperties() const {
       return m_paintProperties.get();
     }
     ObjectPaintProperties& ensurePaintProperties();
 
+    PropertyTreeState* localBorderBoxProperties() const {
+      return m_localBorderBoxProperties.get();
+    }
+
+    void clearLocalBorderBoxProperties();
+    void setLocalBorderBoxProperties(PropertyTreeState&);
+    const PropertyTreeState* contentsProperties() const;
+
    private:
     // Holds references to the paint property nodes created by this object.
     std::unique_ptr<ObjectPaintProperties> m_paintProperties;
+
+    // This is a complete set of property nodes that should be used as a
+    // starting point to paint a LayoutObject. This data is cached because some
+    // properties inherit from the containing block chain instead of the
+    // painting parent and cannot be derived in O(1) during the paint walk.
+    //
+    // For example: <div style='opacity: 0.3;'/>
+    //   The div's local border box properties would have an opacity 0.3 effect
+    //   node. Even though the div has no transform, its local border box
+    //   properties would have a transform node that points to the div's
+    //   ancestor transform space.
+    std::unique_ptr<PropertyTreeState> m_localBorderBoxProperties;
+
+    // This is the complete set of property nodes that can be used to paint the
+    // contents of this object. It is similar to m_localBorderBoxProperties but
+    // includes properties (e.g., overflow clip, scroll translation) that apply
+    // to contents. This cached value is derived from m_localBorderBoxProperties
+    // and m_paintProperties and should be invalidated when these change.
+    mutable std::unique_ptr<PropertyTreeState> m_contentsProperties;
   };
 
   RarePaintData& ensureRarePaintData();
   RarePaintData* rarePaintData() { return m_rarePaintData.get(); }
 
   //////////////////////////////////////////
   // Helper functions. Dangerous to use!
   void setPreviousSibling(LayoutObject* previous) { m_previous = previous; }
   void setNextSibling(LayoutObject* next) { m_next = next; }
   void setParent(LayoutObject* parent) {
@@ skipping 1360 matching lines @@
     }
 #endif
 
    protected:
     friend class PaintPropertyTreeBuilder;
     FRIEND_TEST_ALL_PREFIXES(AnimationCompositorAnimationsTest,
                              canStartAnimationOnCompositorTransformSPv2);
     FRIEND_TEST_ALL_PREFIXES(AnimationCompositorAnimationsTest,
                              canStartAnimationOnCompositorEffectSPv2);
 
-    // The following two functions can be called from PaintPropertyTreeBuilder
-    // only.
+    // The following non-const functions for ObjectPaintProperties should only
+    // be called from PaintPropertyTreeBuilder.
     ObjectPaintProperties& ensurePaintProperties() {
       return m_layoutObject.ensureRarePaintData().ensurePaintProperties();
     }
     ObjectPaintProperties* paintProperties() {
       if (auto* paintData = m_layoutObject.rarePaintData())
         return paintData->paintProperties();
       return nullptr;
     }
 
+    // The following non-const functions for local border box properties should
+    // only be called from PaintPropertyTreeBuilder.
+    void clearLocalBorderBoxProperties() {
+      if (auto* paintData = m_layoutObject.rarePaintData())
+        paintData->clearLocalBorderBoxProperties();
+    }
+    void setLocalBorderBoxProperties(PropertyTreeState& localBorderBox) {
+      return m_layoutObject.ensureRarePaintData().setLocalBorderBoxProperties(
+          localBorderBox);
+    }
+
     friend class LayoutObject;
     MutableForPainting(const LayoutObject& layoutObject)
         : m_layoutObject(const_cast<LayoutObject&>(layoutObject)) {}
 
     LayoutObject& m_layoutObject;
   };
   MutableForPainting getMutableForPainting() const {
     return MutableForPainting(*this);
   }
 
@@ skipping 977 matching lines @@
 CORE_EXPORT void showLineTree(const blink::LayoutObject*);
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1,
                                 const blink::LayoutObject* object2);
 
 #endif
 
 #endif  // LayoutObject_h