cc: Redraw incomplete frames when new texture uploads finish

cc/thread_proxy.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/thread_proxy.h"
 
+#include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/delay_based_time_source.h"
 #include "cc/draw_quad.h"
 #include "cc/frame_rate_controller.h"
 #include "cc/input_handler.h"
 #include "cc/layer_tree_host.h"
 #include "cc/output_surface.h"
 #include "cc/prioritized_resource_manager.h"
 #include "cc/scheduler.h"
@@ skipping 29 matching lines @@
     , m_manageTilesPending(false)
     , m_weakFactoryOnImplThread(ALLOW_THIS_IN_INITIALIZER_LIST(this))
     , m_weakFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this))
     , m_beginFrameCompletionEventOnImplThread(0)
     , m_readbackRequestOnImplThread(0)
     , m_commitCompletionEventOnImplThread(0)
     , m_completionEventForCommitHeldOnTreeActivation(0)
     , m_textureAcquisitionCompletionEventOnImplThread(0)
     , m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
     , m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
+    , m_insideDraw(false)
     , m_totalCommitCount(0)
     , m_deferCommits(false)
 {
     TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
     DCHECK(isMainThread());
 }
 
 ThreadProxy::~ThreadProxy()
 {
     TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
@@ skipping 332 matching lines @@
     // interact with main thread's layer tree.
     if (m_layerTreeHost->settings().implSidePainting)
         return;
 
     m_layerTreeHostImpl->sendManagedMemoryStats(
         m_layerTreeHost->contentsTextureManager()->memoryVisibleBytes(),
         m_layerTreeHost->contentsTextureManager()->memoryVisibleAndNearbyBytes(),
         m_layerTreeHost->contentsTextureManager()->memoryUseBytes());
 }
 
+bool ThreadProxy::isInsideDraw()
+{
+    return m_insideDraw;
+}
+
 void ThreadProxy::setNeedsRedraw()
 {
     DCHECK(isMainThread());
     TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedraw");
     Proxy::implThread()->postTask(base::Bind(&ThreadProxy::setFullRootLayerDamageOnImplThread, m_implThreadWeakPtr));
     Proxy::implThread()->postTask(base::Bind(&ThreadProxy::setNeedsRedrawOnImplThread, m_implThreadWeakPtr));
 }
 
 void ThreadProxy::setDeferCommits(bool deferCommits)
 {
@@ skipping 16 matching lines @@
     return m_commitRequested;
 }
 
 void ThreadProxy::setNeedsRedrawOnImplThread()
 {
     DCHECK(isImplThread());
     TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedrawOnImplThread");
     m_schedulerOnImplThread->setNeedsRedraw();
 }
 
+void ThreadProxy::didSwapUseIncompleteTextureOnImplThread()
+{
+   DCHECK(isImplThread());
+   TRACE_EVENT0("cc", "ThreadProxy::didSwapUseIncompleteTextureOnImplThread");
+   m_schedulerOnImplThread->didSwapUseIncompleteTexture();
+}
+
+void ThreadProxy::didUploadVisibleHighResolutionTileOnImplTread()
+{
+   DCHECK(isImplThread());
+   TRACE_EVENT0("cc", "ThreadProxy::didUploadVisibleHighResolutionTileOnImplTread");
+   m_schedulerOnImplThread->setNeedsRedraw();
+}
+
 void ThreadProxy::mainThreadHasStoppedFlinging()
 {
     if (m_inputHandlerOnImplThread)
         m_inputHandlerOnImplThread->mainThreadHasStoppedFlinging();
 }
 
 void ThreadProxy::start()
 {
     DCHECK(isMainThread());
     DCHECK(Proxy::implThread());
@@ skipping 278 matching lines @@
     else
     {
         m_commitCompletionEventOnImplThread->signal();
         m_commitCompletionEventOnImplThread = 0;
     }
 
     // SetVisible kicks off the next scheduler action, so this must be last.
     m_schedulerOnImplThread->setVisible(m_layerTreeHostImpl->visible());
 }
 
+void ThreadProxy::scheduledActionCheckForCompletedTextures()
+{
+    DCHECK(isImplThread());
+    TRACE_EVENT0("cc", "ThreadProxy::scheduledActionCheckForCompletedTextures");
+    m_layerTreeHostImpl->checkForCompletedTextures();
+}
+
 void ThreadProxy::scheduledActionActivatePendingTreeIfNeeded()
 {
+    DCHECK(isImplThread());
+    TRACE_EVENT0("cc", "ThreadProxy::scheduledActionActivatePendingTreeIfNeeded");
     m_layerTreeHostImpl->activatePendingTreeIfNeeded();
 }
 
 void ThreadProxy::scheduledActionBeginContextRecreation()
 {
     DCHECK(isImplThread());
     Proxy::mainThread()->postTask(base::Bind(&ThreadProxy::beginContextRecreation, m_mainThreadWeakPtr));
 }
 
 ScheduledActionDrawAndSwapResult ThreadProxy::scheduledActionDrawAndSwapInternal(bool forcedDraw)
 {
     TRACE_EVENT0("cc", "ThreadProxy::scheduledActionDrawAndSwap");
+
+    base::AutoReset<bool> markInside(&m_insideDraw, true);
+
     ScheduledActionDrawAndSwapResult result;
     result.didDraw = false;
     result.didSwap = false;
     DCHECK(isImplThread());
     DCHECK(m_layerTreeHostImpl.get());
     if (!m_layerTreeHostImpl.get())
         return result;
 
     DCHECK(m_layerTreeHostImpl->renderer());
     if (!m_layerTreeHostImpl->renderer())
@@ skipping 305 matching lines @@
 }
 
 void ThreadProxy::capturePictureOnImplThread(CompletionEvent* completion, skia::RefPtr<SkPicture>* picture)
 {
     DCHECK(isImplThread());
     *picture = m_layerTreeHostImpl->capturePicture();
     completion->signal();
 }
 
 }  // namespace cc