[SPv2] Add CSS mask support

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 78 matching lines @@
   }
   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(); }
 
+  // The hierarchy of the effect subtree created by a LayoutObject as follows:
+  // [ mask isolation ]
+  // |   Isolated group created by CSS mask. Masked contents go in here.
+  // +-[ effect ]
+  // |     Isolated group for effects other than CSS mask. Including opacity
+  // |     and filters.
+  // +-[ mask content ]
+  //       Isolated group for painting the mask itself. This node will have
+  //       SkBlendMode::kDstIn and shall paint last, i.e. after masked contents.
+  const EffectPaintPropertyNode* maskIsolation() const {
+    return m_maskIsolation.get();
+  }
+  const EffectPaintPropertyNode* maskContent() const {
+    return m_maskContent.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.
+  // [ mask clip ]
+  // |   Clip created by CSS mask. It serves two purposes:
+  // |   1. Cull painting of the masked subtree. Because anything outside of
+  // |      the mask is never visible, it is pointless to paint them.
+  // |   2. Raster clip of the masked subtree. Because the mask implemented
+  // |      as SkBlendMode::kDstIn, pixels outside of mask's bound will be
+  // |      intact when they shall be masked out. This clip ensures no pixels
+  // |      leak out.
+  // +-[ css clip ]
+  //   |   Clip created by CSS clip. CSS clip applies to all descendants, this
+  //   |   node only applies to containing block descendants. For descendants
+  //   |   not contained by this object, use [ 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 scrollbar.
+  // [ css clip fixed position ]
+  //     Clip created by CSS clip. Only exists if the current clip includes
+  //     some clip that doesn't apply to our fixed position descendants.
+  const ClipPaintPropertyNode* maskClip() const { return m_maskClip.get(); }
   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();
   }
@@ skipping 54 matching lines @@
     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 clearMaskIsolation() { return clear(m_maskIsolation); }
+  bool clearMaskContent() { return clear(m_maskContent); }
   bool clearEffect() { return clear(m_effect); }
+  bool clearMaskClip() { return clear(m_maskClip); }
   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); }
@@ skipping 31 matching lines @@
   }
   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 updateMaskIsolation(Args&&... args) {
+    return update(m_maskIsolation, std::forward<Args>(args)...);
+  }
+  template <typename... Args>
+  bool updateMaskContent(Args&&... args) {
+    return update(m_maskContent, std::forward<Args>(args)...);
+  }
+  template <typename... Args>
   bool updateEffect(Args&&... args) {
     return update(m_effect, std::forward<Args>(args)...);
   }
   template <typename... Args>
+  bool updateMaskClip(Args&&... args) {
+    return update(m_maskClip, 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)...);
   }
   template <typename... Args>
   bool updateInnerBorderRadiusClip(Args&&... args) {
     return update(m_innerBorderRadiusClip, std::forward<Args>(args)...);
   }
   template <typename... Args>
   bool updateOverflowClip(Args&&... args) {
     return update(m_overflowClip, std::forward<Args>(args)...);
   }
 
 #if DCHECK_IS_ON()
   // Used by FindPropertiesNeedingUpdate.h for recording the current properties.
   std::unique_ptr<ObjectPaintProperties> clone() const {
     std::unique_ptr<ObjectPaintProperties> cloned = create();
     if (m_paintOffsetTranslation)
       cloned->m_paintOffsetTranslation = m_paintOffsetTranslation->clone();
     if (m_transform)
       cloned->m_transform = m_transform->clone();
+    if (m_maskIsolation)
+      cloned->m_maskIsolation = m_maskIsolation->clone();
+    if (m_maskContent)
+      cloned->m_maskContent = m_maskContent->clone();
     if (m_effect)
       cloned->m_effect = m_effect->clone();
+    if (m_maskClip)
+      cloned->m_maskClip = m_maskClip->clone();
     if (m_cssClip)
       cloned->m_cssClip = m_cssClip->clone();
     if (m_cssClipFixedPosition)
       cloned->m_cssClipFixedPosition = m_cssClipFixedPosition->clone();
     if (m_innerBorderRadiusClip)
       cloned->m_innerBorderRadiusClip = m_innerBorderRadiusClip->clone();
     if (m_overflowClip)
       cloned->m_overflowClip = m_overflowClip->clone();
     if (m_perspective)
       cloned->m_perspective = m_perspective->clone();
@@ skipping 40 matching lines @@
       return false;
     }
     field = PaintPropertyNode::create(std::forward<Args>(args)...);
     return true;
   }
 
   void updateContentsProperties() const;
 
   RefPtr<TransformPaintPropertyNode> m_paintOffsetTranslation;
   RefPtr<TransformPaintPropertyNode> m_transform;
+  RefPtr<EffectPaintPropertyNode> m_maskIsolation;
+  RefPtr<EffectPaintPropertyNode> m_maskContent;
   RefPtr<EffectPaintPropertyNode> m_effect;
+  RefPtr<ClipPaintPropertyNode> m_maskClip;
   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