cc: Add predictive pre-painting.

cc/tiled_layer.cc

 // Copyright 2011 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 "cc/tiled_layer.h"
 
 #include "CCLayerImpl.h"
 #include "CCLayerTreeHost.h"
@@ skipping 550 matching lines @@
         priority = CCPriorityCalculator::maxPriority(priority, CCPriorityCalculator::smallAnimatedLayerMinPriority());
     if (priority != CCPriorityCalculator::lowestPriority())
         texture->setRequestPriority(priority);
 }
 }
 
 void TiledLayerChromium::setTexturePriorities(const CCPriorityCalculator& priorityCalc)
 {
     updateBounds();
     resetUpdateState();
+    updateScrollPrediction();
 
     if (m_tiler->hasEmptyBounds())
         return;
 
     bool drawsToRoot = !renderTarget()->parent();
     bool smallAnimatedLayer = isSmallAnimatedLayer(this);
 
     // Minimally create the tiles in the desired pre-paint rect.
     IntRect createTilesRect = idlePaintRect();
     if (!createTilesRect.isEmpty()) {
@@ skipping 49 matching lines @@
         }
     }
 
     // Now update priorities on all tiles we have in the layer, no matter where they are.
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect tileRect = m_tiler->tileRect(tile);
-        setPriorityForTexture(visibleContentRect(), tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
+        setPriorityForTexture(m_predictedVisibleRect, tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
     }
 }
 
 Region TiledLayerChromium::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
     if (contentsOpaque())
         return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 }
 
 void TiledLayerChromium::resetUpdateState()
 {
     m_skipsDraw = false;
     m_failedUpdate = false;
 
     CCLayerTilingData::TileMap::const_iterator end = m_tiler->tiles().end();
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != end; ++iter) {
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         tile->resetUpdateState();
     }
 }
 
+namespace {
+IntRect expandRectByDelta(IntRect rect, IntSize delta) {
+    int width  = rect.width() + abs(delta.width());
+    int height = rect.height() + abs(delta.height());
+    int x = rect.x() + ((delta.width() < 0)  ? delta.width()  : 0);

[enne (OOO), 2012/10/18 19:13:08]

Why do you need this clamping on the negative end, but not on the positive
content bounds end? Don't you intersect with content bounds later anyway?

[epennerAtGoogle, 2012/10/18 19:58:55]

When expanding a rect in the direction of an arbitrary vector, the width/height
are always increased. But the x/y are only changed if you are expanding in the
negative direction.

[enne (OOO), 2012/10/19 18:40:56]

Ah, gotcha, thanks.

+    int y = rect.y() + ((delta.height() < 0) ? delta.height() : 0);
+    return IntRect(x, y, width, height);
+}
+}
+
+void TiledLayerChromium::updateScrollPrediction()
+{
+    // This scroll prediction is very primitive and should be replaced by a
+    // a recursive calculation on all layers which uses actual scroll/animation
+    // velocities. To insure this doesn't miss-predict, we only use it to predict
+    // the visibleRect if:
+    // - contentBounds() hasn't changed.
+    // - visibleRect.size() hasn't changed.
+    // These two conditions prevent rotations, scales, pinch-zooms etc. where
+    // the prediction would be incorrect.
+    IntSize delta = visibleContentRect().center() - m_previousVisibleRect.center();
+    m_predictedScroll = -delta;
+    m_predictedVisibleRect = visibleContentRect();
+    if (m_previousContentBounds == contentBounds() && m_previousVisibleRect.size() == visibleContentRect().size()) {
+        // Only expand the visible rect in the major scroll direction, to prevent
+        // massive paints due to diagonal scrolls.
+        IntSize majorScrollAxis = (abs(delta.width()) > abs(delta.height())) ? IntSize(delta.width(), 0) : IntSize(0, delta.height());
+        m_predictedVisibleRect = expandRectByDelta(visibleContentRect(), majorScrollAxis);
+
+        // Bound the prediction to at most 2 tiles, and clamp to content bounds.

[enne (OOO), 2012/10/18 19:13:08]

The 2 tiles ahead guess seems a little magical.  Has this worked well in
practice for you?

At the very least, can you pull all these numbers here and in idle paint rect up
into named constants?

[epennerAtGoogle, 2012/10/18 19:58:55]

There needs to be some kind of clamp to prevent arbitrary sized paints, since we
don't move the visible rect but only expand it. Downstream we used the size if
the visible rect to clamp how much extra painting is done but I was more
conservative here.

The amount of extra painting basically chooses the ratio of time that is
committed to pre-painting in cases where there is also visible invalidations.

+        IntRect bound = visibleContentRect();
+        bound.inflateX(m_tiler->tileSize().width() * 2);
+        bound.inflateY(m_tiler->tileSize().height() * 2);
+        bound.intersect(IntRect(IntPoint::zero(), contentBounds()));
+        m_predictedVisibleRect.intersect(bound);
+    }
+    m_previousContentBounds = contentBounds();
+    m_previousVisibleRect = visibleContentRect();
+}
+
 void TiledLayerChromium::update(CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats)
 {
     ASSERT(!m_skipsDraw && !m_failedUpdate); // Did resetUpdateState get skipped?
     updateBounds();
     if (m_tiler->hasEmptyBounds() || !drawsContent())
         return;
 
     bool didPaint = false;
 
     // Animation pre-paint. If the layer is small, try to paint it all
     // immediately whether or not it is occluded, to avoid paint/upload
     // hiccups while it is animating.
     if (isSmallAnimatedLayer(this)) {
         int left, top, right, bottom;
         m_tiler->contentRectToTileIndices(IntRect(IntPoint::zero(), contentBounds()), left, top, right, bottom);
         updateTiles(left, top, right, bottom, queue, 0, stats, didPaint);
         if (didPaint)
             return;
         // This was an attempt to paint the entire layer so if we fail it's okay,
         // just fallback on painting visible etc. below.
         m_failedUpdate = false;
     }
 
-    if (visibleContentRect().isEmpty())
+    if (m_predictedVisibleRect.isEmpty())
         return;
 
     // Visible painting. First occlude visible tiles and paint the non-occluded tiles.
     int left, top, right, bottom;
-    m_tiler->contentRectToTileIndices(visibleContentRect(), left, top, right, bottom);
+    m_tiler->contentRectToTileIndices(m_predictedVisibleRect, left, top, right, bottom);
     markOcclusionsAndRequestTextures(left, top, right, bottom, occlusion);
     m_skipsDraw = !updateTiles(left, top, right, bottom, queue, occlusion, stats, didPaint);
     if (m_skipsDraw)
         m_tiler->reset();
     if (m_skipsDraw || didPaint)
         return;
 
     // If we have already painting everything visible. Do some pre-painting while idle.
     IntRect idlePaintContentRect = idlePaintRect();
     if (idlePaintContentRect.isEmpty())
         return;
 
     // Prepaint anything that was occluded but inside the layer's visible region.
     if (!updateTiles(left, top, right, bottom, queue, 0, stats, didPaint) || didPaint)
         return;
 
     int prepaintLeft, prepaintTop, prepaintRight, prepaintBottom;
     m_tiler->contentRectToTileIndices(idlePaintContentRect, prepaintLeft, prepaintTop, prepaintRight, prepaintBottom);
 
-    // Then expand outwards from the visible area until we find a dirty row or column to update.
-    while (left > prepaintLeft || top > prepaintTop || right < prepaintRight || bottom < prepaintBottom) {
-        if (bottom < prepaintBottom) {
-            ++bottom;
-            if (!updateTiles(left, bottom, right, bottom, queue, 0, stats, didPaint) || didPaint)
-                return;
+    // Then expand outwards one row/column at a time until we find a dirty row/column
+    // to update. Increment along the major and minor scroll directions first.
+    IntSize delta = -m_predictedScroll;
+    delta = IntSize(delta.width() == 0 ? 1 : delta.width(),
+                    delta.height() == 0 ? 1 : delta.height());
+    IntSize majorDelta = (abs(delta.width()) >  abs(delta.height())) ? IntSize(delta.width(), 0) : IntSize(0, delta.height());
+    IntSize minorDelta = (abs(delta.width()) <= abs(delta.height())) ? IntSize(delta.width(), 0) : IntSize(0, delta.height());
+    IntSize deltas[4] = {majorDelta, minorDelta, -majorDelta, -minorDelta};
+    for(int i = 0; i < 4; i++) {
+        if (deltas[i].height() > 0) {
+            while (bottom < prepaintBottom) {
+                ++bottom;
+                if (!updateTiles(left, bottom, right, bottom, queue, 0, stats, didPaint) || didPaint)
+                    return;
+            }
         }
-        if (top > prepaintTop) {
-            --top;
-            if (!updateTiles(left, top, right, top, queue, 0, stats, didPaint) || didPaint)
-                return;
+        if (deltas[i].height() < 0) {
+            while (top > prepaintTop) {
+                --top;
+                if (!updateTiles(left, top, right, top, queue, 0, stats, didPaint) || didPaint)
+                    return;
+            }
         }
-        if (left > prepaintLeft) {
-            --left;
-            if (!updateTiles(left, top, left, bottom, queue, 0, stats, didPaint) || didPaint)
-                return;
+        if (deltas[i].width() < 0) {
+            while (left > prepaintLeft) {
+                --left;
+                if (!updateTiles(left, top, left, bottom, queue, 0, stats, didPaint) || didPaint)
+                    return;
+            }
         }
-        if (right < prepaintRight) {
-            ++right;
-            if (!updateTiles(right, top, right, bottom, queue, 0, stats, didPaint) || didPaint)
-                return;
+        if (deltas[i].width() > 0) {
+            while (right < prepaintRight) {
+                ++right;
+                if (!updateTiles(right, top, right, bottom, queue, 0, stats, didPaint) || didPaint)
+                    return;
+            }
         }
     }
 }
 
 bool TiledLayerChromium::needsIdlePaint()
 {
     // Don't trigger more paints if we failed (as we'll just fail again).
     if (m_failedUpdate || visibleContentRect().isEmpty() || m_tiler->hasEmptyBounds() || !drawsContent())
         return false;
 
@@ skipping 23 matching lines @@
 
 IntRect TiledLayerChromium::idlePaintRect()
 {
     // Don't inflate an empty rect.
     if (visibleContentRect().isEmpty())
         return IntRect();
 
     // FIXME: This can be made a lot larger now! We should increase
     //        this slowly while insuring it doesn't cause any perf issues.
     IntRect prepaintRect = visibleContentRect();
-    prepaintRect.inflateX(m_tiler->tileSize().width());
-    prepaintRect.inflateY(m_tiler->tileSize().height() * 2);
+    prepaintRect.inflateX(m_tiler->tileSize().width() * 2);
+    prepaintRect.inflateY(m_tiler->tileSize().height() * 4);
     IntRect contentRect(IntPoint::zero(), contentBounds());
     prepaintRect.intersect(contentRect);
 
     return prepaintRect;
 }
 
 }