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 481 matching lines @@
   // 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. If the chunk has
+    // effectively-invisible opacity we skip it. Otherwise, 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();
+
+    // TODO(wkorman): Do we need to check blend mode, mask, or filter to skip

[wkorman, 2017/04/24 19:49:38]

Seeking your thought on this comment as I haven't thought deeply about it and
plan to review once I see CQ dry run results. If we pass all tests we're
probably ok as is.

+    // only when appropriate? See also PaintLayer::IsTransparent() which was
+    // previously incorporated via PaintLayer::PaintsWithTransparency().
+
+    // Skip paint chunks that are effectively invisible due to opacity. 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 (chunk_effect->Opacity() < kMinimumVisibleOpacity) {
+      chunk_it++;
+      continue;
+    }
+
     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