Route D3D VSync signal to Compositor

gpu/ipc/service/gpu_command_buffer_stub.cc

 // 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.
 
 #include "gpu/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/memory_pressure_listener.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/service_utils.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "gpu/ipc/service/gpu_memory_manager.h"
 #include "gpu/ipc/service/gpu_memory_tracking.h"
+#include "gpu/ipc/service/gpu_vsync_provider.h"
 #include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "gpu/ipc/service/image_transport_surface.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/init/gl_factory.h"
 
 #if defined(OS_WIN)
@@ skipping 159 matching lines @@
   res->SetInteger("renderer_pid", channel->GetClientPID());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
   return base::WrapUnique(new DevToolsChannelData(res.release()));
 }
 
 CommandBufferId GetCommandBufferID(int channel_id, int32_t route_id) {
   return CommandBufferId::FromUnsafeValue(
       (static_cast<uint64_t>(channel_id) << 32) | route_id);
 }
 
+bool IsGpuVSyncSignalSupported() {

[sunnyps, 2017/01/25 01:36:41]

This should be passed from the browser to gpu process via GpuPreferences.

[stanisc, 2017/01/26 02:14:13]

I think it is doesn't make much sense to over-complicate this considering that
this switch is temporary and should be removed later.

+#if defined(OS_WIN)
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kUseD3DVSync))
+    return true;
+
+  const std::string group_name =
+      base::FieldTrialList::FindFullName("UseD3DVSync");

[jbauman, 2017/01/25 00:00:16]

Could you use base::Feature here instead?

[stanisc, 2017/01/26 02:14:12]

Done.

+  return group_name == "Enabled";
+#else
+  return false;
+#endif  // defined(OS_WIN)
+}
+
 }  // namespace
 
 std::unique_ptr<GpuCommandBufferStub> GpuCommandBufferStub::Create(
     GpuChannel* channel,
     GpuCommandBufferStub* share_command_buffer_stub,
     const GPUCreateCommandBufferConfig& init_params,
     int32_t route_id,
     std::unique_ptr<base::SharedMemory> shared_state_shm) {
   std::unique_ptr<GpuCommandBufferStub> stub(
       new GpuCommandBufferStub(channel, init_params, route_id));
@@ skipping 11 matching lines @@
       initialized_(false),
       surface_handle_(init_params.surface_handle),
       use_virtualized_gl_context_(false),
       command_buffer_id_(GetCommandBufferID(channel->client_id(), route_id)),
       stream_id_(init_params.stream_id),
       route_id_(route_id),
       last_flush_count_(0),
       waiting_for_sync_point_(false),
       previous_processed_num_(0),
       active_url_(init_params.active_url),
-      active_url_hash_(base::Hash(active_url_.possibly_invalid_spec())) {}
+      active_url_hash_(base::Hash(active_url_.possibly_invalid_spec())),
+      gpu_vsync_signal_supported_(IsGpuVSyncSignalSupported()) {}
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 }
 
 GpuMemoryManager* GpuCommandBufferStub::GetMemoryManager() const {
     return channel()->gpu_channel_manager()->gpu_memory_manager();
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
@@ skipping 40 matching lines @@
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncToken,
                         OnWaitSyncToken)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken,
                         OnSignalSyncToken)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery,
                         OnSignalQuery)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
                         OnCreateStreamTexture)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetNeedsVSync, OnSetNeedsVSync);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CheckCompleteWaits();
 
   // Ensure that any delayed work that was created will be handled.
   if (have_context) {
     if (executor_)
       executor_->ProcessPendingQueries();
     ScheduleDelayedWork(
@@ skipping 40 matching lines @@
   return context_group_->feature_info();
 }
 
 void GpuCommandBufferStub::SetLatencyInfoCallback(
     const LatencyInfoCallback& callback) {
   latency_info_callback_ = callback;
 }
 
 void GpuCommandBufferStub::UpdateVSyncParameters(base::TimeTicks timebase,
                                                  base::TimeDelta interval) {
+#if defined(OS_WIN)
+  if (gpu_vsync_signal_supported_) {
+    base::AutoLock lock(vsync_lock_);
+    vsync_interval_ = interval;
+    return;
+  }
+#endif  // defined(OS_WIN)
+
+  SendUpdatedVSyncParameters(timebase, interval);
+}
+
+void GpuCommandBufferStub::UpdateGpuVSync(base::TimeTicks timestamp) {
+  DCHECK(gpu_vsync_signal_supported_);
+
+#if defined(OS_WIN)
+
+  base::TimeDelta interval;
+  {
+    base::AutoLock lock(vsync_lock_);
+    interval = vsync_interval_;
+  }
+
+  SendUpdatedVSyncParameters(timestamp, interval);
+#endif  // defined(OS_WIN)
+}
+
+void GpuCommandBufferStub::SendUpdatedVSyncParameters(

[jbauman, 2017/01/25 00:00:16]

Technically Send on an IPC::SyncChannel can only be called from the main thread.
You'll need to create a SyncMessageFilter using
IPC::SyncChannel::CreateSyncMessageFilter and send on that.

[stanisc, 2017/01/26 02:14:13]

Done.

+    base::TimeTicks timebase,
+    base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 bool GpuCommandBufferStub::IsScheduled() {
   return (!executor_.get() || executor_->scheduled());
 }
 
 void GpuCommandBufferStub::PollWork() {
   // Post another delayed task if we have not yet reached the time at which
@@ skipping 131 matching lines @@
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   executor_.reset();
 
   sync_point_client_.reset();
 
+  vsync_provider_.reset();
+
   bool have_context = false;
   if (decoder_ && decoder_->GetGLContext()) {
     // Try to make the context current regardless of whether it was lost, so we
     // don't leak resources.
     have_context = decoder_->GetGLContext()->MakeCurrent(surface_.get());
   }
   for (auto& observer : destruction_observers_)
     observer.OnWillDestroyStub();
 
   if (decoder_) {
@@ skipping 93 matching lines @@
   } else {
     surface_ = ImageTransportSurface::CreateNativeSurface(
         AsWeakPtr(), surface_handle_, surface_format);
     if (!surface_ || !surface_->Initialize(surface_format)) {
       surface_ = nullptr;
       DLOG(ERROR) << "Failed to create surface.";
       return false;
     }
   }
 
+  if (IsGpuVSyncSignalSupported()) {
+    vsync_provider_ = GpuVSyncProvider::Create(

[jbauman, 2017/01/25 00:00:16]

Only create this for stubs that aren't "offscreen".

[stanisc, 2017/01/26 02:14:13]

Done.

+        base::Bind(&GpuCommandBufferStub::UpdateGpuVSync,
+                   base::Unretained(this)),
+        surface_handle_);
+  }
+
   scoped_refptr<gl::GLContext> context;
   gl::GLShareGroup* gl_share_group = channel_->share_group();
   if (use_virtualized_gl_context_ && gl_share_group) {
     context = gl_share_group->GetSharedContext(surface_.get());
     if (!context.get()) {
       context = gl::init::CreateGLContext(
           gl_share_group, surface_.get(),
           GenerateGLContextAttribs(init_params.attribs,
                                    context_group_->gpu_preferences()));
       if (!context.get()) {
@@ skipping 116 matching lines @@
 }
 
 void GpuCommandBufferStub::OnSetGetBuffer(int32_t shm_id,
                                           IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetGetBuffer");
   if (command_buffer_)
     command_buffer_->SetGetBuffer(shm_id);
   Send(reply_message);
 }
 
+void GpuCommandBufferStub::OnSetNeedsVSync(bool needs_vsync) {
+  DCHECK(vsync_provider_);

[jbauman, 2017/01/25 00:00:16]

if (!vsync_provider_) return;

This message could be sent from an untrusted renderer.

[stanisc, 2017/01/26 02:14:13]

Done.

+  vsync_provider_->SetNeedsVSync(needs_vsync);
+}
+
 void GpuCommandBufferStub::OnTakeFrontBuffer(const Mailbox& mailbox) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnTakeFrontBuffer");
   if (!decoder_) {
     LOG(ERROR) << "Can't take front buffer before initialization.";
     return;
   }
 
   decoder_->TakeFrontBuffer(mailbox);
 }
 
@@ skipping 419 matching lines @@
       command_buffer_->GetLastState().error == error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(error::kUnknown);
   if (decoder_)
     decoder_->MarkContextLost(error::kUnknown);
   command_buffer_->SetParseError(error::kLostContext);
 }
 
 }  // namespace gpu