Reland Compile under-invalidation checking in all builds

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 62 matching lines @@
 
 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;
     IntRect rect;
     PaintInvalidationReason reason;
 };
 
-#if DCHECK_IS_ON()
 struct UnderPaintInvalidation {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     int x;
     int y;
     SkColor oldPixel;
     SkColor newPixel;
 };
-#endif
 
 struct PaintInvalidationTracking {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     Vector<PaintInvalidationInfo> trackedPaintInvalidations;
-#if DCHECK_IS_ON()
     RefPtr<SkPicture> lastPaintedPicture;
     Region paintInvalidationRegionSinceLastPaint;
     Vector<UnderPaintInvalidation> underPaintInvalidations;
-#endif
 };
 
 typedef HashMap<const GraphicsLayer*, PaintInvalidationTracking> PaintInvalidationTrackingMap;
 static PaintInvalidationTrackingMap& paintInvalidationTrackingMap()
 {
     DEFINE_STATIC_LOCAL(PaintInvalidationTrackingMap, map, ());
     return map;
 }
 
 std::unique_ptr<GraphicsLayer> GraphicsLayer::create(GraphicsLayerClient* client)
@@ skipping 218 matching lines @@
 
 IntRect GraphicsLayer::interestRect()
 {
     return m_previousInterestRect;
 }
 
 void GraphicsLayer::paint(const IntRect* interestRect, GraphicsContext::DisabledMode disabledMode)
 {
     if (paintWithoutCommit(interestRect, disabledMode)) {
         getPaintController().commitNewDisplayItems(offsetFromLayoutObjectWithSubpixelAccumulation());
-#if DCHECK_IS_ON()
-        if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
+        if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
             RefPtr<SkPicture> newPicture = capturePicture();
             checkPaintUnderInvalidations(*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())
@@ skipping 189 matching lines @@
     resetTrackedPaintInvalidations();
     m_isTrackingPaintInvalidations = tracksPaintInvalidations;
 }
 
 void GraphicsLayer::resetTrackedPaintInvalidations()
 {
     auto it = paintInvalidationTrackingMap().find(this);
     if (it == paintInvalidationTrackingMap().end())
         return;
 
-    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
+    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
         it->value.trackedPaintInvalidations.clear();
     else
         paintInvalidationTrackingMap().remove(it);
 }
 
 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)
 {
     if (!isTrackingOrCheckingPaintInvalidations() || rect.isEmpty())
         return;
 
     PaintInvalidationTracking& tracking = paintInvalidationTrackingMap().add(this, PaintInvalidationTracking()).storedValue->value;
 
     if (m_isTrackingPaintInvalidations) {
         PaintInvalidationInfo info = { &client, client.debugName(), rect, reason };
         tracking.trackedPaintInvalidations.append(info);
     }
 
-#if DCHECK_IS_ON()
-    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
+    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
         // 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 172 matching lines @@
                 for (auto& info : infos) {
                     std::unique_ptr<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(std::move(infoJSON));
                 }
                 json->setArray("paintInvalidations", std::move(paintInvalidationsJSON));
             }
-#if DCHECK_IS_ON()
+
             Vector<UnderPaintInvalidation>& underPaintInvalidations = it->value.underPaintInvalidations;
             if (!underPaintInvalidations.isEmpty()) {
                 std::unique_ptr<JSONArray> underPaintInvalidationsJSON = JSONArray::create();
                 for (auto& underPaintInvalidation : underPaintInvalidations) {
                     std::unique_ptr<JSONObject> underPaintInvalidationJSON = JSONObject::create();
                     underPaintInvalidationJSON->setDouble("x", underPaintInvalidation.x);
                     underPaintInvalidationJSON->setDouble("y", underPaintInvalidation.x);
                     underPaintInvalidationJSON->setString("oldPixel", Color(underPaintInvalidation.oldPixel).nameForLayoutTreeAsText());
                     underPaintInvalidationJSON->setString("newPixel", Color(underPaintInvalidation.newPixel).nameForLayoutTreeAsText());
                     underPaintInvalidationsJSON->pushObject(std::move(underPaintInvalidationJSON));
                 }
                 json->setArray("underPaintInvalidations", std::move(underPaintInvalidationsJSON));
             }
-#endif
         }
     }
 
     if ((flags & LayerTreeIncludesPaintingPhases) && m_paintingPhase) {
         std::unique_ptr<JSONArray> paintingPhasesJSON = JSONArray::create();
         if (m_paintingPhase & GraphicsLayerPaintBackground)
             paintingPhasesJSON->pushString("GraphicsLayerPaintBackground");
         if (m_paintingPhase & GraphicsLayerPaintForeground)
             paintingPhasesJSON->pushString("GraphicsLayerPaintForeground");
         if (m_paintingPhase & GraphicsLayerPaintMask)
@@ skipping 438 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);
     return graphicsContext.endRecording();
@@ skipping 25 matching lines @@
     if (it == paintInvalidationTrackingMap().end())
         return;
     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());
+    {
+        SkCanvas canvas(oldBitmap);
+        canvas.clear(SK_ColorTRANSPARENT);
+        canvas.drawPicture(tracking.lastPaintedPicture.get());
+    }
 
     SkBitmap newBitmap;
     newBitmap.allocPixels(SkImageInfo::MakeN32Premul(width, height));
-    SkCanvas(newBitmap).drawPicture(&newPicture);
+    {
+        SkCanvas canvas(newBitmap);
+        canvas.clear(SK_ColorTRANSPARENT);
+        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))) {
                 if (mismatchingPixels < maxMismatchesToReport) {
                     UnderPaintInvalidation underPaintInvalidation = { x, y, oldPixel, newPixel };
                     tracking.underPaintInvalidations.append(underPaintInvalidation);
                     LOG(ERROR) << debugName() << " Uninvalidated old/new pixels mismatch at " << x << "," << y << " old:" << std::hex << oldPixel << " new:" << newPixel;
                 } else if (mismatchingPixels == maxMismatchesToReport) {
                     LOG(ERROR) << "and more...";
                 }
                 ++mismatchingPixels;
-                *newBitmap.getAddr32(x, y) = SK_ColorRED;
+                *newBitmap.getAddr32(x, y) = SkColorSetARGB(0x80, 0xFF, 0, 0xFF); // Half translucent magenta.
             } else {
                 *newBitmap.getAddr32(x, y) = 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);
     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