Combine LayoutObject::previousPaintOffset and paintOffset in paint properties

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

 // Copyright 2015 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.
 
 #ifndef ObjectPaintProperties_h
 #define ObjectPaintProperties_h
 
 #include "core/CoreExport.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
@@ skipping 10 matching lines @@
 namespace blink {
 
 // This class stores the paint property nodes associated with a LayoutObject.
 // The object owns each of the property nodes directly set here (e.g, m_cssClip,
 // m_paintOffsetTranslation, etc.) and RefPtrs are only used to harden against
 // use-after-free bugs. These paint properties are built/updated by
 // PaintPropertyTreeBuilder during the PrePaint lifecycle step.
 //
 // There are two groups of information stored on ObjectPaintProperties:
 // 1. The set of property nodes created locally and owned by this LayoutObject.
-// 2. The set of property nodes (inherited, or created locally) and paint offset
-//    that can be used to paint the border box of this LayoutObject (see:
-//    localBorderBoxProperties).
+// 2. The set of property nodes (inherited, or created locally) that can be used
+//    along with LayoutObject::paintOffset to paint the border box of this
+//    LayoutObject (see: localBorderBoxProperties).
 //
 // [update & clear implementation note] This class has update[property](...) and
 // clear[property]() helper functions for efficiently creating and updating
 // properties. These functions return true if the property tree structure
 // changes (e.g., a node is added or removed), and false otherwise. Property
 // nodes store parent pointers but not child pointers and these return values
 // are important for catching property tree structure changes which require
 // updating descendant's parent pointers. The update functions use a
 // create-or-update pattern of re-using existing properties for efficiency:
 // 1. It avoids extra allocations.
@@ skipping 65 matching lines @@
   const ClipPaintPropertyNode* cssClipFixedPosition() const {
     return m_cssClipFixedPosition.get();
   }
   const ClipPaintPropertyNode* innerBorderRadiusClip() const {
     return m_innerBorderRadiusClip.get();
   }
   const ClipPaintPropertyNode* overflowClip() const {
     return m_overflowClip.get();
   }
 
-  // The complete set of property tree nodes (inherited, or created locally) and
-  // paint offset that can be used to paint. |paintOffset| is relative to the
-  // propertyTreeState's transform space.
-  // See: localBorderBoxProperties and contentsProperties.
-  struct PropertyTreeStateWithOffset {
-    PropertyTreeStateWithOffset(LayoutPoint offset, PropertyTreeState treeState)
-        : paintOffset(offset), propertyTreeState(treeState) {}
-    LayoutPoint paintOffset;
-    PropertyTreeState propertyTreeState;
-  };
-
   // This is a complete set of property nodes and paint offset that should be
   // used as a starting point to paint this layout object. This 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; position: relative; margin: 11px;'/>
   // would have a paint offset of (11px, 11px) and propertyTreeState.effect()
   // would be an effect node with opacity of 0.3 which was created by the div
   // itself. Note that propertyTreeState.transform() would not be null but would
   // instead point to the transform space setup by div's ancestors.
-  const PropertyTreeStateWithOffset* localBorderBoxProperties() const {
+  const PropertyTreeState* localBorderBoxProperties() const {
     return m_localBorderBoxProperties.get();
   }
 
   // This is the complete set of property nodes and paint offset that can be
   // used to paint the contents of this object. It is similar to
   // localBorderBoxProperties but includes properties (e.g., overflow clip,
   // scroll translation) that apply to contents. This is suitable for paint
   // invalidation.
-  ObjectPaintProperties::PropertyTreeStateWithOffset contentsProperties() const;
+  PropertyTreeState contentsProperties() const;
 
   void updateLocalBorderBoxProperties(
-      LayoutPoint& paintOffset,
       const TransformPaintPropertyNode* transform,
       const ClipPaintPropertyNode* clip,
       const EffectPaintPropertyNode* effect,
       const ScrollPaintPropertyNode* scroll) {
     if (m_localBorderBoxProperties) {
-      m_localBorderBoxProperties->paintOffset = paintOffset;
-      m_localBorderBoxProperties->propertyTreeState.setTransform(transform);
-      m_localBorderBoxProperties->propertyTreeState.setClip(clip);
-      m_localBorderBoxProperties->propertyTreeState.setEffect(effect);
-      m_localBorderBoxProperties->propertyTreeState.setScroll(scroll);
+      m_localBorderBoxProperties->setTransform(transform);
+      m_localBorderBoxProperties->setClip(clip);
+      m_localBorderBoxProperties->setEffect(effect);
+      m_localBorderBoxProperties->setScroll(scroll);
     } else {
-      m_localBorderBoxProperties = WTF::wrapUnique(
-          new ObjectPaintProperties::PropertyTreeStateWithOffset(
-              paintOffset, PropertyTreeState(transform, clip, effect, scroll)));
+      m_localBorderBoxProperties = WTF::wrapUnique(new PropertyTreeState(
+          PropertyTreeState(transform, clip, effect, scroll)));
     }
   }
   void clearLocalBorderBoxProperties() { m_localBorderBoxProperties = nullptr; }
 
   // The following clear* functions return true if the property tree structure
   // changes (an existing node was deleted), and false otherwise. See the
   // class-level comment ("update & clear implementation note") for details
   // about why this is needed for efficient updates.
   bool clearPaintOffsetTranslation() { return clear(m_paintOffsetTranslation); }
   bool clearTransform() { return clear(m_transform); }
@@ skipping 93 matching lines @@
       cloned->m_svgLocalToBorderBoxTransform =
           m_svgLocalToBorderBoxTransform->clone();
     }
     if (m_scrollTranslation)
       cloned->m_scrollTranslation = m_scrollTranslation->clone();
     if (m_scrollbarPaintOffset)
       cloned->m_scrollbarPaintOffset = m_scrollbarPaintOffset->clone();
     if (m_scroll)
       cloned->m_scroll = m_scroll->clone();
     if (m_localBorderBoxProperties) {
-      auto& state = m_localBorderBoxProperties->propertyTreeState;
       cloned->m_localBorderBoxProperties =
-          WTF::wrapUnique(new PropertyTreeStateWithOffset(
-              m_localBorderBoxProperties->paintOffset,
-              PropertyTreeState(state.transform(), state.clip(), state.effect(),
-                                state.scroll())));
+          WTF::wrapUnique(new PropertyTreeState(*m_localBorderBoxProperties));
     }
     return cloned;
   }
 #endif
 
  private:
   ObjectPaintProperties() {}
 
   // Return true if the property tree structure changes (an existing node was
   // deleted), and false otherwise. See the class-level comment ("update & clear
@@ skipping 27 matching lines @@
   RefPtr<ClipPaintPropertyNode> m_cssClipFixedPosition;
   RefPtr<ClipPaintPropertyNode> m_innerBorderRadiusClip;
   RefPtr<ClipPaintPropertyNode> m_overflowClip;
   RefPtr<TransformPaintPropertyNode> m_perspective;
   // TODO(pdr): Only LayoutSVGRoot needs this and it should be moved there.
   RefPtr<TransformPaintPropertyNode> m_svgLocalToBorderBoxTransform;
   RefPtr<TransformPaintPropertyNode> m_scrollTranslation;
   RefPtr<TransformPaintPropertyNode> m_scrollbarPaintOffset;
   RefPtr<ScrollPaintPropertyNode> m_scroll;
 
-  std::unique_ptr<PropertyTreeStateWithOffset> m_localBorderBoxProperties;
+  std::unique_ptr<PropertyTreeState> m_localBorderBoxProperties;
 };
 
 }  // namespace blink
 
 #endif  // ObjectPaintProperties_h