Provide a vsync notification to the renderer

cc/thread_proxy.h

 // 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.
 
 #ifndef CC_THREAD_PROXY_H_
 #define CC_THREAD_PROXY_H_
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "cc/animation_events.h"
 #include "cc/completion_event.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/proxy.h"
 #include "cc/resource_update_controller.h"
 #include "cc/scheduler.h"
+#include "cc/vsync_time_source.h"
 
 namespace cc {
 
 class InputHandler;
 class LayerTreeHost;
 class ResourceUpdateQueue;
 class Scheduler;
 class ScopedThreadProxy;
 class Thread;
 
-class ThreadProxy : public Proxy, LayerTreeHostImplClient, SchedulerClient, ResourceUpdateControllerClient {
+class ThreadProxy : public Proxy, LayerTreeHostImplClient, SchedulerClient, ResourceUpdateControllerClient, VSyncProvider {
 public:
     static scoped_ptr<Proxy> create(LayerTreeHost*, scoped_ptr<Thread> implThread);
 
     virtual ~ThreadProxy();
 
     // Proxy implementation
     virtual bool compositeAndReadback(void *pixels, const gfx::Rect&) OVERRIDE;
     virtual void startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration) OVERRIDE;
     virtual void finishAllRendering() OVERRIDE;
     virtual bool isStarted() const OVERRIDE;
@@ skipping 15 matching lines @@
     virtual size_t maxPartialTextureUpdates() const OVERRIDE;
     virtual void acquireLayerTextures() OVERRIDE;
     virtual void forceSerializeOnSwapBuffers() OVERRIDE;
     virtual bool commitPendingForTesting() OVERRIDE;
     virtual skia::RefPtr<SkPicture> capturePicture() OVERRIDE;
 
     // LayerTreeHostImplClient implementation
     virtual void didLoseOutputSurfaceOnImplThread() OVERRIDE;
     virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE;
     virtual void onVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval) OVERRIDE;
+    virtual void didVSync(base::TimeTicks frameTime) OVERRIDE;
     virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE;
     virtual void onHasPendingTreeStateChanged(bool hasPendingTree) OVERRIDE;
     virtual void setNeedsRedrawOnImplThread() OVERRIDE;
     virtual void didUploadVisibleHighResolutionTileOnImplThread() OVERRIDE;
     virtual void setNeedsCommitOnImplThread() OVERRIDE;
     virtual void setNeedsManageTilesOnImplThread() OVERRIDE;
     virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE;
     virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE;
     virtual void reduceWastedContentsTextureMemoryOnImplThread() OVERRIDE;
     virtual void sendManagedMemoryStats() OVERRIDE;
     virtual bool isInsideDraw() OVERRIDE;
     virtual void renewTreePriority() OVERRIDE;
 
     // SchedulerClient implementation
     virtual void scheduledActionBeginFrame() OVERRIDE;
     virtual ScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapIfPossible() OVERRIDE;
     virtual ScheduledActionDrawAndSwapResult scheduledActionDrawAndSwapForced() OVERRIDE;
     virtual void scheduledActionCommit() OVERRIDE;
     virtual void scheduledActionCheckForCompletedTileUploads() OVERRIDE;
     virtual void scheduledActionActivatePendingTreeIfNeeded() OVERRIDE;
     virtual void scheduledActionBeginContextRecreation() OVERRIDE;
     virtual void scheduledActionAcquireLayerTexturesForMainThread() OVERRIDE;
     virtual void didAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE;
 
     // ResourceUpdateControllerClient implementation
     virtual void readyToFinalizeTextureUpdates() OVERRIDE;
 
+    // VSyncProvider implementation
+    virtual void RequestVSyncNotification(VSyncClient* client) OVERRIDE;
+
     int maxFramesPendingForTesting() const { return m_schedulerOnImplThread->maxFramesPending(); }
 
 private:
     ThreadProxy(LayerTreeHost*, scoped_ptr<Thread> implThread);
 
     struct BeginFrameAndCommitState {
         BeginFrameAndCommitState();
         ~BeginFrameAndCommitState();
 
         base::TimeTicks monotonicFrameBeginTime;
@@ skipping 91 matching lines @@
 
     // Set when the main thread is waiting on layers to be drawn.
     CompletionEvent* m_textureAcquisitionCompletionEventOnImplThread;
 
     scoped_ptr<ResourceUpdateController> m_currentResourceUpdateControllerOnImplThread;
 
     // Set when the next draw should post didCommitAndDrawFrame to the main thread.
     bool m_nextFrameIsNewlyCommittedFrameOnImplThread;
 
     bool m_renderVSyncEnabled;
+    bool m_renderVSyncNotificationEnabled;
+    VSyncClient* m_vsyncClient;
 
     bool m_insideDraw;
 
     base::TimeDelta m_totalCommitTime;
     size_t m_totalCommitCount;
 
     bool m_deferCommits;
     scoped_ptr<BeginFrameAndCommitState> m_pendingDeferredCommit;
 
     base::TimeTicks m_smoothnessTakesPriorityExpirationTime;
     bool m_renewTreePriorityOnImplThreadPending;
 };
 
 }  // namespace cc
 
 #endif  // CC_THREAD_PROXY_H_