Provide a vsync notification to the renderer

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"
@@ skipping 41 matching lines @@
     , 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_renderVSyncNotificationEnabled(layerTreeHost->settings().renderVSyncNotificationEnabled)
+    , m_vsyncClient(0)
     , m_totalCommitCount(0)
     , m_deferCommits(false)
     , m_renewTreePriorityOnImplThreadPending(false)
 {
     TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
     DCHECK(isMainThread());
 }
 
 ThreadProxy::~ThreadProxy()
 {
@@ skipping 253 matching lines @@
     Proxy::mainThread()->postTask(base::Bind(&ThreadProxy::didCompleteSwapBuffers, m_mainThreadWeakPtr));
 }
 
 void ThreadProxy::onVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval)
 {
     DCHECK(isImplThread());
     TRACE_EVENT2("cc", "ThreadProxy::onVSyncParametersChanged", "timebase", (timebase - base::TimeTicks()).InMilliseconds(), "interval", interval.InMilliseconds());
     m_schedulerOnImplThread->setTimebaseAndInterval(timebase, interval);
 }
 
+void ThreadProxy::didVSync(base::TimeTicks frameTime)
+{
+    DCHECK(isImplThread());
+    TRACE_EVENT0("cc", "ThreadProxy::didVSync");
+    if (m_vsyncClient)
+        m_vsyncClient->DidVSync(frameTime);
+}
+
 void ThreadProxy::onCanDrawStateChanged(bool canDraw)
 {
     DCHECK(isImplThread());
     TRACE_EVENT1("cc", "ThreadProxy::onCanDrawStateChanged", "canDraw", canDraw);
     m_schedulerOnImplThread->setCanDraw(canDraw);
 }
 
 void ThreadProxy::onHasPendingTreeStateChanged(bool hasPendingTree)
 {
     DCHECK(isImplThread());
@@ skipping 639 matching lines @@
         m_outputSurfaceRecreationCallback.Cancel();
 }
 
 void ThreadProxy::initializeImplOnImplThread(CompletionEvent* completion, InputHandler* handler)
 {
     TRACE_EVENT0("cc", "ThreadProxy::initializeImplOnImplThread");
     DCHECK(isImplThread());
     m_layerTreeHostImpl = m_layerTreeHost->createLayerTreeHostImpl(this);
     const base::TimeDelta displayRefreshInterval = base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond / 60);
     scoped_ptr<FrameRateController> frameRateController;
-    if (m_renderVSyncEnabled)
-        frameRateController.reset(new FrameRateController(DelayBasedTimeSource::create(displayRefreshInterval, Proxy::implThread())));
-    else
+    if (m_renderVSyncEnabled) {
+        if (m_renderVSyncNotificationEnabled)
+            frameRateController.reset(new FrameRateController(VSyncTimeSource::create(this)));
+        else
+            frameRateController.reset(new FrameRateController(DelayBasedTimeSource::create(displayRefreshInterval, Proxy::implThread())));
+    } else
         frameRateController.reset(new FrameRateController(Proxy::implThread()));
     SchedulerSettings schedulerSettings;
     schedulerSettings.implSidePainting = m_layerTreeHost->settings().implSidePainting;
     m_schedulerOnImplThread = Scheduler::create(this, frameRateController.Pass(),
                                                 schedulerSettings);
     m_schedulerOnImplThread->setVisible(m_layerTreeHostImpl->visible());
 
     m_inputHandlerOnImplThread = scoped_ptr<InputHandler>(handler);
     if (m_inputHandlerOnImplThread.get())
         m_inputHandlerOnImplThread->bindToClient(m_layerTreeHostImpl.get());
@@ skipping 29 matching lines @@
     completion->signal();
 }
 
 void ThreadProxy::layerTreeHostClosedOnImplThread(CompletionEvent* completion)
 {
     TRACE_EVENT0("cc", "ThreadProxy::layerTreeHostClosedOnImplThread");
     DCHECK(isImplThread());
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
     m_inputHandlerOnImplThread.reset();
     m_layerTreeHostImpl.reset();
+    m_vsyncClient = 0;
     m_schedulerOnImplThread.reset();
     m_weakFactoryOnImplThread.InvalidateWeakPtrs();
     completion->signal();
 }
 
 void ThreadProxy::setFullRootLayerDamageOnImplThread()
 {
     DCHECK(isImplThread());
     m_layerTreeHostImpl->setFullRootLayerDamage();
 }
@@ skipping 16 matching lines @@
     completion->signal();
 }
 
 void ThreadProxy::renderingStatsOnImplThread(CompletionEvent* completion, RenderingStats* stats)
 {
     DCHECK(isImplThread());
     m_layerTreeHostImpl->renderingStats(stats);
     completion->signal();
 }
 
+void ThreadProxy::RequestVSyncNotification(VSyncClient* client)
+{
+    DCHECK(isImplThread());
+    m_vsyncClient = client;
+    m_layerTreeHostImpl->enableVSyncNotification(client);
+}
+
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : memoryAllocationLimitBytes(0)
 {
 }
 
 ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState()
 {
 }
 
 bool ThreadProxy::commitPendingForTesting()
@@ skipping 96 matching lines @@
 
 void ThreadProxy::renewTreePriorityOnImplThread()
 {
     DCHECK(m_renewTreePriorityOnImplThreadPending);
     m_renewTreePriorityOnImplThreadPending = false;
 
     renewTreePriority();
 }
 
 }  // namespace cc