Add optional debugging output of what paint chunks go into what layers.

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 59 matching lines @@
   ContentLayerClientImpl(DisplayItem::Id paintChunkId)
       : m_id(paintChunkId),
         m_debugName(paintChunkId.client.debugName()),
         m_ccPictureLayer(cc::PictureLayer::Create(this)) {}
 
   void SetDisplayList(scoped_refptr<cc::DisplayItemList> ccDisplayItemList) {
     m_ccDisplayItemList = std::move(ccDisplayItemList);
   }
   void SetPaintableRegion(gfx::Rect region) { m_paintableRegion = region; }
 
+  void addPaintChunkDebugData(std::unique_ptr<JSONArray> json) {
+    m_paintChunkDebugData.append(std::move(json));
+  }
+  void clearPaintChunkDebugData() { m_paintChunkDebugData.clear(); }
+
   // cc::ContentLayerClient
   gfx::Rect PaintableRegion() override { return m_paintableRegion; }
   scoped_refptr<cc::DisplayItemList> PaintContentsToDisplayList(
       PaintingControlSetting) override {
     return m_ccDisplayItemList;
   }
   bool FillsBoundsCompletely() const override { return false; }
   size_t GetApproximateUnsharedMemoryUsage() const override {
     // TODO(jbroman): Actually calculate memory usage.
     return 0;
@@ skipping 33 matching lines @@
 
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
       // TODO(crbug.com/496260): Some antialiasing effects overflow the paint
       // invalidation rect.
       IntRect r = rasterInvalidationInfo->rect;
       r.inflate(1);
       tracking.rasterInvalidationRegionSinceLastPaint.unite(r);
     }
   }
 
-  std::unique_ptr<JSONObject> layerAsJSON() {
+  std::unique_ptr<JSONObject> layerAsJSON(LayerTreeFlags flags) {
     std::unique_ptr<JSONObject> json = JSONObject::create();
     json->setString("name", m_debugName);
     IntSize bounds(m_ccPictureLayer->bounds().width(),
                    m_ccPictureLayer->bounds().height());
     if (!bounds.isEmpty())
       json->setArray("bounds", sizeAsJSONArray(bounds));
     json->setBoolean("contentsOpaque", m_ccPictureLayer->contents_opaque());
     json->setBoolean("drawsContent", m_ccPictureLayer->DrawsContent());
 
+    if (flags & LayerTreeIncludesDebugInfo) {
+      std::unique_ptr<JSONArray> paintChunkContentsArray = JSONArray::create();
+      for (const auto& debugData : m_paintChunkDebugData) {
+        paintChunkContentsArray->pushValue(debugData->clone());
+      }
+      json->setArray("paintChunkContents", std::move(paintChunkContentsArray));
+    }
+
     ccLayersRasterInvalidationTrackingMap().asJSON(m_ccPictureLayer.get(),
                                                    json.get());
     return json;
   }
 
   scoped_refptr<cc::PictureLayer> ccPictureLayer() { return m_ccPictureLayer; }
 
   bool matches(const PaintChunk& paintChunk) {
     return paintChunk.id && m_id == *paintChunk.id;
   }
 
  private:
   PaintChunk::Id m_id;
   String m_debugName;
   scoped_refptr<cc::PictureLayer> m_ccPictureLayer;
   scoped_refptr<cc::DisplayItemList> m_ccDisplayItemList;
   gfx::Rect m_paintableRegion;
+  Vector<std::unique_ptr<JSONArray>> m_paintChunkDebugData;
 };
 
 PaintArtifactCompositor::PaintArtifactCompositor() {
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return;
   m_rootLayer = cc::Layer::Create();
   m_webLayer = Platform::current()->compositorSupport()->createLayerFromCCLayer(
       m_rootLayer.get());
   m_isTrackingRasterInvalidations = false;
 }
@@ skipping 16 matching lines @@
     if (client->hasTrackedRasterInvalidations())
       return true;
   }
   return false;
 }
 
 std::unique_ptr<JSONObject> PaintArtifactCompositor::layersAsJSON(
     LayerTreeFlags flags) const {
   std::unique_ptr<JSONArray> layersJSON = JSONArray::create();
   for (const auto& client : m_contentLayerClients) {
-    layersJSON->pushObject(client->layerAsJSON());
+    layersJSON->pushObject(client->layerAsJSON(flags));
   }
   std::unique_ptr<JSONObject> json = JSONObject::create();
   json->setArray("layers", std::move(layersJSON));
   return json;
 }
 
 namespace {
 
 static gfx::Rect largeRect(-200000, -200000, 400000, 400000);
 
@@ skipping 87 matching lines @@
       paintChunk.id
           ? *paintChunk.id
           : paintArtifact.getDisplayItemList()[paintChunk.beginIndex].getId()));
 }
 
 scoped_refptr<cc::Layer> PaintArtifactCompositor::layerForPaintChunk(
     const PaintArtifact& paintArtifact,
     const PaintChunk& paintChunk,
     gfx::Vector2dF& layerOffset,
     Vector<std::unique_ptr<ContentLayerClientImpl>>& newContentLayerClients,
-    RasterInvalidationTracking* tracking) {
+    RasterInvalidationTracking* tracking,
+    bool storeDebugInfo) {
   DCHECK(paintChunk.size());
 
   // If the paint chunk is a foreign layer, just return that layer.
   if (scoped_refptr<cc::Layer> foreignLayer =
           foreignLayerForPaintChunk(paintArtifact, paintChunk, layerOffset))
     return foreignLayer;
 
   // The common case: create or reuse a PictureLayer for painted content.
   std::unique_ptr<ContentLayerClientImpl> contentLayerClient =
       clientForPaintChunk(paintChunk, paintArtifact);
 
   gfx::Rect combinedBounds = enclosingIntRect(paintChunk.bounds);
   scoped_refptr<cc::DisplayItemList> displayList =
       recordPaintChunk(paintArtifact, paintChunk, combinedBounds);
   contentLayerClient->SetDisplayList(std::move(displayList));
   contentLayerClient->SetPaintableRegion(gfx::Rect(combinedBounds.size()));
 
   layerOffset = combinedBounds.OffsetFromOrigin();
   scoped_refptr<cc::PictureLayer> ccPictureLayer =
       contentLayerClient->ccPictureLayer();
   ccPictureLayer->SetBounds(combinedBounds.size());
   ccPictureLayer->SetIsDrawable(true);
   if (paintChunk.knownToBeOpaque)
     ccPictureLayer->SetContentsOpaque(true);
   DCHECK(!tracking ||
          tracking->trackedRasterInvalidations.size() ==
              paintChunk.rasterInvalidationRects.size());
+
+  contentLayerClient->clearPaintChunkDebugData();
+  if (storeDebugInfo) {
+    contentLayerClient->addPaintChunkDebugData(
+        paintArtifact.getDisplayItemList().subsequenceAsJSON(
+            paintChunk.beginIndex, paintChunk.endIndex,
+            DisplayItemList::SkipNonDrawings |
+                DisplayItemList::ShownOnlyDisplayItemTypes));
+  }
+
   for (unsigned index = 0; index < paintChunk.rasterInvalidationRects.size();
        ++index) {
     IntRect rect(enclosingIntRect(paintChunk.rasterInvalidationRects[index]));
     gfx::Rect ccInvalidationRect(rect.x(), rect.y(), std::max(0, rect.width()),
                                  std::max(0, rect.height()));
     // Raster paintChunk.rasterInvalidationRects is in the space of the
     // containing transform node, so need to subtract off the layer offset.
     ccInvalidationRect.Offset(-combinedBounds.OffsetFromOrigin());
     contentLayerClient->setNeedsDisplayRect(
         ccInvalidationRect,
@@ skipping 419 matching lines @@
   dummyLayer->SetTransformTreeIndex(kSecondaryRootNodeId);
   dummyLayer->SetClipTreeIndex(outputClipId);
   dummyLayer->SetEffectTreeIndex(effectNode.id);
   dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
 }
 
 }  // namespace
 
 void PaintArtifactCompositor::update(
     const PaintArtifact& paintArtifact,
-    RasterInvalidationTrackingMap<const PaintChunk>* rasterChunkInvalidations) {
+    RasterInvalidationTrackingMap<const PaintChunk>* rasterChunkInvalidations,
+    bool storeDebugInfo) {
   DCHECK(m_rootLayer);
 
   cc::LayerTree* layerTree = m_rootLayer->GetLayerTree();
 
   // The tree will be null after detaching and this update can be ignored.
   // See: WebViewImpl::detachPaintArtifactCompositor().
   if (!layerTree)
     return;
 
   if (m_extraDataForTestingEnabled)
     m_extraDataForTesting = WTF::wrapUnique(new ExtraDataForTesting);
 
   m_rootLayer->RemoveAllChildren();
   m_rootLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
 
   PropertyTreeManager propertyTreeManager(*layerTree->property_trees(),
                                           m_rootLayer.get());
 
   Vector<std::unique_ptr<ContentLayerClientImpl>> newContentLayerClients;
   newContentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
   for (const PaintChunk& paintChunk : paintArtifact.paintChunks()) {
     gfx::Vector2dF layerOffset;
     scoped_refptr<cc::Layer> layer = layerForPaintChunk(
         paintArtifact, paintChunk, layerOffset, newContentLayerClients,
         rasterChunkInvalidations ? rasterChunkInvalidations->find(&paintChunk)
-                                 : nullptr);
+                                 : nullptr,
+        storeDebugInfo);
 
     int transformId = propertyTreeManager.compositorIdForTransformNode(
         paintChunk.properties.propertyTreeState.transform());
     int scrollId = propertyTreeManager.compositorIdForScrollNode(
         paintChunk.properties.propertyTreeState.scroll());
     int clipId = propertyTreeManager.compositorIdForClipNode(
         paintChunk.properties.propertyTreeState.clip());
     int effectId = propertyTreeManager.switchToEffectNode(
         *paintChunk.properties.propertyTreeState.effect());
 
@@ skipping 23 matching lines @@
   m_contentLayerClients.clear();
   m_contentLayerClients.swap(newContentLayerClients);
 
   // Mark the property trees as having been rebuilt.
   layerTree->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
   layerTree->property_trees()->needs_rebuild = false;
   layerTree->property_trees()->ResetCachedData();
 }
 
 }  // namespace blink