FOR DISCUSSION: Implement indirect compositing reasons for effect nodes.

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 <algorithm>
 #include <memory>
 #include <utility>
 #include "cc/layers/content_layer_client.h"
@@ skipping 556 matching lines @@
     }
   }
 
   newContentLayerClients.push_back(std::move(contentLayerClient));
   return ccPictureLayer;
 }
 
 bool PaintArtifactCompositor::canMergeInto(
     const PaintArtifact& paintArtifact,
     const PaintChunk& newChunk,
-    const PendingLayer& candidatePendingLayer) {
+    const PendingLayer& candidatePendingLayer,
+    const HashSet<const EffectPaintPropertyNode*>* compositedEffectNodes) {
   const PaintChunk& pendingLayerFirstChunk =
       *candidatePendingLayer.paintChunks[0];
   if (paintArtifact.getDisplayItemList()[newChunk.beginIndex].isForeignLayer())
     return false;
 
   if (paintArtifact.getDisplayItemList()[pendingLayerFirstChunk.beginIndex]
           .isForeignLayer())
     return false;
 
   if (newChunk.properties.backfaceHidden !=
       pendingLayerFirstChunk.properties.backfaceHidden)
     return false;
 
   DCHECK_GE(candidatePendingLayer.paintChunks.size(), 1u);
   PropertyTreeStateIterator iterator(newChunk.properties.propertyTreeState);
   for (const PropertyTreeState* currentState =
            &newChunk.properties.propertyTreeState;
        currentState; currentState = iterator.next()) {
     if (*currentState == candidatePendingLayer.propertyTreeState)
       return true;
     if (currentState->hasDirectCompositingReasons())
       return false;
+    if (compositedEffectNodes &&
+        compositedEffectNodes->find(currentState->effect()) !=
+            compositedEffectNodes->end()) {

[trchen, 2017/03/01 23:02:59]

I think this line will over-composite many of the chunks.

Chunk only needs compositing if the state switch across a compositing boundary,
but is okay to have a node that is right on the boundary. This should fix it:

if (currentState->innerMostNode() == Effect &&
    compositedEffectNodes &&
    compositedEffectNodes->find(currentState->effect()) !=
        compositedEffectNodes->end()) {

+      LOG(ERROR) << "newly composited";
+      return false;
+    }
   }
   return false;
 }
 
 bool PaintArtifactCompositor::mightOverlap(
     const PaintChunk& paintChunk,
     const PendingLayer& candidatePendingLayer,
     GeometryMapper& geometryMapper) {
   PropertyTreeState rootPropertyTreeState(TransformPaintPropertyNode::root(),
                                           ClipPaintPropertyNode::root(),
@@ skipping 41 matching lines @@
     if (bounds.size() != paintChunk.bounds.size())
       knownToBeOpaque = false;
     else
       knownToBeOpaque = paintChunk.knownToBeOpaque;
   }
 }
 
 void PaintArtifactCompositor::collectPendingLayers(
     const PaintArtifact& paintArtifact,
     Vector<PendingLayer>& pendingLayers,
-    GeometryMapper& geometryMapper) {
+    GeometryMapper& geometryMapper,
+    const HashSet<const EffectPaintPropertyNode*>& compositedEffectNodes) {
   // n = # of paint chunks. Memoizing canMergeInto() can get it to O(n^2), and
   // other heuristics can make worst-case behavior better.
   for (const PaintChunk& paintChunk : paintArtifact.paintChunks()) {
     bool createNew = true;
     for (Vector<PendingLayer>::reverse_iterator candidatePendingLayer =
              pendingLayers.rbegin();
          candidatePendingLayer != pendingLayers.rend();
          ++candidatePendingLayer) {
-      if (canMergeInto(paintArtifact, paintChunk, *candidatePendingLayer)) {
+      if (canMergeInto(paintArtifact, paintChunk, *candidatePendingLayer,
+                       &compositedEffectNodes)) {
         candidatePendingLayer->add(paintChunk, &geometryMapper);
         createNew = false;
         break;
       }
       if (mightOverlap(paintChunk, *candidatePendingLayer, geometryMapper)) {
         break;
       }
     }
     if (createNew)
       pendingLayers.push_back(PendingLayer(paintChunk));
   }
 }
 
+static void addEffectNodesUpToRoot(
+    const PaintChunk& paintChunk,
+    HashSet<const EffectPaintPropertyNode*>& compositedEffectNodes) {
+  const EffectPaintPropertyNode* effect =
+      paintChunk.properties.propertyTreeState.effect();
+  while (effect) {
+    compositedEffectNodes.insert(effect);
+    effect = effect->parent();
+  }
+}
+
+static void checkEffectNodesUpToRoot(
+    const PaintChunk& paintChunk,
+    unsigned currentIndex,
+    HashSet<const EffectPaintPropertyNode*>& compositedEffectNodes,
+    HashMap<const EffectPaintPropertyNode*, unsigned>& effectNodeLayerIndex) {
+  const EffectPaintPropertyNode* effect =
+      paintChunk.properties.propertyTreeState.effect();
+  while (effect) {
+    auto it = effectNodeLayerIndex.find(effect);
+    if (it != effectNodeLayerIndex.end() && it->value != currentIndex)
+      compositedEffectNodes.insert(effect);
+    else
+      effectNodeLayerIndex.set(effect, currentIndex);
+    effect = effect->parent();
+  }
+}
+
+void PaintArtifactCompositor::collectCompositedEffectNodes(
+    const Vector<PendingLayer>& pendingLayers,
+    HashSet<const EffectPaintPropertyNode*>& compositedEffectNodes) {
+  HashMap<const EffectPaintPropertyNode*, unsigned> effectNodeLayerIndex;
+  for (unsigned currentIndex = 0; currentIndex < pendingLayers.size();
+       ++currentIndex) {
+    const PendingLayer& pendingLayer = pendingLayers[currentIndex];
+    for (const auto* paintChunk : pendingLayer.paintChunks) {
+      if (paintChunk->properties.propertyTreeState
+              .hasDirectCompositingReasons()) {

[trchen, 2017/03/01 23:02:59]

propertyTreeState.hasDirectCompositingReasons() only look at the innermost node.
There can be compositing reason in the chain between chunk state and the
effect's input space. For example:

<div style="opacity:0.5;">
  <div style="will-change:transform;">
    <div style="overflow:hidden;">Chunk</div>
  </div>
</div>

We also want to check the output space of each effect in the chain, for example:

<div style="opacity:0.5">
  <div style="will-change:transform;">
    <div style="overflow:scroll">
      <div style="opacity:0.5">Chunk</div>
    </div>
  </div>
</div>

+        addEffectNodesUpToRoot(*paintChunk, compositedEffectNodes);
+      } else {
+        checkEffectNodesUpToRoot(*paintChunk, currentIndex,
+                                 compositedEffectNodes, effectNodeLayerIndex);
+      }
+    }
+  }
+}
+
 void PaintArtifactCompositor::update(
     const PaintArtifact& paintArtifact,
     RasterInvalidationTrackingMap<const PaintChunk>* rasterChunkInvalidations,
     bool storeDebugInfo,
     GeometryMapper& geometryMapper) {
 #ifndef NDEBUG
   storeDebugInfo = true;
 #endif
 
   DCHECK(m_rootLayer);
@@ skipping 10 matching lines @@
 
   m_rootLayer->RemoveAllChildren();
 
   m_rootLayer->set_property_tree_sequence_number(sPropertyTreeSequenceNumber);
 
   PropertyTreeManager propertyTreeManager(*layerTreeHost->property_trees(),
                                           m_rootLayer.get(),
                                           sPropertyTreeSequenceNumber);
 
   Vector<PendingLayer, 0> pendingLayers;
-  collectPendingLayers(paintArtifact, pendingLayers, geometryMapper);
+  {
+    HashSet<const EffectPaintPropertyNode*> compositedEffectNodes;
+    Vector<PendingLayer, 0> tentativePendingLayers;
+    LOG(ERROR) << "first pass";
+    collectPendingLayers(paintArtifact, tentativePendingLayers, geometryMapper,
+                         compositedEffectNodes);
+    collectCompositedEffectNodes(tentativePendingLayers, compositedEffectNodes);
+    LOG(ERROR) << "# composited effect nodes: " << compositedEffectNodes.size();
+    LOG(ERROR) << "second pass";
+    collectPendingLayers(paintArtifact, pendingLayers, geometryMapper,
+                         compositedEffectNodes);
+  }
 
   Vector<std::unique_ptr<ContentLayerClientImpl>> newContentLayerClients;
   newContentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
   for (const PendingLayer& pendingLayer : pendingLayers) {
     gfx::Vector2dF layerOffset;
     scoped_refptr<cc::Layer> layer = compositedLayerForPendingLayer(
         paintArtifact, pendingLayer, layerOffset, newContentLayerClients,
         rasterChunkInvalidations, storeDebugInfo, geometryMapper);
 
     const auto* transform = pendingLayer.propertyTreeState.transform();
@@ skipping 34 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink