Let FrameView track object paint invalidations

third_party/WebKit/Source/platform/graphics/GraphicsLayer.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 575 matching lines @@
 bool GraphicsLayer::hasTrackedPaintInvalidations() const
 {
     PaintInvalidationTrackingMap::iterator it = paintInvalidationTrackingMap().find(this);
     if (it != paintInvalidationTrackingMap().end())
         return !it->value.trackedPaintInvalidations.isEmpty();
     return false;
 }
 
 void GraphicsLayer::trackPaintInvalidation(const DisplayItemClient& client, const IntRect& rect, PaintInvalidationReason reason)
 {
-    // The caller must check isTrackingOrCheckingPaintInvalidations() before calling this method

[chrishtr, 2016/06/13 20:18:52]

This method now gets called in more scenarios?

[Xianzhu, 2016/06/13 20:52:01]

In less scenarios. Now all the callers have rect ready, so checking
isTrackingOrCheckingPaintInvalidation() before calling trackPaintInvalidation()
won't save much cost.

[Xianzhu, 2016/06/16 19:06:14]

I meant we track paint invalidations in less scenarios: now only for rect paint
invalidation here.

-    // to avoid constructing the rect unnecessarily.
-    DCHECK(isTrackingOrCheckingPaintInvalidations());
+    if (!isTrackingOrCheckingPaintInvalidations() || rect.isEmpty())
+        return;
 
     PaintInvalidationTracking& tracking = paintInvalidationTrackingMap().add(this, PaintInvalidationTracking()).storedValue->value;
-    // Omit the entry for trackObjectPaintInvalidation() if the last entry is for the same client.
-    // This is to avoid duplicated entries for setNeedsDisplayInRect() and trackObjectPaintInvalidation().
-    if (rect.isEmpty() && !tracking.trackedPaintInvalidations.isEmpty() && tracking.trackedPaintInvalidations.last().client == &client)
-        return;
-
     PaintInvalidationInfo info = { &client, client.debugName(), rect, reason };
     tracking.trackedPaintInvalidations.append(info);
 
 #if DCHECK_IS_ON()
-    if (!rect.isEmpty() && RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
         // TODO(crbug.com/496260): Some antialiasing effects overflows the paint invalidation rect.
         IntRect r = rect;
         r.inflate(1);
         tracking.paintInvalidationRegionSinceLastPaint.unite(r);
     }
 #endif
 }
 
 static bool comparePaintInvalidationInfo(const PaintInvalidationInfo& a, const PaintInvalidationInfo& b)
 {
@@ skipping 87 matching lines @@
     return array;
 }
 
 static String pointerAsString(const void* ptr)
 {
     TextStream ts;
     ts << ptr;
     return ts.release();
 }
 
-PassRefPtr<JSONObject> GraphicsLayer::layerTreeAsJSON(LayerTreeFlags flags, RenderingContextMap& renderingContextMap) const
+PassRefPtr<JSONObject> GraphicsLayer::layerTreeAsJSON(LayerTreeFlags flags) const
+{
+    RenderingContextMap renderingContextMap;
+    return layerTreeAsJSONInternal(flags, renderingContextMap);
+}
+
+PassRefPtr<JSONObject> GraphicsLayer::layerTreeAsJSONInternal(LayerTreeFlags flags, RenderingContextMap& renderingContextMap) const
 {
     RefPtr<JSONObject> json = JSONObject::create();
 
-    if (flags & LayerTreeIncludesDebugInfo) {
+    if (flags & LayerTreeIncludesDebugInfo)
         json->setString("this", pointerAsString(this));
-        json->setString("debugName", m_client->debugName(this));
-    }
+
+    json->setString("name", debugName());

[Xianzhu, 2016/06/13 20:52:01]

This will help us understand the relationship between the layers and the layout
objects in the tree dump.

 
     if (m_position != FloatPoint())
         json->setArray("position", pointAsJSONArray(m_position));
 
     if (m_hasTransformOrigin && m_transformOrigin != FloatPoint3D(m_size.width() * 0.5f, m_size.height() * 0.5f, 0))
         json->setArray("transformOrigin", pointAsJSONArray(m_transformOrigin));
 
     if (m_size != IntSize())
         json->setArray("bounds", sizeAsJSONArray(m_size));
 
@@ skipping 35 matching lines @@
     if (flags & LayerTreeIncludesDebugInfo)
         json->setString("client", pointerAsString(m_client));
 
     if (m_backgroundColor.alpha())
         json->setString("backgroundColor", m_backgroundColor.nameForLayoutTreeAsText());
 
     if (!m_transform.isIdentity())
         json->setArray("transform", transformAsJSONArray(m_transform));
 
     if (m_replicaLayer)
-        json->setObject("replicaLayer", m_replicaLayer->layerTreeAsJSON(flags, renderingContextMap));
+        json->setObject("replicaLayer", m_replicaLayer->layerTreeAsJSONInternal(flags, renderingContextMap));
 
     if (m_replicatedLayer)
         json->setString("replicatedLayer", flags & LayerTreeIncludesDebugInfo ? pointerAsString(m_replicatedLayer) : "");
 
     PaintInvalidationTrackingMap::iterator it = paintInvalidationTrackingMap().find(this);
     if (it != paintInvalidationTrackingMap().end()) {
         if (flags & LayerTreeIncludesPaintInvalidations) {
             Vector<PaintInvalidationInfo>& infos = it->value.trackedPaintInvalidations;
             if (!infos.isEmpty()) {
                 std::sort(infos.begin(), infos.end(), &comparePaintInvalidationInfo);
@@ skipping 63 matching lines @@
         for (size_t i = 0; i < kNumberOfSquashingDisallowedReasons; ++i) {
             if (m_debugInfo.getSquashingDisallowedReasons() & kSquashingDisallowedReasonStringMap[i].reason)
                 squashingDisallowedReasonsJSON->pushString(debug ? kSquashingDisallowedReasonStringMap[i].description : kSquashingDisallowedReasonStringMap[i].shortName);
         }
         json->setArray("squashingDisallowedReasons", squashingDisallowedReasonsJSON);
     }
 
     if (m_children.size()) {
         RefPtr<JSONArray> childrenJSON = JSONArray::create();
         for (size_t i = 0; i < m_children.size(); i++)
-            childrenJSON->pushObject(m_children[i]->layerTreeAsJSON(flags, renderingContextMap));
+            childrenJSON->pushObject(m_children[i]->layerTreeAsJSONInternal(flags, renderingContextMap));
         json->setArray("children", childrenJSON);
     }
 
     return json;
 }
 
 String GraphicsLayer::layerTreeAsText(LayerTreeFlags flags) const
 {
-    RenderingContextMap renderingContextMap;
-    RefPtr<JSONObject> json = layerTreeAsJSON(flags, renderingContextMap);
-    return json->toPrettyJSONString();
+    return layerTreeAsJSON(flags)->toPrettyJSONString();
 }
 
 static const cc::Layer* ccLayerForWebLayer(const WebLayer* webLayer)
 {
     return webLayer ? webLayer->ccLayer() : nullptr;
 }
 
 String GraphicsLayer::debugName(cc::Layer* layer) const
 {
     String name;
@@ skipping 210 matching lines @@
     if (m_isRootForIsolatedGroup == isolated)
         return;
     m_isRootForIsolatedGroup = isolated;
     platformLayer()->setIsRootForIsolatedGroup(isolated);
 }
 
 void GraphicsLayer::setContentsNeedsDisplay()
 {
     if (WebLayer* contentsLayer = contentsLayerIfRegistered()) {
         contentsLayer->invalidate();
-        if (isTrackingOrCheckingPaintInvalidations())
-            trackPaintInvalidation(*this, m_contentsRect, PaintInvalidationFull);
+        trackPaintInvalidation(*this, m_contentsRect, PaintInvalidationFull);
     }
 }
 
 void GraphicsLayer::setNeedsDisplay()
 {
     if (!drawsContent())
         return;
 
     // TODO(chrishtr): stop invalidating the rects once FrameView::paintRecursively does so.
     m_layer->layer()->invalidate();
     for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->invalidate();
     getPaintController().invalidateAll();
 
-    if (isTrackingOrCheckingPaintInvalidations())
-        trackPaintInvalidation(*this, IntRect(IntPoint(), expandedIntSize(m_size)), PaintInvalidationFull);
+    trackPaintInvalidation(*this, IntRect(IntPoint(), expandedIntSize(m_size)), PaintInvalidationFull);
 }
 
 void GraphicsLayer::setNeedsDisplayInRect(const IntRect& rect, PaintInvalidationReason invalidationReason, const DisplayItemClient& client)
 {
     if (!drawsContent())
         return;
 
     m_layer->layer()->invalidateRect(rect);
     if (firstPaintInvalidationTrackingEnabled())
         m_debugInfo.appendAnnotatedInvalidateRect(rect, invalidationReason);
     for (size_t i = 0; i < m_linkHighlights.size(); ++i)
         m_linkHighlights[i]->invalidate();
 
-    if (isTrackingOrCheckingPaintInvalidations())
-        trackPaintInvalidation(client, rect, invalidationReason);
-}
-
-void GraphicsLayer::displayItemClientWasInvalidated(const DisplayItemClient& displayItemClient, PaintInvalidationReason invalidationReason)
-{
-    if (!drawsContent())
-        return;
-
-    getPaintController().displayItemClientWasInvalidated(displayItemClient);
-
-    if (isTrackingOrCheckingPaintInvalidations())
-        trackPaintInvalidation(displayItemClient, IntRect(), invalidationReason);
+    trackPaintInvalidation(client, rect, invalidationReason);
 }
 
 void GraphicsLayer::setContentsRect(const IntRect& rect)
 {
     if (rect == m_contentsRect)
         return;
 
     m_contentsRect = rect;
     updateContentsRect();
 }
@@ skipping 225 matching lines @@
 {
     if (!layer) {
         fprintf(stderr, "Cannot showGraphicsLayerTree for (nil).\n");
         return;
     }
 
     String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
     fprintf(stderr, "%s\n", output.utf8().data());
 }
 #endif