Move scroll paint property nodes to be owned by the transform tree

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 73 matching lines @@
   const TransformPaintPropertyNode* svgLocalToBorderBoxTransform() const {
     return m_svgLocalToBorderBoxTransform.get();
   }
   const TransformPaintPropertyNode* scrollTranslation() const {
     return m_scrollTranslation.get();
   }
   const TransformPaintPropertyNode* scrollbarPaintOffset() const {
     return m_scrollbarPaintOffset.get();
   }
 
-  // Auxiliary scrolling information. Includes information such as the hierarchy
-  // of scrollable areas, the extent that can be scrolled, etc. The actual
-  // scroll offset is stored in the transform tree (m_scrollTranslation).
-  const ScrollPaintPropertyNode* scroll() const { return m_scroll.get(); }
-
   const EffectPaintPropertyNode* effect() const { return m_effect.get(); }
 
   // The hierarchy of the clip subtree created by a LayoutObject is as follows:
   // [ css clip ]
   // [ css clip fixed position]
   // [ inner border radius clip ] Clip created by a rounded border with overflow
   //                              clip. This clip is not inset by scrollbars.
   // +--- [ overflow clip ]       Clip created by overflow clip and is inset by
   //                              the scrollbars.
   const ClipPaintPropertyNode* cssClip() const { return m_cssClip.get(); }
   const ClipPaintPropertyNode* cssClipFixedPosition() const {
     return m_cssClipFixedPosition.get();
   }
   const ClipPaintPropertyNode* innerBorderRadiusClip() const {
     return m_innerBorderRadiusClip.get();
   }
   const ClipPaintPropertyNode* overflowClip() const {
     return m_overflowClip.get();
   }
 
-  // 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.
+  // This is a complete set of property nodes 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;'/> would have a propertyTreeState.effect()
+  // 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 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.
+  // This is the complete set of property nodes 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.
   const PropertyTreeState* contentsProperties() const {
     if (!m_contentsProperties) {
       if (!m_localBorderBoxProperties)
         return nullptr;
       updateContentsProperties();
     } else {
 #if DCHECK_IS_ON()
       // Check if the cached m_contentsProperties is valid.
       DCHECK(m_localBorderBoxProperties);
       std::unique_ptr<PropertyTreeState> oldProperties =
           std::move(m_contentsProperties);
       updateContentsProperties();
       DCHECK(*m_contentsProperties == *oldProperties);
 #endif
     }
     return m_contentsProperties.get();
   };
 
   void updateLocalBorderBoxProperties(
       const TransformPaintPropertyNode* transform,
       const ClipPaintPropertyNode* clip,
-      const EffectPaintPropertyNode* effect,
-      const ScrollPaintPropertyNode* scroll) {
+      const EffectPaintPropertyNode* effect) {
     if (m_localBorderBoxProperties) {
       m_localBorderBoxProperties->setTransform(transform);
       m_localBorderBoxProperties->setClip(clip);
       m_localBorderBoxProperties->setEffect(effect);
-      m_localBorderBoxProperties->setScroll(scroll);
     } else {
-      m_localBorderBoxProperties = WTF::wrapUnique(new PropertyTreeState(
-          PropertyTreeState(transform, clip, effect, scroll)));
+      m_localBorderBoxProperties = WTF::wrapUnique(
+          new PropertyTreeState(PropertyTreeState(transform, clip, effect)));
     }
     m_contentsProperties = nullptr;
   }
   void clearLocalBorderBoxProperties() {
     m_localBorderBoxProperties = nullptr;
     m_contentsProperties = 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); }
   bool clearEffect() { return clear(m_effect); }
   bool clearCssClip() { return clear(m_cssClip); }
   bool clearCssClipFixedPosition() { return clear(m_cssClipFixedPosition); }
   bool clearInnerBorderRadiusClip() { return clear(m_innerBorderRadiusClip); }
   bool clearOverflowClip() { return clear(m_overflowClip); }
   bool clearPerspective() { return clear(m_perspective); }
   bool clearSvgLocalToBorderBoxTransform() {
     return clear(m_svgLocalToBorderBoxTransform);
   }
   bool clearScrollTranslation() { return clear(m_scrollTranslation); }
   bool clearScrollbarPaintOffset() { return clear(m_scrollbarPaintOffset); }
-  bool clearScroll() { return clear(m_scroll); }
 
   // The following update* functions return true if the property tree structure
   // changes (a new node was created), and false otherwise. See the class-level
   // comment ("update & clear implementation note") for details about why this
   // is needed for efficient updates.
   template <typename... Args>
   bool updatePaintOffsetTranslation(Args&&... args) {
     return update(m_paintOffsetTranslation, std::forward<Args>(args)...);
   }
   template <typename... Args>
   bool updateTransform(Args&&... args) {
     return update(m_transform, std::forward<Args>(args)...);
   }
   template <typename... Args>
   bool updatePerspective(Args&&... args) {
     return update(m_perspective, std::forward<Args>(args)...);
   }
   template <typename... Args>
   bool updateSvgLocalToBorderBoxTransform(Args&&... args) {
     DCHECK(!scrollTranslation()) << "SVG elements cannot scroll so there "
                                     "should never be both a scroll translation "
                                     "and an SVG local to border box transform.";
     return update(m_svgLocalToBorderBoxTransform, std::forward<Args>(args)...);
   }
   template <typename... Args>
   bool updateScrollTranslation(Args&&... args) {
     DCHECK(!svgLocalToBorderBoxTransform())
         << "SVG elements cannot scroll so there should never be both a scroll "
            "translation and an SVG local to border box transform.";
-    return update(m_scrollTranslation, std::forward<Args>(args)...);
+    if (m_scrollTranslation) {
+      m_scrollTranslation->updateScrollTranslation(std::forward<Args>(args)...);
+      return false;
+    }
+    m_scrollTranslation = TransformPaintPropertyNode::createScrollTranslation(
+        std::forward<Args>(args)...);
+    return true;
   }
   template <typename... Args>
   bool updateScrollbarPaintOffset(Args&&... args) {
     return update(m_scrollbarPaintOffset, std::forward<Args>(args)...);
   }
   template <typename... Args>
-  bool updateScroll(Args&&... args) {
-    return update(m_scroll, std::forward<Args>(args)...);
-  }
-  template <typename... Args>
   bool updateEffect(Args&&... args) {
     return update(m_effect, std::forward<Args>(args)...);
   }
   template <typename... Args>
   bool updateCssClip(Args&&... args) {
     return update(m_cssClip, std::forward<Args>(args)...);
   }
   template <typename... Args>
   bool updateCssClipFixedPosition(Args&&... args) {
     return update(m_cssClipFixedPosition, std::forward<Args>(args)...);
@@ skipping 28 matching lines @@
     if (m_perspective)
       cloned->m_perspective = m_perspective->clone();
     if (m_svgLocalToBorderBoxTransform) {
       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) {
       cloned->m_localBorderBoxProperties =
           WTF::wrapUnique(new PropertyTreeState(*m_localBorderBoxProperties));
     }
     return cloned;
   }
 #endif
 
  private:
   ObjectPaintProperties() {}
@@ skipping 30 matching lines @@
   RefPtr<EffectPaintPropertyNode> m_effect;
   RefPtr<ClipPaintPropertyNode> m_cssClip;
   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<PropertyTreeState> m_localBorderBoxProperties;
   mutable std::unique_ptr<PropertyTreeState> m_contentsProperties;
 };
 
 }  // namespace blink
 
 #endif  // ObjectPaintProperties_h