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;

[pdr., 2016/09/01 16:48:52]

Region is a huge datastructure. Do we need to worry about that?

[Xianzhu, 2016/09/01 17:00:03]

I don't think we need to worry memory because the structure is allocated only
when paintUnderInvalidationChecking is enabled or we are tracking paint
invalidations, at most one for each GraphicsLayer.

     Vector<UnderPaintInvalidation> underPaintInvalidations;

[pdr., 2016/09/01 16:48:52]

To save memory can you make this vector small by default?

-#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 645 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 67 matching lines @@
 
     // 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