Use message passing for BeginFrameAndCommitState and clean up forced commit logic

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/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/delay_based_time_source.h"
 #include "cc/draw_quad.h"
@@ skipping 20 matching lines @@
 scoped_ptr<Proxy> ThreadProxy::create(LayerTreeHost* layerTreeHost, scoped_ptr<Thread> implThread)
 {
     return make_scoped_ptr(new ThreadProxy(layerTreeHost, implThread.Pass())).PassAs<Proxy>();
 }
 
 ThreadProxy::ThreadProxy(LayerTreeHost* layerTreeHost, scoped_ptr<Thread> implThread)
     : Proxy(implThread.Pass())
     , m_animateRequested(false)
     , m_commitRequested(false)
     , m_commitRequestSentToImplThread(false)
-    , m_forcedCommitRequested(false)
     , m_layerTreeHost(layerTreeHost)
     , m_rendererInitialized(false)
     , m_started(false)
     , m_texturesAcquired(true)
     , m_inCompositeAndReadback(false)
     , m_mainThreadProxy(ScopedThreadProxy::create(Proxy::mainThread()))
     , m_beginFrameCompletionEventOnImplThread(0)
     , m_readbackRequestOnImplThread(0)
     , m_commitCompletionEventOnImplThread(0)
     , m_textureAcquisitionCompletionEventOnImplThread(0)
     , m_nextFrameIsNewlyCommittedFrameOnImplThread(false)
     , m_renderVSyncEnabled(layerTreeHost->settings().renderVSyncEnabled)
     , m_totalCommitCount(0)
     , m_deferCommits(false)
-    , m_deferredCommitPending(false)
 {
     TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
     DCHECK(isMainThread());
 }
 
 ThreadProxy::~ThreadProxy()
 {
     TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
     DCHECK(isMainThread());
     DCHECK(!m_started);
 }
 
 bool ThreadProxy::compositeAndReadback(void *pixels, const gfx::Rect& rect)
 {
-    TRACE_EVENT0("cc", "ThreadPRoxy::compositeAndReadback");
+    TRACE_EVENT0("cc", "ThreadProxy::compositeAndReadback");
     DCHECK(isMainThread());
     DCHECK(m_layerTreeHost);
     DCHECK(!m_deferCommits);
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "compositeAndReadback_EarlyOut_LR_Uninitialized");
         return false;
     }
 
 
     // Perform a synchronous commit.
     {
         DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
         CompletionEvent beginFrameCompletion;
         Proxy::implThread()->postTask(base::Bind(&ThreadProxy::forceBeginFrameOnImplThread, base::Unretained(this), &beginFrameCompletion));
         beginFrameCompletion.wait();
     }
     m_inCompositeAndReadback = true;
-    beginFrame();
+    beginFrame(scoped_ptr<BeginFrameAndCommitState>());
     m_inCompositeAndReadback = false;
 
     // Perform a synchronous readback.
     ReadbackRequest request;
     request.rect = rect;
     request.pixels = pixels;
     {
         DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
         Proxy::implThread()->postTask(base::Bind(&ThreadProxy::requestReadbackOnImplThread, base::Unretained(this), &request));
         request.completion.wait();
@@ skipping 230 matching lines @@
 {
     DCHECK(isImplThread());
     TRACE_EVENT0("cc", "ThreadProxy::setNeedsCommitOnImplThread");
     m_schedulerOnImplThread->setNeedsCommit();
 }
 
 void ThreadProxy::setNeedsForcedCommitOnImplThread()
 {
     DCHECK(isImplThread());
     TRACE_EVENT0("cc", "ThreadProxy::setNeedsForcedCommitOnImplThread");
-    m_schedulerOnImplThread->setNeedsCommit();
     m_schedulerOnImplThread->setNeedsForcedCommit();
 }
 
 void ThreadProxy::postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector> events, base::Time wallClockTime)
 {
     DCHECK(isImplThread());
     TRACE_EVENT0("cc", "ThreadProxy::postAnimationEventsToMainThreadOnImplThread");
     m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadProxy::setAnimationEvents, base::Unretained(this), base::Passed(events.Pass()), wallClockTime));
 }
 
@@ skipping 43 matching lines @@
 {
     DCHECK(isMainThread());
     DCHECK_NE(m_deferCommits, deferCommits);
     m_deferCommits = deferCommits;
 
     if (m_deferCommits)
         TRACE_EVENT_ASYNC_BEGIN0("cc", "ThreadProxy::setDeferCommits", this);
     else
         TRACE_EVENT_ASYNC_END0("cc", "ThreadProxy::setDeferCommits", this);
 
-    if (!m_deferCommits && m_deferredCommitPending) {
-        m_deferredCommitPending = false;
-        m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadProxy::beginFrame, base::Unretained(this)));
-    }
+    if (!m_deferCommits && m_pendingDeferredCommit)
+        m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadProxy::beginFrame, base::Unretained(this), base::Passed(m_pendingDeferredCommit.Pass())));
 }
 
 bool ThreadProxy::commitRequested() const
 {
     DCHECK(isMainThread());
     return m_commitRequested;
 }
 
 void ThreadProxy::setNeedsRedrawOnImplThread()
 {
@@ skipping 60 matching lines @@
     DCHECK(isImplThread());
     m_layerTreeHostImpl->finishAllRendering();
     completion->signal();
 }
 
 void ThreadProxy::forceBeginFrameOnImplThread(CompletionEvent* completion)
 {
     TRACE_EVENT0("cc", "ThreadProxy::forceBeginFrameOnImplThread");
     DCHECK(!m_beginFrameCompletionEventOnImplThread);
 
+    setNeedsForcedCommitOnImplThread();
     if (m_schedulerOnImplThread->commitPending()) {
         completion->signal();
         return;
     }
 
     m_beginFrameCompletionEventOnImplThread = completion;
-    setNeedsForcedCommitOnImplThread();
 }
 
 void ThreadProxy::scheduledActionBeginFrame()
 {
     TRACE_EVENT0("cc", "ThreadProxy::scheduledActionBeginFrame");
-    DCHECK(!m_pendingBeginFrameRequest);
-    m_pendingBeginFrameRequest = make_scoped_ptr(new BeginFrameAndCommitState());
-    m_pendingBeginFrameRequest->monotonicFrameBeginTime = base::TimeTicks::Now();
-    m_pendingBeginFrameRequest->scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
-    m_pendingBeginFrameRequest->implTransform = m_layerTreeHostImpl->implTransform();
-    m_pendingBeginFrameRequest->memoryAllocationLimitBytes = m_layerTreeHostImpl->memoryAllocationLimitBytes();
+    scoped_ptr<BeginFrameAndCommitState> beginFrameState(new BeginFrameAndCommitState);
+    beginFrameState->monotonicFrameBeginTime = base::TimeTicks::Now();
+    beginFrameState->scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
+    beginFrameState->implTransform = m_layerTreeHostImpl->implTransform();
+    DCHECK_GT(m_layerTreeHostImpl->memoryAllocationLimitBytes(), 0u);
+    beginFrameState->memoryAllocationLimitBytes = m_layerTreeHostImpl->memoryAllocationLimitBytes();
     if (m_layerTreeHost->contentsTextureManager())
-         m_layerTreeHost->contentsTextureManager()->getEvictedBackings(m_pendingBeginFrameRequest->evictedContentsTexturesBackings);
+         m_layerTreeHost->contentsTextureManager()->getEvictedBackings(beginFrameState->evictedContentsTexturesBackings);
 
-    m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadProxy::beginFrame, base::Unretained(this)));
+    m_mainThreadProxy->postTask(FROM_HERE, base::Bind(&ThreadProxy::beginFrame, base::Unretained(this), base::Passed(beginFrameState.Pass())));
 
     if (m_beginFrameCompletionEventOnImplThread) {
         m_beginFrameCompletionEventOnImplThread->signal();
         m_beginFrameCompletionEventOnImplThread = 0;
     }
 }
 
-void ThreadProxy::beginFrame()
+void ThreadProxy::beginFrame(scoped_ptr<BeginFrameAndCommitState> beginFrameState)
 {
     TRACE_EVENT0("cc", "ThreadProxy::beginFrame");
     DCHECK(isMainThread());
     if (!m_layerTreeHost)
         return;
 
     if (m_deferCommits) {
-        m_deferredCommitPending = true;
+        m_pendingDeferredCommit = beginFrameState.Pass();
         m_layerTreeHost->didDeferCommit();
         TRACE_EVENT0("cc", "EarlyOut_DeferCommits");
         return;
     }
 
-    if (!m_pendingBeginFrameRequest) {
-        TRACE_EVENT0("cc", "EarlyOut_StaleBeginFrameMessage");
-        return;
-    }
-
     if (m_layerTreeHost->needsSharedContext() && !WebSharedGraphicsContext3D::haveCompositorThreadContext())
         WebSharedGraphicsContext3D::createCompositorThreadContext();
 
-    scoped_ptr<BeginFrameAndCommitState> request(m_pendingBeginFrameRequest.Pass());
-
     // Do not notify the impl thread of commit requests that occur during
     // the apply/animate/layout part of the beginFrameAndCommit process since
     // those commit requests will get painted immediately. Once we have done
     // the paint, m_commitRequested will be set to false to allow new commit
     // requests to be scheduled.
     m_commitRequested = true;
     m_commitRequestSentToImplThread = true;
 
     // On the other hand, the animationRequested flag needs to be cleared
     // here so that any animation requests generated by the apply or animate
     // callbacks will trigger another frame.
     m_animateRequested = false;
 
-    // FIXME: technically, scroll deltas need to be applied for dropped commits as well.
-    // Re-do the commit flow so that we don't send the scrollInfo on the BFAC message.
-    m_layerTreeHost->applyScrollAndScale(*request->scrollInfo);
-    m_layerTreeHost->setImplTransform(request->implTransform);
+    if (beginFrameState) {
+        m_layerTreeHost->applyScrollAndScale(*beginFrameState->scrollInfo);
+        m_layerTreeHost->setImplTransform(beginFrameState->implTransform);
+    }
 
     if (!m_inCompositeAndReadback && !m_layerTreeHost->visible()) {
         m_commitRequested = false;
         m_commitRequestSentToImplThread = false;
-        m_forcedCommitRequested = false;
 
         TRACE_EVENT0("cc", "EarlyOut_NotVisible");
         Proxy::implThread()->postTask(base::Bind(&ThreadProxy::beginFrameAbortedOnImplThread, base::Unretained(this)));
         return;
     }
 
     m_layerTreeHost->willBeginFrame();
 
-    m_layerTreeHost->updateAnimations(request->monotonicFrameBeginTime);
+    if (beginFrameState)
+        m_layerTreeHost->updateAnimations(beginFrameState->monotonicFrameBeginTime);
     m_layerTreeHost->layout();
 
     // Clear the commit flag after updating animations and layout here --- objects that only
     // layout when painted will trigger another setNeedsCommit inside
     // updateLayers.
     m_commitRequested = false;
     m_commitRequestSentToImplThread = false;
-    m_forcedCommitRequested = false;
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "EarlyOut_InitializeFailed");
         return;
     }
 
-    m_layerTreeHost->contentsTextureManager()->unlinkEvictedBackings(request->evictedContentsTexturesBackings);
+    if (beginFrameState)
+        m_layerTreeHost->contentsTextureManager()->unlinkEvictedBackings(beginFrameState->evictedContentsTexturesBackings);
 
     scoped_ptr<ResourceUpdateQueue> queue = make_scoped_ptr(new ResourceUpdateQueue);
-    m_layerTreeHost->updateLayers(*(queue.get()), request->memoryAllocationLimitBytes);
+    m_layerTreeHost->updateLayers(*(queue.get()), beginFrameState ? beginFrameState->memoryAllocationLimitBytes : 0);
 
     // Once single buffered layers are committed, they cannot be modified until
     // they are drawn by the impl thread.
     m_texturesAcquired = false;
 
     m_layerTreeHost->willCommit();
     // Before applying scrolls and calling animate, we set m_animateRequested to
     // false. If it is true now, it means setNeedAnimate was called again, but
     // during a state when m_commitRequestSentToImplThread = true. We need to
     // force that call to happen again now so that the commit request is sent to
@@ skipping 358 matching lines @@
 }
 
 void ThreadProxy::renderingStatsOnImplThread(CompletionEvent* completion, RenderingStats* stats)
 {
     DCHECK(isImplThread());
     m_layerTreeHostImpl->renderingStats(stats);
     completion->signal();
 }
 
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
+    : memoryAllocationLimitBytes(0)
 {
 }
 
 ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState()
 {
 }
 
 }  // namespace cc