Avoid false-positives of under-invalidation checking

Source/platform/graphics/paint/DisplayItemList.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 
 #include "platform/NotImplemented.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
@@ skipping 278 matching lines @@
 
 static void showUnderInvalidationError(const char* reason, const DisplayItem& displayItem)
 {
 #ifndef NDEBUG
     WTFLogAlways("%s: %s\nSee http://crbug.com/450725.", reason, displayItem.asDebugString().utf8().data());
 #else
     WTFLogAlways("%s. Run debug build to get more details\nSee http://crbug.com/450725.", reason);
 #endif // NDEBUG
 }
 
+static bool bitmapIsAllZero(const SkBitmap& bitmap)
+{
+    bitmap.lockPixels();
+    bool result = true;
+    for (int x = 0; result && x < bitmap.width(); ++x) {
+        for (int y = 0; result && y < bitmap.height(); ++y) {
+            if (SkColorSetA(bitmap.getColor(x, y), 0) != SK_ColorTRANSPARENT)
+                result = false;
+        }
+    }
+    bitmap.unlockPixels();
+    return result;
+}
+
 void DisplayItemList::checkCachedDisplayItemIsUnchanged(const DisplayItem& displayItem, DisplayItemIndicesByClientMap& displayItemIndicesByClient)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
 
     if (!displayItem.isDrawing() || !clientCacheIsValid(displayItem.client()))
         return;
 
-    if (static_cast<const DrawingDisplayItem&>(displayItem).skipUnderInvalidationChecking())
+    DrawingDisplayItem::UnderInvalidationCheckingMode mode = static_cast<const DrawingDisplayItem&>(displayItem).underInvalidationCheckingMode();
+    if (mode == DrawingDisplayItem::DontCheck)
         return;
 
     // If checking under-invalidation, we always generate new display item even if the client is not invalidated.
     // Checks if the new picture is the same as the cached old picture. If the new picture is different but
     // the client is not invalidated, issue error about under-invalidation.
     size_t index = findMatchingItemFromIndex(displayItem, displayItem.type(), displayItemIndicesByClient, m_currentDisplayItems);
     if (index == kNotFound) {
         showUnderInvalidationError("ERROR: under-invalidation: no cached display item", displayItem);
         ASSERT_NOT_REACHED();
         return;
     }
 
     RefPtr<const SkPicture> newPicture = static_cast<const DrawingDisplayItem&>(displayItem).picture();
     RefPtr<const SkPicture> oldPicture = static_cast<const DrawingDisplayItem&>(*m_currentDisplayItems[index]).picture();
     // Remove the display item from cache so that we can check if there are any remaining cached display items after merging.
     m_currentDisplayItems[index] = nullptr;
 
     if (!newPicture && !oldPicture)
         return;
-    if (newPicture && oldPicture && newPicture->approximateOpCount() == oldPicture->approximateOpCount()) {
-        SkDynamicMemoryWStream newPictureSerialized;
-        newPicture->serialize(&newPictureSerialized);
-        SkDynamicMemoryWStream oldPictureSerialized;
-        oldPicture->serialize(&oldPictureSerialized);
+    if (newPicture && oldPicture) {
+        switch (mode) {
+        case DrawingDisplayItem::CheckPicture:
+            if (newPicture->approximateOpCount() == oldPicture->approximateOpCount()) {
+                SkDynamicMemoryWStream newPictureSerialized;
+                newPicture->serialize(&newPictureSerialized);
+                SkDynamicMemoryWStream oldPictureSerialized;
+                oldPicture->serialize(&oldPictureSerialized);
 
-        if (newPictureSerialized.bytesWritten() == oldPictureSerialized.bytesWritten()) {
-            RefPtr<SkData> oldData = adoptRef(oldPictureSerialized.copyToData());
-            RefPtr<SkData> newData = adoptRef(newPictureSerialized.copyToData());
-            if (oldData->equals(newData.get()))
-                return;
+                if (newPictureSerialized.bytesWritten() == oldPictureSerialized.bytesWritten()) {
+                    RefPtr<SkData> oldData = adoptRef(oldPictureSerialized.copyToData());
+                    RefPtr<SkData> newData = adoptRef(newPictureSerialized.copyToData());
+                    if (oldData->equals(newData.get()))
+                        return;
+                }
+            }
+            break;
+        case DrawingDisplayItem::CheckBitmap:

[Justin Novosad, 2015/06/01 21:47:34]

For now, this strategy will work. In the near future, this method may end up
comparing ganesh vs non-ganesh renders, which may have subtle differences due to
anti-aliasing precision.  I think it will be possible to solve by adding a new
mode here.

+            if (newPicture->cullRect() == oldPicture->cullRect()) {
+                SkBitmap bitmap;
+                SkRect rect = newPicture->cullRect();
+                bitmap.allocPixels(SkImageInfo::MakeN32Premul(rect.width(), rect.height()));
+                SkCanvas canvas(bitmap);
+                canvas.translate(-rect.x(), -rect.y());
+                canvas.drawPicture(oldPicture.get());
+                SkPaint diffPaint;
+                diffPaint.setXfermodeMode(SkXfermode::kDifference_Mode);
+                canvas.drawPicture(newPicture.get(), nullptr, &diffPaint);
+                if (bitmapIsAllZero(bitmap)) // Contents are the same.
+                    return;
+            }
+        default:
+            ASSERT_NOT_REACHED();
         }
     }
 
     showUnderInvalidationError("ERROR: under-invalidation: display item changed", displayItem);
 #ifndef NDEBUG
     String oldPictureDebugString = oldPicture ? pictureAsDebugString(oldPicture.get()) : "None";
     String newPictureDebugString = newPicture ? pictureAsDebugString(newPicture.get()) : "None";
     WTFLogAlways("old picture:\n%s\n", oldPictureDebugString.utf8().data());
     WTFLogAlways("new picture:\n%s\n", newPictureDebugString.utf8().data());
 #endif // NDEBUG
@@ skipping 46 matching lines @@
 
 void DisplayItemList::replay(GraphicsContext& context) const
 {
     TRACE_EVENT0("blink,benchmark", "DisplayItemList::replay");
     ASSERT(m_newDisplayItems.isEmpty());
     for (auto& displayItem : m_currentDisplayItems)
         displayItem->replay(context);
 }
 
 } // namespace blink