Skip paint chunks with effectively invisible opacity.

For SPv2 we always paint effectively invisible content,
but during layerization we scrutinize effect node and
skip chunks that would be effectively invisible. This
simplifies code in SPv2 while still avoiding the
resource and processing overhead of creating, managing
and rastering a layer for that chunk.

BUG=713403
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2

Review-Url: https://codereview.chromium.org/2833883003
Cr-Commit-Position: refs/heads/master@{#468120}

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

@@ -135,9 +135,14 @@ PaintResult PaintLayerPainter::Paint(
           ->ShouldThrottleRendering())
     return kFullyPainted;
 
-  // If this layer is totally invisible then there is nothing to paint.
-  if (PaintedOutputInvisible(painting_info))
+  // If this layer is totally invisible then there is nothing to paint. In SPv2
+  // we simplify this optimization by painting even when effectively invisible
+  // but skipping the painted content during layerization in
+  // PaintArtifactCompositor.
+  if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
+      PaintedOutputInvisible(painting_info)) {
     return kFullyPainted;
+  }
 
   if (paint_layer_.PaintsWithTransparency(painting_info.GetGlobalPaintFlags()))
     paint_flags |= kPaintLayerHaveTransparency;

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

@@ -32,23 +32,19 @@ class PaintLayerPainterTest
       : ScopedRootLayerScrollingForTest(GetParam().root_layer_scrolling),
         PaintControllerPaintTestBase(GetParam().slimming_paint_v2) {}
 
-  void ExpectPaintedOutputVisibility(const char* element_name,
-                                     bool expected_spv1) {
-    ExpectPaintedOutputVisibility(element_name, expected_spv1, expected_spv1);
-  }
+  void ExpectPaintedOutputInvisible(const char* element_name,
+                                    bool expected_value) {
+    // The optimization to skip painting for effectively-invisible content is
+    // limited to SPv1.
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+      return;
 
-  void ExpectPaintedOutputVisibility(const char* element_name,
-                                     bool expected_spv1,
-                                     bool expected_spv2) {
     PaintLayer* target_layer =
         ToLayoutBox(GetLayoutObjectByElementId(element_name))->Layer();
     PaintLayerPaintingInfo painting_info(nullptr, LayoutRect(),
                                          kGlobalPaintNormalPhase, LayoutSize());
     bool invisible =
         PaintLayerPainter(*target_layer).PaintedOutputInvisible(painting_info);
-    bool expected_value = RuntimeEnabledFeatures::slimmingPaintV2Enabled()
-                              ? expected_spv2
-                              : expected_spv1;
     EXPECT_EQ(expected_value, invisible)
         << "Failed painted output visibility [spv2_enabled="
         << RuntimeEnabledFeatures::slimmingPaintV2Enabled()
@@ -795,21 +791,21 @@ TEST_P(PaintLayerPainterTest,
 TEST_P(PaintLayerPainterTest, DontPaintWithTinyOpacity) {
   SetBodyInnerHTML(
       "<div id='target' style='background: blue; opacity: 0.0001'></div>");
-  ExpectPaintedOutputVisibility("target", true, false);
+  ExpectPaintedOutputInvisible("target", true);
 }
 
 TEST_P(PaintLayerPainterTest, DoPaintWithTinyOpacityAndWillChangeOpacity) {
   SetBodyInnerHTML(
       "<div id='target' style='background: blue; opacity: 0.0001; "
       "will-change: opacity'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest, DoPaintWithTinyOpacityAndBackdropFilter) {
   SetBodyInnerHTML(
       "<div id='target' style='background: blue; opacity: 0.0001;"
       "  backdrop-filter: blur(2px);'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest,
@@ -817,20 +813,20 @@ TEST_P(PaintLayerPainterTest,
   SetBodyInnerHTML(
       "<div id='target' style='background: blue; opacity: 0.0001;"
       "  backdrop-filter: blur(2px); will-change: opacity'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest, DoPaintWithCompositedTinyOpacity) {
   SetBodyInnerHTML(
       "<div id='target' style='background: blue; opacity: 0.0001;"
       " will-change: transform'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest, DoPaintWithNonTinyOpacity) {
   SetBodyInnerHTML(
       "<div id='target' style='background: blue; opacity: 0.1'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest, DoPaintWithEffectAnimationZeroOpacity) {
@@ -848,10 +844,10 @@ TEST_P(PaintLayerPainterTest, DoPaintWithEffectAnimationZeroOpacity) {
       "} "
       "</style> "
       "<div id='target'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
-TEST_P(PaintLayerPainterTest, DontPaintWithTransformAnimationZeroOpacity) {
+TEST_P(PaintLayerPainterTest, DoPaintWithTransformAnimationZeroOpacity) {
   SetBodyInnerHTML(
       "<style> "
       "div#target { "
@@ -865,7 +861,7 @@ TEST_P(PaintLayerPainterTest, DontPaintWithTransformAnimationZeroOpacity) {
       "} "
       "</style> "
       "<div id='target'>x</div></div>");
-  ExpectPaintedOutputVisibility("target", false, true);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest,
@@ -884,7 +880,7 @@ TEST_P(PaintLayerPainterTest,
       "} "
       "</style> "
       "<div id='target'>x</div></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest, DoPaintWithWillChangeOpacity) {
@@ -897,7 +893,7 @@ TEST_P(PaintLayerPainterTest, DoPaintWithWillChangeOpacity) {
       "}"
       "</style> "
       "<div id='target'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest, DoPaintWithZeroOpacityAndWillChangeOpacity) {
@@ -911,7 +907,7 @@ TEST_P(PaintLayerPainterTest, DoPaintWithZeroOpacityAndWillChangeOpacity) {
       "}"
       "</style> "
       "<div id='target'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 TEST_P(PaintLayerPainterTest,
@@ -926,7 +922,7 @@ TEST_P(PaintLayerPainterTest,
       "}"
       "</style> "
       "<div id='target'></div>");
-  ExpectPaintedOutputVisibility("target", false);
+  ExpectPaintedOutputInvisible("target", false);
 }
 
 }  // namespace blink

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

@@ -474,11 +474,49 @@ bool PaintArtifactCompositor::CanDecompositeEffect(
   return true;
 }
 
+static bool EffectGroupContainsChunk(
+    const EffectPaintPropertyNode& group_effect,
+    const PaintChunk& chunk) {
+  const EffectPaintPropertyNode* effect =
+      chunk.properties.property_tree_state.Effect();
+  return effect == &group_effect ||
+         StrictChildOfAlongPath(&group_effect, effect);
+}
+
+static bool SkipGroupIfEffectivelyInvisible(
+    const PaintArtifact& paint_artifact,
+    const EffectPaintPropertyNode& current_group,
+    Vector<PaintChunk>::const_iterator& chunk_it) {
+  // The lower bound of visibility is considered to be 0.0004f < 1/2048. With
+  // 10-bit color channels (only available on the newest Macs as of 2016;
+  // otherwise it's 8-bit), we see that an alpha of 1/2048 or less leads to a
+  // color output of less than 0.5 in all channels, hence not visible.
+  static const float kMinimumVisibleOpacity = 0.0004f;
+  if (current_group.Opacity() >= kMinimumVisibleOpacity ||
+      current_group.HasDirectCompositingReasons()) {
+    return false;
+  }
+
+  // Fast-forward to just past the end of the chunk sequence within this
+  // effect group.
+  DCHECK(EffectGroupContainsChunk(current_group, *chunk_it));
+  while (++chunk_it != paint_artifact.PaintChunks().end()) {
+    if (!EffectGroupContainsChunk(current_group, *chunk_it))
+      break;
+  }
+  return true;
+}
+
 void PaintArtifactCompositor::LayerizeGroup(
     const PaintArtifact& paint_artifact,
     Vector<PendingLayer>& pending_layers,
     const EffectPaintPropertyNode& current_group,
     Vector<PaintChunk>::const_iterator& chunk_it) {
+  // Skip paint chunks that are effectively invisible due to opacity and don't
+  // have a direct compositing reason.
+  if (SkipGroupIfEffectivelyInvisible(paint_artifact, current_group, chunk_it))
+    return;
+
   size_t first_layer_in_current_group = pending_layers.size();
   // The worst case time complexity of the algorithm is O(pqd), where
   // p = the number of paint chunks.

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp

@@ -143,6 +143,30 @@ class PaintArtifactCompositorTestWithPropertyTrees
         .get();
   }
 
+  void AddSimpleRectChunk(TestPaintArtifact& artifact) {
+    artifact
+        .Chunk(TransformPaintPropertyNode::Root(),
+               ClipPaintPropertyNode::Root(), EffectPaintPropertyNode::Root())
+        .RectDrawing(FloatRect(100, 100, 200, 100), Color::kBlack);
+  }
+
+  void CreateSimpleArtifactWithOpacity(TestPaintArtifact& artifact,
+                                       float opacity,
+                                       bool include_preceding_chunk,
+                                       bool include_subsequent_chunk) {
+    if (include_preceding_chunk)
+      AddSimpleRectChunk(artifact);
+    RefPtr<EffectPaintPropertyNode> effect =
+        CreateOpacityOnlyEffect(EffectPaintPropertyNode::Root(), opacity);
+    artifact
+        .Chunk(TransformPaintPropertyNode::Root(),
+               ClipPaintPropertyNode::Root(), effect)
+        .RectDrawing(FloatRect(0, 0, 100, 100), Color::kBlack);
+    if (include_subsequent_chunk)
+      AddSimpleRectChunk(artifact);
+    Update(artifact.Build());
+  }
+
  private:
   std::unique_ptr<PaintArtifactCompositor> paint_artifact_compositor_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
@@ -2075,4 +2099,171 @@ TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
       composited_element_ids.Contains(effect->GetCompositorElementId()));
 }
 
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, SkipChunkWithOpacityZero) {
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0, false, false);
+    ASSERT_EQ(0u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0, true, false);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0, true, true);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0, false, true);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, SkipChunkWithTinyOpacity) {
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.0003f, false, false);
+    ASSERT_EQ(0u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.0003f, true, false);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.0003f, true, true);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.0003f, false, true);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       DontSkipChunkWithMinimumOpacity) {
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.0004f, false, false);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.0004f, true, false);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.0004f, true, true);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.0004f, false, true);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       DontSkipChunkWithAboveMinimumOpacity) {
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.3f, false, false);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.3f, true, false);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.3f, true, true);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+  {
+    TestPaintArtifact artifact;
+    CreateSimpleArtifactWithOpacity(artifact, 0.3f, false, true);
+    ASSERT_EQ(1u, ContentLayerCount());
+  }
+}
+
+PassRefPtr<EffectPaintPropertyNode> CreateEffectWithOpacityAndReason(
+    float opacity,
+    CompositingReasons reason,
+    RefPtr<EffectPaintPropertyNode> parent = nullptr) {
+  return EffectPaintPropertyNode::Create(
+      parent ? parent : EffectPaintPropertyNode::Root(),
+      TransformPaintPropertyNode::Root(), ClipPaintPropertyNode::Root(),
+      kColorFilterNone, CompositorFilterOperations(), opacity,
+      SkBlendMode::kSrcOver, reason);
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       DontSkipChunkWithTinyOpacityAndDirectCompositingReason) {
+  RefPtr<EffectPaintPropertyNode> effect =
+      CreateEffectWithOpacityAndReason(0.0001f, kCompositingReasonCanvas);
+  TestPaintArtifact artifact;
+  artifact
+      .Chunk(TransformPaintPropertyNode::Root(), ClipPaintPropertyNode::Root(),
+             effect)
+      .RectDrawing(FloatRect(0, 0, 100, 100), Color::kBlack);
+  Update(artifact.Build());
+  ASSERT_EQ(1u, ContentLayerCount());
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       SkipChunkWithTinyOpacityAndVisibleChildEffectNode) {
+  RefPtr<EffectPaintPropertyNode> tinyEffect =
+      CreateEffectWithOpacityAndReason(0.0001f, kCompositingReasonNone);
+  RefPtr<EffectPaintPropertyNode> visibleEffect =
+      CreateEffectWithOpacityAndReason(0.5f, kCompositingReasonNone,
+                                       tinyEffect);
+  TestPaintArtifact artifact;
+  artifact
+      .Chunk(TransformPaintPropertyNode::Root(), ClipPaintPropertyNode::Root(),
+             visibleEffect)
+      .RectDrawing(FloatRect(0, 0, 100, 100), Color::kBlack);
+  Update(artifact.Build());
+  ASSERT_EQ(0u, ContentLayerCount());
+}
+
+TEST_F(
+    PaintArtifactCompositorTestWithPropertyTrees,
+    DontSkipChunkWithTinyOpacityAndVisibleChildEffectNodeWithCompositingParent) {
+  RefPtr<EffectPaintPropertyNode> tinyEffect =
+      CreateEffectWithOpacityAndReason(0.0001f, kCompositingReasonCanvas);
+  RefPtr<EffectPaintPropertyNode> visibleEffect =
+      CreateEffectWithOpacityAndReason(0.5f, kCompositingReasonNone,
+                                       tinyEffect);
+  TestPaintArtifact artifact;
+  artifact
+      .Chunk(TransformPaintPropertyNode::Root(), ClipPaintPropertyNode::Root(),
+             visibleEffect)
+      .RectDrawing(FloatRect(0, 0, 100, 100), Color::kBlack);
+  Update(artifact.Build());
+  ASSERT_EQ(1u, ContentLayerCount());
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
+       SkipChunkWithTinyOpacityAndVisibleChildEffectNodeWithCompositingChild) {
+  RefPtr<EffectPaintPropertyNode> tinyEffect =
+      CreateEffectWithOpacityAndReason(0.0001f, kCompositingReasonNone);
+  RefPtr<EffectPaintPropertyNode> visibleEffect =
+      CreateEffectWithOpacityAndReason(0.5f, kCompositingReasonCanvas,
+                                       tinyEffect);
+  TestPaintArtifact artifact;
+  artifact
+      .Chunk(TransformPaintPropertyNode::Root(), ClipPaintPropertyNode::Root(),
+             visibleEffect)
+      .RectDrawing(FloatRect(0, 0, 100, 100), Color::kBlack);
+  Update(artifact.Build());
+  ASSERT_EQ(0u, ContentLayerCount());
+}
+
 }  // namespace blink