Disable some PaintPropertyTreeBuilder features for SPv1 SlimmingPaintInvalidation

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilder.cpp

 // 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.
 
 #include "core/paint/PaintPropertyTreeBuilder.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 339 matching lines @@
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.isSVG() && !object.isSVGRoot()) {
     updateTransformForNonRootSVG(object, context);
     return;
   }
 
   if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
     const ComputedStyle& style = object.styleRef();
 
-    CompositingReasons compositingReasons =
-        compositingReasonsForTransform(object);
+    bool needsTransformNode = false;
+    CompositingReasons compositingReasons = CompositingReasonNone;
+    if (object.isBox()) {
+      // A transform node is allocated for transforms, preserves-3d (SPv2) and
+      // any direct compositing reason (SPv2). The latter is required because
+      // this is the only way to represent compositing both an element and its
+      // stacking descendants.
+      needsTransformNode |= style.hasTransform();
+      if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        needsTransformNode |= style.preserves3D();

[chrishtr, 2016/12/28 18:15:18]

Are you sure preserve-3D is not required for SlimmingPaintInvalidation?

[Xianzhu, 2016/12/28 18:25:29]

Yes. GeometryMapper doesn't use FlattenInheritedTransform.

+        compositingReasons = compositingReasonsForTransform(object);
+        needsTransformNode |= (compositingReasons != CompositingReasonNone);
+      }
+    }
 
-    // A transform node is allocated for transforms, preserves-3d and any
-    // direct compositing reason. The latter is required because this is the
-    // only way to represent compositing both an element and its stacking
-    // descendants.
-    if (object.isBox() && (style.hasTransform() || style.preserves3D() ||
-                           compositingReasons != CompositingReasonNone)) {
+    if (needsTransformNode) {
       auto& box = toLayoutBox(object);
       TransformationMatrix matrix;
       style.applyTransform(
           matrix, box.size(), ComputedStyle::ExcludeTransformOrigin,
           ComputedStyle::IncludeMotionPath,
           ComputedStyle::IncludeIndependentTransformProperties);
 
       // TODO(trchen): transform-style should only be respected if a PaintLayer
       // is created.
       // If a node with transform-style: preserve-3d does not exist in an
       // existing rendering context, it establishes a new one.
       unsigned renderingContextID = context.current.renderingContextID;
-      if (style.preserves3D() && !renderingContextID)
+      if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
+          style.preserves3D() && !renderingContextID)
         renderingContextID = PtrHash<const LayoutObject>::hash(&object);
 
       auto& properties = object.getMutableForPainting().ensurePaintProperties();
       context.forceSubtreeUpdate |= properties.updateTransform(
           context.current.transform, matrix, transformOrigin(box),
           context.current.shouldFlattenInheritedTransform, renderingContextID,
           compositingReasons);
     } else {
       if (auto* properties = object.getMutableForPainting().paintProperties())
         context.forceSubtreeUpdate |= properties->clearTransform();
     }
   }
 
   const auto* properties = object.paintProperties();
   if (properties && properties->transform()) {
     context.current.transform = properties->transform();
-    if (object.styleRef().preserves3D()) {
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
+        object.styleRef().preserves3D()) {
       context.current.renderingContextID =
           properties->transform()->renderingContextID();
       context.current.shouldFlattenInheritedTransform = false;
     } else {
       context.current.renderingContextID = 0;
       context.current.shouldFlattenInheritedTransform = true;
     }
   }
 }
 
 void PaintPropertyTreeBuilder::updateEffect(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
+  if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+    return;
+
   const ComputedStyle& style = object.styleRef();
 
   const bool isCSSIsolatedGroup =
       object.isBoxModelObject() && style.isStackingContext();
   const bool isSVGExceptRoot = object.isSVG() && !object.isSVGRoot();
   if (!isCSSIsolatedGroup && !isSVGExceptRoot) {
     if (object.needsPaintPropertyUpdate() || context.forceSubtreeUpdate) {
       if (auto* properties = object.getMutableForPainting().paintProperties())
         context.forceSubtreeUpdate |= properties->clearEffect();
     }
@@ skipping 566 matching lines @@
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 
   context.forceSubtreeUpdate |= object.subtreeNeedsPaintPropertyUpdate();
 }
 
 }  // namespace blink