Fix GraphicsLayer under-invalidation checking when interest rect changes

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 74 matching lines @@
     int x;
     int y;
     SkColor oldPixel;
     SkColor newPixel;
 };
 
 struct PaintInvalidationTracking {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     Vector<PaintInvalidationInfo> trackedPaintInvalidations;
     sk_sp<SkPicture> lastPaintedPicture;
+    IntRect lastInterestRect;
     Region paintInvalidationRegionSinceLastPaint;
     Vector<UnderPaintInvalidation> underPaintInvalidations;
 };
 
 typedef HashMap<const GraphicsLayer*, PaintInvalidationTracking> PaintInvalidationTrackingMap;
 static PaintInvalidationTrackingMap& paintInvalidationTrackingMap()
 {
     DEFINE_STATIC_LOCAL(PaintInvalidationTrackingMap, map, ());
     return map;
 }
@@ skipping 225 matching lines @@
 
 void GraphicsLayer::paint(const IntRect* interestRect, GraphicsContext::DisabledMode disabledMode)
 {
     if (paintWithoutCommit(interestRect, disabledMode)) {
         getPaintController().commitNewDisplayItems(offsetFromLayoutObjectWithSubpixelAccumulation());
         if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
             sk_sp<SkPicture> newPicture = capturePicture();
             checkPaintUnderInvalidations(*newPicture);
             PaintInvalidationTracking& tracking = paintInvalidationTrackingMap().add(this, PaintInvalidationTracking()).storedValue->value;
             tracking.lastPaintedPicture = std::move(newPicture);
+            tracking.lastInterestRect = m_previousInterestRect;
             tracking.paintInvalidationRegionSinceLastPaint = Region();
         }
     }
 }
 
 bool GraphicsLayer::paintWithoutCommit(const IntRect* interestRect, GraphicsContext::DisabledMode disabledMode)
 {
     ASSERT(drawsContent());
 
     if (!m_client)
@@ skipping 928 matching lines @@
     if (!drawsContent())
         return;
 
     auto it = paintInvalidationTrackingMap().find(this);
     if (it == paintInvalidationTrackingMap().end())
         return;
     PaintInvalidationTracking& tracking = it->value;
     if (!tracking.lastPaintedPicture)
         return;
 
+    IntRect rect = intersection(tracking.lastInterestRect, interestRect());
+    if (rect.isEmpty())
+        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));
+    oldBitmap.allocPixels(SkImageInfo::MakeN32Premul(rect.width(), rect.height()));
     {
         SkCanvas canvas(oldBitmap);
         canvas.clear(SK_ColorTRANSPARENT);
+        canvas.translate(-rect.x(), -rect.y());
         canvas.drawPicture(tracking.lastPaintedPicture.get());
     }
 
     SkBitmap newBitmap;
-    newBitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height));
+    newBitmap.allocPixels(SkImageInfo::MakeN32Premul(rect.width(), rect.height()));
     {
         SkCanvas canvas(newBitmap);
         canvas.clear(SK_ColorTRANSPARENT);
+        canvas.translate(-rect.x(), -rect.y());
         canvas.drawPicture(&newPicture);
     }
 
     oldBitmap.lockPixels();
     newBitmap.lockPixels();
     int mismatchingPixels = 0;
     static const int maxMismatchesToReport = 50;
-    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 (pixelsDiffer(oldPixel, newPixel) && !tracking.paintInvalidationRegionSinceLastPaint.contains(IntPoint(x, y))) {
+    for (int bitmapY = 0; bitmapY < rect.height(); ++bitmapY) {
+        int layerY = bitmapY + rect.y();
+        for (int bitmapX = 0; bitmapX < rect.width(); ++bitmapX) {
+            int layerX = bitmapX + rect.x();
+            SkColor oldPixel = oldBitmap.getColor(bitmapX, bitmapY);
+            SkColor newPixel = newBitmap.getColor(bitmapX, bitmapY);
+            if (pixelsDiffer(oldPixel, newPixel) && !tracking.paintInvalidationRegionSinceLastPaint.contains(IntPoint(layerX, layerY))) {
                 if (mismatchingPixels < maxMismatchesToReport) {
-                    UnderPaintInvalidation underPaintInvalidation = { x, y, oldPixel, newPixel };
+                    UnderPaintInvalidation underPaintInvalidation = { layerX, layerY, oldPixel, newPixel };
                     tracking.underPaintInvalidations.append(underPaintInvalidation);
-                    LOG(ERROR) << debugName() << " Uninvalidated old/new pixels mismatch at " << x << "," << y << " old:" << std::hex << oldPixel << " new:" << newPixel;
+                    LOG(ERROR) << debugName() << " Uninvalidated old/new pixels mismatch at " << layerX << "," << layerY << " old:" << std::hex << oldPixel << " new:" << newPixel;
                 } else if (mismatchingPixels == maxMismatchesToReport) {
                     LOG(ERROR) << "and more...";
                 }
                 ++mismatchingPixels;
-                *newBitmap.getAddr32(x, y) = SkColorSetARGB(0xFF, 0xA0, 0, 0); // Dark red.
+                *newBitmap.getAddr32(bitmapX, bitmapY) = SkColorSetARGB(0xFF, 0xA0, 0, 0); // Dark red.
             } else {
-                *newBitmap.getAddr32(x, y) = SK_ColorTRANSPARENT;
+                *newBitmap.getAddr32(bitmapX, bitmapY) = SK_ColorTRANSPARENT;
             }
         }
     }
-
     oldBitmap.unlockPixels();
     newBitmap.unlockPixels();
 
     // 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);
+    recorder.beginRecording(rect);
+    recorder.getRecordingCanvas()->drawBitmap(newBitmap, rect.x(), rect.y());
     sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
     getPaintController().appendDebugDrawingAfterCommit(*this, picture, offsetFromLayoutObjectWithSubpixelAccumulation());
 }
 
 } // 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