Calculate and track display item opaqueness

third_party/WebKit/Source/platform/graphics/paint/PaintArtifact.cpp

 // Copyright 2015 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 "platform/graphics/paint/PaintArtifact.h"
 
 #include "platform/TraceEvent.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 
 namespace blink {
 
 namespace {
 
-void computeChunkBounds(const DisplayItemList& displayItems, Vector<PaintChunk>& paintChunks)
+void computeChunkBoundsAndOpaqueness(const DisplayItemList& displayItems, Vector<PaintChunk>& paintChunks)
 {
     for (PaintChunk& chunk : paintChunks) {
         FloatRect bounds;
+        bool knownToBeOpaqueItems = false;
         for (const DisplayItem& item : displayItems.itemsInPaintChunk(chunk)) {
             if (!item.isDrawing())
                 continue;
             const auto& drawing = static_cast<const DrawingDisplayItem&>(item);
             if (const SkPicture* picture = drawing.picture())
                 bounds.unite(picture->cullRect());
+            if (drawing.knownToBeOpaque())
+                knownToBeOpaqueItems = true;
         }
         chunk.bounds = bounds;
+
+        // TODO(pdr): This should be optimized to not require a second walk of
+        // the items. It's not yet clear what the best approach is (regions,
+        // largest rects, first-N-rects, etc).
+        if (!knownToBeOpaqueItems)

[jbroman, 2016/01/26 17:50:14]

I'd think SkRegion is both simple and reasonably efficient here (it has
optimizations for cases like "you're adding something that's strictly contained
in this rectangle".  Then you can set:

chunk.knownToBeOpaque = opaqueRegion.contains(enclosingIntRect(bounds));

We can still leave a TODO to revisit, but it seems to me to be easier to reason
about, and more likely than a second pass to be acceptably efficient.

[pdr., 2016/01/26 23:38:08]

Heck yeah, done.

+            return;
+        for (const DisplayItem& item : displayItems.itemsInPaintChunk(chunk)) {
+            if (!item.isDrawing())
+                continue;
+            const auto& drawing = static_cast<const DrawingDisplayItem&>(item);
+            if (!drawing.knownToBeOpaque())
+                continue;
+            if (const SkPicture* picture = drawing.picture()) {
+                if (bounds.contains(picture->cullRect())) {
+                    chunk.knownToBeOpaque = true;
+                    break;
+                }
+            }
+        }
     }
 }
 
 } // namespace
 
 PaintArtifact::PaintArtifact()
     : m_displayItemList(0)
 {
 }
 
 PaintArtifact::PaintArtifact(DisplayItemList displayItems, Vector<PaintChunk> paintChunks)
     : m_displayItemList(std::move(displayItems))
     , m_paintChunks(std::move(paintChunks))
 {
-    computeChunkBounds(m_displayItemList, m_paintChunks);
+    computeChunkBoundsAndOpaqueness(m_displayItemList, m_paintChunks);
 }
 
 PaintArtifact::PaintArtifact(PaintArtifact&& source)
     : m_displayItemList(std::move(source.m_displayItemList))
     , m_paintChunks(std::move(source.m_paintChunks))
 {
 }
 
 PaintArtifact::~PaintArtifact()
 {
@@ skipping 31 matching lines @@
 #if ENABLE(ASSERT)
     m_displayItemList.assertDisplayItemClientsAreAlive();
 #endif
     for (const DisplayItem& displayItem : m_displayItemList) {
         // TODO(wkorman): Pass the actual visual rect for the display item.
         displayItem.appendToWebDisplayItemList(IntRect(), list);
     }
 }
 
 } // namespace blink