[Do not submit] D3DKMTWaitForVerticalBlankEvent VSync prototype

gpu/ipc/service/gpu_command_buffer_stub.h

 // Copyright (c) 2012 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 GPU_IPC_SERVICE_GPU_COMMAND_BUFFER_STUB_H_
 #define GPU_IPC_SERVICE_GPU_COMMAND_BUFFER_STUB_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/command_buffer_id.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/gpu_export.h"
 #include "gpu/ipc/common/surface_handle.h"
 #include "gpu/ipc/service/gpu_memory_manager.h"
@@ skipping 14 matching lines @@
 class SyncPointClient;
 }
 
 struct GPUCreateCommandBufferConfig;
 struct GpuCommandBufferMsg_CreateImage_Params;
 
 namespace gpu {
 
 class GpuChannel;
 struct WaitForCommandState;
+class GpuVSyncProvider;
 
 class GPU_EXPORT GpuCommandBufferStub
     : public IPC::Listener,
       public IPC::Sender,
       public ImageTransportSurfaceDelegate,
       public base::SupportsWeakPtr<GpuCommandBufferStub> {
  public:
   class DestructionObserver {
    public:
     // Called in Destroy(), before the context/surface are released.
@@ skipping 23 matching lines @@
 
 // ImageTransportSurfaceDelegate implementation:
 #if defined(OS_WIN)
   void DidCreateAcceleratedSurfaceChildWindow(
       SurfaceHandle parent_window,
       SurfaceHandle child_window) override;
 #endif
   void DidSwapBuffersComplete(SwapBuffersCompleteParams params) override;
   const gles2::FeatureInfo* GetFeatureInfo() const override;
   void SetLatencyInfoCallback(const LatencyInfoCallback& callback) override;
+  // This is called from VSyncProvider to update parameters for generating
+  // timer-based VSync signals on the browser side.
   void UpdateVSyncParameters(base::TimeTicks timebase,
                              base::TimeDelta interval) override;
 
+  // This is called from GpuVSyncProvider with actual GPU VSync signals.
+  void UpdateGpuVSync(base::TimeTicks timestamp);
+
+  // Send VSync signals or VSync parameters over IPC.
+  void SendUpdatedVSyncParameters(base::TimeTicks timebase,
+                                  base::TimeDelta interval);
+
   gles2::MemoryTracker* GetMemoryTracker() const;
 
   // Whether this command buffer can currently handle IPC messages.
   bool IsScheduled();
 
   // Whether there are commands in the buffer that haven't been processed.
   bool HasUnprocessedCommands();
 
   gles2::GLES2Decoder* decoder() const { return decoder_.get(); }
   CommandExecutor* scheduler() const { return executor_.get(); }
@@ skipping 72 matching lines @@
                                 uint64_t release);
 
   void OnDescheduleUntilFinished();
   void OnRescheduleAfterFinished();
 
   void OnCreateImage(const GpuCommandBufferMsg_CreateImage_Params& params);
   void OnDestroyImage(int32_t id);
   void OnCreateStreamTexture(uint32_t texture_id,
                              int32_t stream_id,
                              bool* succeeded);
+  void OnEnableVSync(bool enabled);
   void OnCommandProcessed();
   void OnParseError();
 
   void ReportState();
 
   // Wrapper for CommandExecutor::PutChanged that sets the crash report URL.
   void PutChanged();
 
   // Poll the command buffer to execute work.
   void PollWork();
@@ skipping 42 matching lines @@
   base::TimeTicks last_idle_time_;
 
   LatencyInfoCallback latency_info_callback_;
 
   GURL active_url_;
   size_t active_url_hash_;
 
   std::unique_ptr<WaitForCommandState> wait_for_token_;
   std::unique_ptr<WaitForCommandState> wait_for_get_offset_;
 
+  bool gpu_vsync_signal_supported_;
+  std::unique_ptr<GpuVSyncProvider> vsync_provider_;
+
+#if defined(OS_WIN)
+  // TODO: This isn't ideal, but for now VSync interval is still
+  // provided via UpdateVSyncParameters on the main thread, but
+  // it needs to be passed along with VSync signal when VSync becomes
+  // available on background thread.
+  // The current solution is to temporarily store vsync_interval_.
+  // Perhaps this could be avoided by calculating the interval from
+  // consecutive VSync signals.
+  base::TimeDelta vsync_interval_;
+  base::Lock vsync_lock_;
+#endif  // defined(OS_WIN)
+
   DISALLOW_COPY_AND_ASSIGN(GpuCommandBufferStub);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_IPC_SERVICE_GPU_COMMAND_BUFFER_STUB_H_