Skip paint chunks with effectively invisible opacity.

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.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 "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/paint/display_item_list.h"
@@ skipping 456 matching lines @@
     return false;
   if (effect->HasDirectCompositingReasons())
     return false;
   if (!CanUpcastTo(layer.property_tree_state,
                    PropertyTreeState(effect->LocalTransformSpace(),
                                      effect->OutputClip(), effect)))
     return false;
   return true;
 }
 
+static bool SkipEffectivelyInvisibleChunks(

[trchen, 2017/04/27 00:24:10]

I feel this could be confusing because it sounds like the helper inspects each
chunk and skip the invisible ones. How about "SkipGroupIfEffectivelyInvisible"?

[wkorman, 2017/04/27 19:42:18]

Done.

+    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()) {

[trchen, 2017/04/27 00:24:10]

nit: short branch first. i.e.
if (!current_group.Opacity() < kMinimumVisibleOpacity ||
current_group.HasDirectCompositingReasons())
  return false;

[wkorman, 2017/04/27 19:42:18]

Done.

+    // Fast-forward to just past the end of the chunk sequence within this
+    // subgroup.

[trchen, 2017/04/27 00:24:10]

I feel we should DCHECK the current chunk indeed belongs to the current group
(which is guaranteed by caller thus we could skip the first chunk
unconditionally), but it is a bit awkward to write. :/

#if DCHECK_IS_ON()
{
  const EffectPaintPropertyNode* current_effect =
chunk_it->properties.property_tree_state.Effect();
  DCHECK(current_effect == &current_group ||
StrictChildOfAlongPath(&current_group, current_effect));
}
#endif

[wkorman, 2017/04/27 19:42:18]

Done, I added a helper function that made this and below a shared single
function call so we don't need the #if.

+    while (++chunk_it != paint_artifact.PaintChunks().end()) {
+      const EffectPaintPropertyNode* current_effect =
+          chunk_it->properties.property_tree_state.Effect();
+      if (current_effect != &current_group &&
+          !StrictChildOfAlongPath(&current_group, current_effect)) {
+        break;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
 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 (SkipEffectivelyInvisibleChunks(paint_artifact, current_group, chunk_it))

[wkorman, 2017/04/27 00:02:32]

Revised per in person discussion with trchen@ around applying effectively
invisible logic to child chunks. The cost of having to walk to find ancestor via
StrictChildOfAlongPath for each is considered worthwhile as it allows us to
avoid deemed-more-expensive compositor overhead.

+    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.
   // q = average number of trials to find a squash layer or rejected
   //     for overlapping.
   // d = (sum of) the depth of property trees.
   // The analysis as follows:
   // Every paint chunk will be visited by the main loop below for exactly once,
   // except for chunks that enter or exit groups (case B & C below).
   // For normal chunk visit (case A), the only cost is determining squash,
   // which costs O(qd), where d came from "canUpcastTo" and geometry mapping.
   // Subtotal: O(pqd)
   // For group entering and exiting, it could cost O(d) for each group, for
   // searching the shallowest subgroup (strictChildOfAlongPath), thus O(d^2)
   // in total.
   // Also when exiting group, the group may be decomposited and squashed to a
   // previous layer. Again finding the host costs O(qd). Merging would cost O(p)
   // due to copying the chunk list. Subtotal: O((qd + p)d) = O(qd^2 + pd)
   // Assuming p > d, the total complexity would be O(pqd + qd^2 + pd) = O(pqd)
   while (chunk_it != paint_artifact.PaintChunks().end()) {
-    // Look at the effect node of the next chunk. There are 3 possible cases:
+    // Look at the effect node of the next chunk. There are 3 possible
+    // cases:
     // A. The next chunk belongs to the current group but no subgroup.
     // B. The next chunk does not belong to the current group.
     // C. The next chunk belongs to some subgroup of the current group.
     const EffectPaintPropertyNode* chunk_effect =
         chunk_it->properties.property_tree_state.Effect();
+
     if (chunk_effect == &current_group) {
       // Case A: The next chunk belongs to the current group but no subgroup.
       bool is_foreign =
           paint_artifact.GetDisplayItemList()[chunk_it->begin_index]
               .IsForeignLayer();
       pending_layers.push_back(PendingLayer(*chunk_it++, is_foreign));
       if (is_foreign)
         continue;
     } else {
       const EffectPaintPropertyNode* subgroup =
@@ skipping 141 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::ShowDebugData() {
   LOG(ERROR) << LayersAsJSON(kLayerTreeIncludesDebugInfo)
                     ->ToPrettyJSONString()
                     .Utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink