Add effect node support in PaintArtifactCompositor for layer list mode [1/4]

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/playback/display_item_list.h"
@@ skipping 221 matching lines @@
 
         // Return the last (bottom-most) clip layer.
         return m_clipLayers.last().second;
     }
 
 private:
     using NodeLayerPair = std::pair<const ClipPaintPropertyNode*, cc::Layer*>;
     Vector<NodeLayerPair, 16> m_clipLayers;
 };
 
-scoped_refptr<cc::Layer> foreignLayerForPaintChunk(const PaintArtifact& paintArtifact, const PaintChunk& paintChunk, gfx::Transform transform)
+scoped_refptr<cc::Layer> foreignLayerForPaintChunk(const PaintArtifact& paintArtifact, const PaintChunk& paintChunk, gfx::Vector2dF& layerOffset)
 {
     if (paintChunk.size() != 1)
         return nullptr;
 
     const auto& displayItem = paintArtifact.getDisplayItemList()[paintChunk.beginIndex];
     if (!displayItem.isForeignLayer())
         return nullptr;
 
     const auto& foreignLayerDisplayItem = static_cast<const ForeignLayerDisplayItem&>(displayItem);
+    layerOffset = gfx::Vector2dF(foreignLayerDisplayItem.location().x(), foreignLayerDisplayItem.location().y());
     scoped_refptr<cc::Layer> layer = foreignLayerDisplayItem.layer();
-    transform.Translate(foreignLayerDisplayItem.location().x(), foreignLayerDisplayItem.location().y());
-    layer->SetTransform(transform);
     layer->SetBounds(foreignLayerDisplayItem.bounds());
     layer->SetIsDrawable(true);
     return layer;
 }
 
 static const int kInvalidNodeId = -1;
 static const int kRealRootNodeId = 0;
 static const int kSecondaryRootNodeId = 1;
 static const int kPropertyTreeSequenceNumber = 1;
 
@@ skipping 76 matching lines @@
     }
 
     // TODO(jbroman): This should be incremental.
     m_rootLayer->RemoveAllChildren();
     m_contentLayerClients.clear();
 
     m_contentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
     ClipLayerManager clipLayerManager(m_rootLayer.get());
     for (const PaintChunk& paintChunk : paintArtifact.paintChunks()) {
         cc::Layer* parent;
-        gfx::Transform transform;
-        if (useLayerLists) {
+        if (useLayerLists)
             parent = m_rootLayer.get();
-        } else {
+        else
             parent = clipLayerManager.switchToNewClipLayer(paintChunk.properties.clip.get());
-            // TODO(jbroman): Same as above. This assumes the transform space of the current clip is
-            // an ancestor of the chunk. It is not necessarily true. crbug.com/597156
-            transform = transformToTransformSpace(paintChunk.properties.transform.get(), localTransformSpace(paintChunk.properties.clip.get()));
-        }
 
-        scoped_refptr<cc::Layer> layer = layerForPaintChunk(paintArtifact, paintChunk, transform);
+        gfx::Vector2dF layerOffset;
+        scoped_refptr<cc::Layer> layer = layerForPaintChunk(paintArtifact, paintChunk, layerOffset);
         if (useLayerLists) {
             // This is only good enough to get trivial 2D translations working.
             // We'll need to actually create more cc transform nodes to do any
             // more; then we'll express offset-to-transform-parent relative to
             // that transform node.
             // TODO(jbroman): ^ Do that.
             layer->set_offset_to_transform_parent(
                 transformToTransformSpace(paintChunk.properties.transform.get(), nullptr).To2dTranslation()
-                + layer->transform().To2dTranslation());
+                + layerOffset);
+        } else {
+            // TODO(jbroman): Same as above. This assumes the transform space of the current clip is
+            // an ancestor of the chunk. It is not necessarily true. crbug.com/597156
+            gfx::Transform transform = transformToTransformSpace(paintChunk.properties.transform.get(), localTransformSpace(paintChunk.properties.clip.get()));
+            transform.Translate(layerOffset.x(), layerOffset.y());
+            // If a clip was applied, its origin needs to be cancelled out in
+            // this transform.
+            if (const auto* clip = paintChunk.properties.clip.get()) {
+                FloatPoint offsetDueToClipOffset = clip->clipRect().rect().location();
+                gfx::Transform undoClipOffset;
+                undoClipOffset.Translate(-offsetDueToClipOffset.x(), -offsetDueToClipOffset.y());
+                transform.ConcatTransform(undoClipOffset);
+            }
+            layer->SetTransform(transform);
         }
+        layer->SetDoubleSided(!paintChunk.properties.backfaceHidden);
         layer->SetNeedsDisplay();
         parent->AddChild(layer);
 
         if (useLayerLists) {
             layer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
             layer->SetTransformTreeIndex(kSecondaryRootNodeId);
             layer->SetClipTreeIndex(kSecondaryRootNodeId);
             layer->SetEffectTreeIndex(kSecondaryRootNodeId);
             layer->SetScrollTreeIndex(kSecondaryRootNodeId);
         }
     }
 
     if (useLayerLists) {
         // Mark the property trees as having been rebuilt.
         host->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
         host->property_trees()->needs_rebuild = false;
     }
 }
 
-scoped_refptr<cc::Layer> PaintArtifactCompositor::layerForPaintChunk(const PaintArtifact& paintArtifact, const PaintChunk& paintChunk, gfx::Transform transform)
+scoped_refptr<cc::Layer> PaintArtifactCompositor::layerForPaintChunk(const PaintArtifact& paintArtifact, const PaintChunk& paintChunk, gfx::Vector2dF& layerOffset)
 {
+    DCHECK(paintChunk.size());
+
     // If the paint chunk is a foreign layer, just return that layer.
-    if (scoped_refptr<cc::Layer> foreignLayer = foreignLayerForPaintChunk(paintArtifact, paintChunk, transform))
+    if (scoped_refptr<cc::Layer> foreignLayer = foreignLayerForPaintChunk(paintArtifact, paintChunk, layerOffset))
         return foreignLayer;
 
     // The common case: create a layer for painted content.
     gfx::Rect combinedBounds = enclosingIntRect(paintChunk.bounds);
     scoped_refptr<cc::DisplayItemList> displayList = recordPaintChunk(paintArtifact, paintChunk, combinedBounds);
     OwnPtr<ContentLayerClientImpl> contentLayerClient = adoptPtr(
         new ContentLayerClientImpl(std::move(displayList), gfx::Rect(combinedBounds.size())));
 
-    // Include the offset in the transform, because it needs to apply in
-    // this layer's transform space (whereas layer position applies in its
-    // parent's transform space).
-    gfx::Vector2dF offset = gfx::PointF(combinedBounds.origin()).OffsetFromOrigin();
-    transform.Translate(offset.x(), offset.y());
-
-    // If a clip was applied, its origin needs to be cancelled out in
-    // this transform.
-    if (const auto* clip = paintChunk.properties.clip.get()) {
-        FloatPoint offsetDueToClipOffset = clip->clipRect().rect().location();
-        gfx::Transform undoClipOffset;
-        undoClipOffset.Translate(-offsetDueToClipOffset.x(), -offsetDueToClipOffset.y());
-        transform.ConcatTransform(undoClipOffset);
-    }
-
+    layerOffset = combinedBounds.OffsetFromOrigin();
     scoped_refptr<cc::PictureLayer> layer = cc::PictureLayer::Create(contentLayerClient.get());
     layer->SetBounds(combinedBounds.size());
-    layer->SetTransform(transform);
     layer->SetIsDrawable(true);
-    layer->SetDoubleSided(!paintChunk.properties.backfaceHidden);
     if (paintChunk.knownToBeOpaque)
         layer->SetContentsOpaque(true);
     m_contentLayerClients.append(std::move(contentLayerClient));
     return layer;
 }
 
 } // namespace blink