Check rect under-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 16 matching lines @@
 
 #include "SkImageFilter.h"
 #include "SkMatrix44.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/layers/layer.h"
 #include "platform/DragImage.h"
 #include "platform/JSONValues.h"
 #include "platform/TraceEvent.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/LayoutRect.h"
+#include "platform/geometry/Region.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/CompositorFactory.h"
 #include "platform/graphics/CompositorFilterOperations.h"
 #include "platform/graphics/FirstPaintInvalidationTracking.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/LinkHighlight.h"
 #include "platform/graphics/filters/SkiaImageFilterBuilder.h"
+#include "platform/graphics/paint/DisplayItemCacheSkipper.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/graphics/paint/PaintController.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "platform/text/TextStream.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebFloatPoint.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebLayer.h"
 #include "public/platform/WebPoint.h"
@@ skipping 14 matching lines @@
 
 namespace blink {
 
 static bool s_drawDebugRedFill = true;
 
 struct PaintInvalidationInfo {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     // This is for comparison only. Don't dereference because the client may have died.
     const DisplayItemClient* client;
     String clientDebugName;
-    FloatRect rect;
+    IntRect rect;
     PaintInvalidationReason reason;
 };
 
-typedef HashMap<const GraphicsLayer*, Vector<PaintInvalidationInfo>> PaintInvalidationTrackingMap;
+struct PaintInvalidationTracking {
+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
+    Vector<PaintInvalidationInfo> trackedPaintInvalidations;
+#if DCHECK_IS_ON()
+    RefPtr<SkPicture> lastPaintedPicture;
+    Region paintInvalidationRegionSinceLastPaint;
+#endif
+};
+
+typedef HashMap<const GraphicsLayer*, PaintInvalidationTracking> PaintInvalidationTrackingMap;
 static PaintInvalidationTrackingMap& paintInvalidationTrackingMap()
 {
     DEFINE_STATIC_LOCAL(PaintInvalidationTrackingMap, map, ());
     return map;
 }
 
 PassOwnPtr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerClient* client)
 {
     return adoptPtr(new GraphicsLayer(client));
 }
 
 GraphicsLayer::GraphicsLayer(GraphicsLayerClient* client)
     : m_client(client)
     , m_backgroundColor(Color::transparent)
     , m_opacity(1)
     , m_blendMode(WebBlendModeNormal)
     , m_hasTransformOrigin(false)
     , m_contentsOpaque(false)
     , m_shouldFlattenTransform(true)
     , m_backfaceVisibility(true)
     , m_masksToBounds(false)
     , m_drawsContent(false)
     , m_contentsVisible(true)
     , m_isRootForIsolatedGroup(false)
     , m_hasScrollParent(false)
     , m_hasClipParent(false)
     , m_painted(false)
     , m_textPainted(false)
     , m_imagePainted(false)
+    , m_isTrackingPaintInvalidations(client && client->isTrackingPaintInvalidations())
     , m_paintingPhase(GraphicsLayerPaintAllWithOverflowClip)
     , m_parent(0)
     , m_maskLayer(0)
     , m_contentsClippingMaskLayer(0)
     , m_replicaLayer(0)
     , m_replicatedLayer(0)
     , m_paintCount(0)
     , m_contentsLayer(0)
     , m_contentsLayerId(0)
     , m_scrollableArea(nullptr)
@@ skipping 23 matching lines @@
 
     if (m_replicaLayer)
         m_replicaLayer->setReplicatedLayer(0);
 
     if (m_replicatedLayer)
         m_replicatedLayer->setReplicatedByLayer(0);
 
     removeAllChildren();
     removeFromParent();
 
-    resetTrackedPaintInvalidations();
+    paintInvalidationTrackingMap().remove(this);
     ASSERT(!m_parent);
 }
 
 LayoutRect GraphicsLayer::visualRect() const
 {
     LayoutRect bounds = LayoutRect(FloatPoint(), size());
     bounds.move(offsetFromLayoutObjectWithSubpixelAccumulation());
     return bounds;
 }
 
@@ skipping 145 matching lines @@
     return LayoutSize(offsetFromLayoutObject()) + client()->subpixelAccumulation();
 }
 
 IntRect GraphicsLayer::interestRect()
 {
     return m_previousInterestRect;
 }
 
 void GraphicsLayer::paint(const IntRect* interestRect, GraphicsContext::DisabledMode disabledMode)
 {
-    if (paintWithoutCommit(interestRect, disabledMode))
+    if (paintWithoutCommit(interestRect, disabledMode)) {
         getPaintController().commitNewDisplayItems(offsetFromLayoutObjectWithSubpixelAccumulation());
+#if DCHECK_IS_ON()
+        if (isTrackingOrCheckingPaintInvalidations()) {
+            RefPtr<SkPicture> newPicture = capturePicture();
+            checkUnderPaintInvalidations(*newPicture);
+            PaintInvalidationTracking& tracking = paintInvalidationTrackingMap().add(this, PaintInvalidationTracking()).storedValue->value;
+            tracking.lastPaintedPicture = newPicture;
+            tracking.paintInvalidationRegionSinceLastPaint = Region();
+        }
+#endif
+    }
 }
 
 bool GraphicsLayer::paintWithoutCommit(const IntRect* interestRect, GraphicsContext::DisabledMode disabledMode)
 {
     ASSERT(drawsContent());
 
     if (!m_client)
         return false;
     if (firstPaintInvalidationTrackingEnabled())
         m_debugInfo.clearAnnotatedInvalidateRects();
@@ skipping 10 matching lines @@
         && !getPaintController().cacheIsEmpty()
         && m_previousInterestRect == *interestRect) {
         return false;
     }
 
     GraphicsContext context(getPaintController(), disabledMode);
 
 #ifndef NDEBUG
     if (contentsOpaque() && s_drawDebugRedFill) {
         FloatRect rect(FloatPoint(), size());
-        if (!DrawingRecorder::useCachedDrawingIfPossible(context, *this, DisplayItem::DebugRedFill)) {
-            DrawingRecorder recorder(context, *this, DisplayItem::DebugRedFill, rect);
-            context.fillRect(rect, SK_ColorRED);
-        }
+        DisplayItemCacheSkipper cacheSkipper(context);

[pdr., 2016/06/09 19:21:44]

This change makes sense, but why was it needed for this patch?

[Xianzhu, 2016/06/09 20:47:44]

This is not needed for this patch. Reverted.

+        DrawingRecorder recorder(context, *this, DisplayItem::DebugRedFill, rect);
+        context.fillRect(rect, SK_ColorRED);
     }
 #endif
 
     m_previousInterestRect = *interestRect;
     m_client->paintContents(this, context, m_paintingPhase, *interestRect);
     notifyFirstPaintToClient();
     return true;
 }
 
 void GraphicsLayer::notifyFirstPaintToClient()
@@ skipping 158 matching lines @@
 {
     return m_debugInfo;
 }
 
 WebLayer* GraphicsLayer::contentsLayerIfRegistered()
 {
     clearContentsLayerIfUnregistered();
     return m_contentsLayer;
 }
 
+void GraphicsLayer::setTracksPaintInvalidations(bool tracksPaintInvalidations)
+{
+    resetTrackedPaintInvalidations();
+    m_isTrackingPaintInvalidations = tracksPaintInvalidations;
+}
+
 void GraphicsLayer::resetTrackedPaintInvalidations()
 {
-    paintInvalidationTrackingMap().remove(this);
+    auto it = paintInvalidationTrackingMap().find(this);
+    if (it == paintInvalidationTrackingMap().end())
+        return;
+
+    if (!RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
+        paintInvalidationTrackingMap().remove(it);
+    else
+        it->value.trackedPaintInvalidations.clear();
 }
 
 bool GraphicsLayer::hasTrackedPaintInvalidations() const
 {
     PaintInvalidationTrackingMap::iterator it = paintInvalidationTrackingMap().find(this);
     if (it != paintInvalidationTrackingMap().end())
-        return !it->value.isEmpty();
+        return !it->value.trackedPaintInvalidations.isEmpty();
     return false;
 }
 
-void GraphicsLayer::trackPaintInvalidation(const DisplayItemClient& client, const FloatRect& rect, PaintInvalidationReason reason)
+void GraphicsLayer::trackPaintInvalidation(const DisplayItemClient& client, const IntRect& rect, PaintInvalidationReason reason)
 {
-    // The caller must check isTrackingPaintInvalidations() before calling this method
+    // The caller must check isTrackingOrCheckingPaintInvalidations() before calling this method
     // to avoid constructing the rect unnecessarily.
-    ASSERT(isTrackingPaintInvalidations());
+    DCHECK(isTrackingOrCheckingPaintInvalidations());
 
-    Vector<PaintInvalidationInfo>& infos = paintInvalidationTrackingMap().add(this, Vector<PaintInvalidationInfo>()).storedValue->value;
+    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() && !infos.isEmpty() && infos.last().client == &client)
+    if (rect.isEmpty() && !tracking.trackedPaintInvalidations.isEmpty() && tracking.trackedPaintInvalidations.last().client == &client)
         return;
 
     PaintInvalidationInfo info = { &client, client.debugName(), rect, reason };
-    infos.append(info);
+    tracking.trackedPaintInvalidations.append(info);
+
+#if DCHECK_IS_ON()
+    if (!rect.isEmpty()) {
+        // 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)
 {
     // Sort by rect first, bigger rects before smaller ones.
     if (a.rect.width() != b.rect.width())
         return a.rect.width() > b.rect.width();
     if (a.rect.height() != b.rect.height())
         return a.rect.height() > b.rect.height();
     if (a.rect.x() != b.rect.x())
@@ skipping 152 matching lines @@
 
     if (m_replicaLayer)
         json->setObject("replicaLayer", m_replicaLayer->layerTreeAsJSON(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;
+            Vector<PaintInvalidationInfo>& infos = it->value.trackedPaintInvalidations;
             if (!infos.isEmpty()) {
                 std::sort(infos.begin(), infos.end(), &comparePaintInvalidationInfo);
                 RefPtr<JSONArray> paintInvalidationsJSON = JSONArray::create();
                 for (auto& info : infos) {
                     RefPtr<JSONObject> infoJSON = JSONObject::create();
                     infoJSON->setString("object", info.clientDebugName);
                     if (!info.rect.isEmpty())
                         infoJSON->setArray("rect", rectAsJSONArray(info.rect));
                     infoJSON->setString("reason", paintInvalidationReasonToString(info.reason));
                     paintInvalidationsJSON->pushObject(infoJSON);
@@ skipping 122 matching lines @@
     if (clampedSize.width() < 0 || clampedSize.height() < 0)
         clampedSize = FloatSize();
 
     if (clampedSize == m_size)
         return;
 
     m_size = clampedSize;
 
     m_layer->layer()->setBounds(flooredIntSize(m_size));
     // Note that we don't resize m_contentsLayer. It's up the caller to do that.
-
-#ifndef NDEBUG
-    // The red debug fill and needs to be invalidated if the layer resizes.
-    setDisplayItemsUncached();
-#endif
 }
 
 void GraphicsLayer::setTransform(const TransformationMatrix& transform)
 {
     m_transform = transform;
     platformLayer()->setTransform(TransformationMatrix::toSkMatrix44(m_transform));
 }
 
 void GraphicsLayer::setTransformOrigin(const FloatPoint3D& transformOrigin)
 {
@@ skipping 135 matching lines @@
     if (m_isRootForIsolatedGroup == isolated)
         return;
     m_isRootForIsolatedGroup = isolated;
     platformLayer()->setIsRootForIsolatedGroup(isolated);
 }
 
 void GraphicsLayer::setContentsNeedsDisplay()
 {
     if (WebLayer* contentsLayer = contentsLayerIfRegistered()) {
         contentsLayer->invalidate();
-        if (isTrackingPaintInvalidations())
+        if (isTrackingOrCheckingPaintInvalidations())
             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 (isTrackingPaintInvalidations())
-        trackPaintInvalidation(*this, FloatRect(FloatPoint(), m_size), PaintInvalidationFull);
+    if (isTrackingOrCheckingPaintInvalidations())
+        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 (isTrackingPaintInvalidations())
+    if (isTrackingOrCheckingPaintInvalidations())
         trackPaintInvalidation(client, rect, invalidationReason);
 }
 
 void GraphicsLayer::displayItemClientWasInvalidated(const DisplayItemClient& displayItemClient, PaintInvalidationReason invalidationReason)
 {
     if (!drawsContent())
         return;
 
     getPaintController().displayItemClientWasInvalidated(displayItemClient);
 
-    if (isTrackingPaintInvalidations())
-        trackPaintInvalidation(displayItemClient, FloatRect(), invalidationReason);
+    if (isTrackingOrCheckingPaintInvalidations())
+        trackPaintInvalidation(displayItemClient, IntRect(), invalidationReason);
 }
 
 void GraphicsLayer::setContentsRect(const IntRect& rect)
 {
     if (rect == m_contentsRect)
         return;
 
     m_contentsRect = rect;
     updateContentsRect();
 }
@@ skipping 120 matching lines @@
     if (WebLayer* layer = platformLayer())
         layer->setElementId(id);
 }
 
 void GraphicsLayer::setCompositorMutableProperties(uint32_t properties)
 {
     if (WebLayer* layer = platformLayer())
         layer->setCompositorMutableProperties(properties);
 }
 
+#if DCHECK_IS_ON()
+
+PassRefPtr<SkPicture> GraphicsLayer::capturePicture()
+{
+    if (!drawsContent())
+        return nullptr;
+
+    IntSize intSize = expandedIntSize(size());
+    GraphicsContext graphicsContext(getPaintController());
+    graphicsContext.beginRecording(IntRect(IntPoint(0, 0), intSize));
+    getPaintController().paintArtifact().replay(graphicsContext);

[pdr., 2016/06/09 19:21:44]

Why look at the pixels instead of just comparing the display item sizes and
types?

[Xianzhu, 2016/06/09 20:47:44]

Several reasons:

1. For incremental invalidation which just invalidate part of an display item,
we expect that only the incremental part of the display item changed. It seems
not feasible to check if a display item didn't change outside a certain rect
without rasterizing it.

2. We need to trust display item's visualRect to check if a changed display item
is covered by the paint invalidation rects. Because visual rects and paint
invalidation rects are actually from the same code path, we'll miss bugs about
paint invalidation rect calculation.

3. Sometimes we need rasterization invalidation when the display item itself
doesn't change but its location changes. We can find display items whose
location changed and check if they are covered by paint invalidation rects, but
this will have the same problem as 2.
 

+    return graphicsContext.endRecording();
+}
+
+void GraphicsLayer::checkUnderPaintInvalidations(const SkPicture& newPicture)
+{
+    if (!drawsContent())
+        return;
+
+    auto it = paintInvalidationTrackingMap().find(this);
+    if (it == paintInvalidationTrackingMap().end())
+        return;
+    const PaintInvalidationTracking& tracking = it->value;
+    if (!tracking.lastPaintedPicture)
+        return;
+
+    SkBitmap oldBitmap;
+    int width = static_cast<int>(ceilf(std::min(tracking.lastPaintedPicture->cullRect().width(), newPicture.cullRect().width())));
+    int height = static_cast<int>(ceilf(std::min(tracking.lastPaintedPicture->cullRect().height(), newPicture.cullRect().height())));
+    oldBitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height));
+    SkCanvas(oldBitmap).drawPicture(tracking.lastPaintedPicture.get());
+
+    SkBitmap newBitmap;
+    newBitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height));
+    SkCanvas(newBitmap).drawPicture(&newPicture);
+
+    oldBitmap.lockPixels();
+    newBitmap.lockPixels();
+    int mismatchingPixels = 0;
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < width; ++x) {
+            SkColor oldPixel = oldBitmap.getColor(x, y);
+            SkColor newPixel = newBitmap.getColor(x, y);
+            if (oldPixel != newPixel && !tracking.paintInvalidationRegionSinceLastPaint.contains(IntPoint(x, y))) {
+                if (mismatchingPixels < 50)
+                    LOG(ERROR) << debugName() << " Uninvalidated old/new pixels mismatch at " << x << "," << y << " old:" << std::hex << oldPixel << " new:" << newPixel;
+                else if (mismatchingPixels == 50)
+                    LOG(ERROR) << "and more...";
+                ++mismatchingPixels;
+                *newBitmap.getAddr32(x, y) = SK_ColorRED;
+            } else {
+                *newBitmap.getAddr32(x, y) = SK_ColorTRANSPARENT;
+            }
+        }
+    }
+
+    oldBitmap.unlockPixels();
+    newBitmap.unlockPixels();
+
+    // Crash in layout test paint invalidation tracking mode if slimmingPaintUnderInvalidationChecking is not enabled.
+    if (!RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
+        CHECK(!mismatchingPixels) << "Run chrome/content_shell with --enable-blink-features=slimmingPaintUnderInvalidationChecking to visualize under-invalidations";
+
+    // Visualize under-invalidations by overlaying the new bitmap (containing red pixels indicating under-invalidations,
+    // and transparent pixels otherwise) onto the painting.
+    SkPictureRecorder recorder;
+    recorder.beginRecording(width, height);
+    recorder.getRecordingCanvas()->drawBitmap(newBitmap, 0, 0);
+    RefPtr<SkPicture> picture = fromSkSp(recorder.finishRecordingAsPicture());
+    getPaintController().appendDebugDrawingAfterCommit(*this, picture, offsetFromLayoutObjectWithSubpixelAccumulation());
+}
+
+#endif // DCHECK_IS_ON()
+
 } // namespace blink
 
 #ifndef NDEBUG
 void showGraphicsLayerTree(const blink::GraphicsLayer* layer)
 {
     if (!layer) {
         fprintf(stderr, "Cannot showGraphicsLayerTree for (nil).\n");
         return;
     }
 
     String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
     fprintf(stderr, "%s\n", output.utf8().data());
 }
 #endif