cc: Redraw incomplete frames when new texture uploads finish

cc/layer_tree_host_impl.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 "cc/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 446 matching lines @@
         occlusionTracker.setNonOccludingScreenSpaceRectsContainer(&frame.nonOccludingScreenSpaceRects);
 
     // Add quads to the Render passes in FrontToBack order to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
 
     // Typically when we are missing a texture and use a checkerboard quad, we still draw the frame. However when the layer being
     // checkerboarded is moving due to an impl-animation, we drop the frame to avoid flashing due to the texture suddenly appearing
     // in the future.
     bool drawFrame = true;
 
-    // Make sure we have the most recent info regarding which textures have been uploaded.
-    checkForCompletedSetPixels();
-
     LayerIteratorType end = LayerIteratorType::end(frame.renderSurfaceLayerList);
     for (LayerIteratorType it = LayerIteratorType::begin(frame.renderSurfaceLayerList); it != end; ++it) {
         RenderPass::Id targetRenderPassId = it.targetRenderSurfaceLayer()->renderSurface()->renderPassId();
         RenderPass* targetRenderPass = frame.renderPassesById[targetRenderPassId];
 
         occlusionTracker.enterLayer(it);
 
         AppendQuadsData appendQuadsData(targetRenderPass->id);
 
         if (it.representsContributingRenderSurface()) {
@@ skipping 227 matching lines @@
 {
     return m_proxy->hasImplThread();
 }
 
 void LayerTreeHostImpl::ScheduleManageTiles()
 {
     if (m_client)
       m_client->setNeedsManageTilesOnImplThread();
 }
 
+void LayerTreeHostImpl::DidUploadVisibleHighResolutionTile()
+{
+    if (m_client)
+        m_client->setNeedsRedrawOnImplThread();

[nduca, 2013/01/16 04:09:47]

see now i dont get why this one does setNeedsRedraw but the other one does
setNeedsRedrawOnBlahBlahBlah

[brianderson, 2013/01/16 20:12:22]

In this case, we know we have a better frame to draw.  In the other case, we
don't know if we have a better frame to draw until the next vsync (so it
indicates we will need an eventual redraw instead of an immediate one).  The
scheduler uses this info to tick without necessarily drawing.

+}
+
 bool LayerTreeHostImpl::shouldClearRootRenderPass() const
 {
     return m_settings.shouldClearRootRenderPass;
 }
 
 void LayerTreeHostImpl::setManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
 {
     if (m_managedMemoryPolicy == policy)
         return;
 
@@ skipping 103 matching lines @@
 const RendererCapabilities& LayerTreeHostImpl::rendererCapabilities() const
 {
     return m_renderer->capabilities();
 }
 
 bool LayerTreeHostImpl::swapBuffers()
 {
     DCHECK(m_renderer);
 
     m_fpsCounter->markEndOfFrame();
-    return m_renderer->swapBuffers();
+    bool result = m_renderer->swapBuffers();
+
+    if (!activeTree()->AreVisibleResourcesReady()) {

[nduca, 2013/01/16 04:09:47]

I'm confused, why are we checking this again here?

[brianderson, 2013/01/16 20:12:22]

This checks if the active tree just drawn was incomplete (checkered or low-res).
 If it was incomplete it lets the proxy know that it needs to redraw when it can
draw a more complete frame.

Maybe a better name for setNeedsRedrawOnVisibleTextureUploadOnImplThread would
be setSwapUsedIncompleteTexturesOnImplThread.

+      m_client->setNeedsRedrawOnVisibleTextureUploadOnImplThread();
+    }
+
+    return result;
 }
 
 const gfx::Size& LayerTreeHostImpl::deviceViewportSize() const
 {
     return m_deviceViewportSize;
 }
 
 const LayerTreeSettings& LayerTreeHostImpl::settings() const
 {
     return m_settings;
@@ skipping 48 matching lines @@
 }
 
 void LayerTreeHostImpl::createPendingTree()
 {
     CHECK(!m_pendingTree);
     m_pendingTree = LayerTreeImpl::create(this);
     m_client->onCanDrawStateChanged(canDraw());
     m_client->onHasPendingTreeStateChanged(pendingTree());
 }
 
+// This function should not be called from within a draw, as it can trigger
+// as spurious draw if a new visible tile gets upload.
 void LayerTreeHostImpl::checkForCompletedSetPixels()
 {
     if (m_tileManager)
         m_tileManager->CheckForCompletedSetPixels();
 }
 
 void LayerTreeHostImpl::activatePendingTreeIfNeeded()
 {
     if (!pendingTree())
         return;
 
-    checkForCompletedSetPixels();
-
     // It's always fine to activate to an empty tree.  Otherwise, only
     // activate once all visible resources in pending tree are ready.
     if (activeTree()->RootLayer() &&
         !pendingTree()->AreVisibleResourcesReady())
       return;
 
     activatePendingTree();
 }
 
 void LayerTreeHostImpl::activatePendingTree()
@@ skipping 707 matching lines @@
 }
 
 skia::RefPtr<SkPicture> LayerTreeHostImpl::capturePicture()
 {
     LayerTreeImpl* tree = pendingTree() ? pendingTree() : activeTree();
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
     return layer ? layer->getPicture() : skia::RefPtr<SkPicture>();
 }
 
 }  // namespace cc