GPU VSync: add timer based v-sync as a backup mechanism for when display goes to sleep.

gpu/ipc/service/gpu_vsync_provider_win.cc

 // Copyright (c) 2016 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_vsync_provider_win.h"
 
 #include <string>
 
 #include "base/atomicops.h"
+#include "base/debug/alias.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/vsync_provider_win.h"
 
 #include <windows.h>
 
 namespace gpu {
 
 namespace {
+// Default interval used when no v-sync interval comes from DWM.
+const int kDefaultTimerBasedInterval = 16666;
+
 // from <D3dkmthk.h>
 typedef LONG NTSTATUS;
 typedef UINT D3DKMT_HANDLE;
 typedef UINT D3DDDI_VIDEO_PRESENT_SOURCE_ID;
 
 #define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
+#define STATUS_GRAPHICS_PRESENT_OCCLUDED ((NTSTATUS)0xC01E0006L)
 
 typedef struct _D3DKMT_OPENADAPTERFROMHDC {
   HDC hDc;
   D3DKMT_HANDLE hAdapter;
   LUID AdapterLuid;
   D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId;
 } D3DKMT_OPENADAPTERFROMHDC;
 
 typedef struct _D3DKMT_CLOSEADAPTER {
   D3DKMT_HANDLE hAdapter;
@@ skipping 17 matching lines @@
 class GpuVSyncWorker : public base::Thread,
                        public base::RefCountedThreadSafe<GpuVSyncWorker> {
  public:
   GpuVSyncWorker(const gfx::VSyncProvider::UpdateVSyncCallback& callback,
                  SurfaceHandle surface_handle);
 
   void CleanupAndStop();
   void Enable(bool enabled);
   void StartRunningVSyncOnThread();
   void WaitForVSyncOnThread();
-  void SendVSyncUpdate(base::TimeTicks now,
-                       base::TimeTicks timestamp,
-                       base::TimeDelta interval);
   bool BelongsToWorkerThread();
 
  private:
   friend class base::RefCountedThreadSafe<GpuVSyncWorker>;
   ~GpuVSyncWorker() override;
 
   void Reschedule();
   void OpenAdapter(const wchar_t* device_name);
   void CloseAdapter();
-  bool WaitForVBlankEvent();
+  NTSTATUS WaitForVBlankEvent();
+
+  void SendGpuVSyncUpdate(base::TimeTicks now,
+                          base::TimeTicks timestamp,
+                          base::TimeDelta interval);
+  void InvokeCallbackAndReschedule(base::TimeTicks timestamp,
+                                   base::TimeDelta interval);
+  void ScheduleDelayBasedVSync(base::TimeTicks timebase,
+                               base::TimeDelta interval);
 
   // Specifies whether background tasks are running.
   // This can be set on background thread only.
   bool running_ = false;
 
   // Specified whether the worker is enabled.  This is accessed from both
   // threads but can be changed on the main thread only.
   base::subtle::AtomicWord enabled_ = false;
 
   const gfx::VSyncProvider::UpdateVSyncCallback callback_;
@@ skipping 94 matching lines @@
   monitor_info.cbSize = sizeof(MONITORINFOEX);
   BOOL success = GetMonitorInfo(monitor, &monitor_info);
   CHECK(success);
 
   if (current_device_name_.compare(monitor_info.szDevice) != 0) {
     // Monitor changed. Close the current adapter handle and open a new one.
     CloseAdapter();
     OpenAdapter(monitor_info.szDevice);
   }
 
-  // Crash if WaitForVBlankEvent fails to avoid spinning the loop.
-  CHECK(WaitForVBlankEvent());
+  NTSTATUS wait_result = WaitForVBlankEvent();
+  if (wait_result != STATUS_SUCCESS) {
+    if (wait_result == STATUS_GRAPHICS_PRESENT_OCCLUDED) {
+      // This may be triggered by the monitor going into sleep.
+      // Use timer based mechanism as a backup, start with getting VSync
+      // parameters to determine timebase and interval.
+      // TODO(stanisc): Consider a slower v-sync rate in this particular case.
+      vsync_provider_->GetVSyncParameters(base::Bind(
+          &GpuVSyncWorker::ScheduleDelayBasedVSync, base::Unretained(this)));
+      return;
+    } else {
+      base::debug::Alias(&wait_result);
+      CHECK(false);
+    }
+  }
 
   vsync_provider_->GetVSyncParameters(
-      base::Bind(&GpuVSyncWorker::SendVSyncUpdate, base::Unretained(this),
+      base::Bind(&GpuVSyncWorker::SendGpuVSyncUpdate, base::Unretained(this),
                  base::TimeTicks::Now()));
-
-  Reschedule();
 }
 
-void GpuVSyncWorker::SendVSyncUpdate(base::TimeTicks now,
-                                     base::TimeTicks timestamp,
-                                     base::TimeDelta interval) {
+void GpuVSyncWorker::SendGpuVSyncUpdate(base::TimeTicks now,
+                                        base::TimeTicks timestamp,
+                                        base::TimeDelta interval) {
   base::TimeDelta adjustment;
 
   if (!(timestamp.is_null() || interval.is_zero())) {
     // Timestamp comes from DwmGetCompositionTimingInfo and apparently it might
     // be up to 2-3 vsync cycles in the past or in the future.
     // The adjustment formula was suggested here:
     // http://www.vsynctester.com/firefoxisbroken.html
     adjustment =
         ((now - timestamp + interval / 8) % interval + interval) % interval -
         interval / 8;
     timestamp = now - adjustment;
   } else {
     // DWM must be disabled.
     timestamp = now;
   }
 
-  TRACE_EVENT1("gpu", "GpuVSyncWorker::SendVSyncUpdate", "adjustment",
+  TRACE_EVENT1("gpu", "GpuVSyncWorker::SendGpuVSyncUpdate", "adjustment",
                adjustment.ToInternalValue());
 
+  InvokeCallbackAndReschedule(timestamp, interval);
+}
+
+void GpuVSyncWorker::InvokeCallbackAndReschedule(base::TimeTicks timestamp,
+                                                 base::TimeDelta interval) {
+  // Send update and restart the task if still enabled.
   if (base::subtle::NoBarrier_Load(&enabled_)) {
     callback_.Run(timestamp, interval);
-  }
-}
-
-void GpuVSyncWorker::Reschedule() {
-  // Restart the task if still enabled.
-  if (base::subtle::NoBarrier_Load(&enabled_)) {
     task_runner()->PostTask(FROM_HERE,
                             base::Bind(&GpuVSyncWorker::WaitForVSyncOnThread,
                                        base::Unretained(this)));
   } else {
     running_ = false;
   }
 }
 
+void GpuVSyncWorker::ScheduleDelayBasedVSync(base::TimeTicks timebase,
+                                             base::TimeDelta interval) {
+  // This is called only when WaitForVBlankEvent fails due to monitor going to
+  // sleep.  Use a delay based v-sync as a back-up.
+  if (interval.is_zero()) {
+    interval = base::TimeDelta::FromMicroseconds(kDefaultTimerBasedInterval);
+  }
+
+  base::TimeTicks now = base::TimeTicks::Now();
+  base::TimeTicks next_vsync = now.SnappedToNextTick(timebase, interval);
+
+  task_runner()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&GpuVSyncWorker::InvokeCallbackAndReschedule,
+                 base::Unretained(this), next_vsync, interval),
+      next_vsync - now);
+}
+
 void GpuVSyncWorker::OpenAdapter(const wchar_t* device_name) {
   DCHECK_EQ(0u, current_adapter_handle_);
 
   HDC hdc = CreateDC(NULL, device_name, NULL, NULL);
 
   D3DKMT_OPENADAPTERFROMHDC open_adapter_data;
   open_adapter_data.hDc = hdc;
 
   NTSTATUS result = open_adapter_from_hdc_ptr_(&open_adapter_data);
   DeleteDC(hdc);
@@ skipping 11 matching lines @@
     close_adapter_data.hAdapter = current_adapter_handle_;
 
     NTSTATUS result = close_adapter_ptr_(&close_adapter_data);
     CHECK(result == STATUS_SUCCESS);
 
     current_adapter_handle_ = 0;
     current_device_name_.clear();
   }
 }
 
-bool GpuVSyncWorker::WaitForVBlankEvent() {
+NTSTATUS GpuVSyncWorker::WaitForVBlankEvent() {
   D3DKMT_WAITFORVERTICALBLANKEVENT wait_for_vertical_blank_event_data;
   wait_for_vertical_blank_event_data.hAdapter = current_adapter_handle_;
   wait_for_vertical_blank_event_data.hDevice = 0;
   wait_for_vertical_blank_event_data.VidPnSourceId = current_source_id_;
 
-  NTSTATUS result =
-      wait_for_vertical_blank_event_ptr_(&wait_for_vertical_blank_event_data);
-
-  return result == STATUS_SUCCESS;
+  return wait_for_vertical_blank_event_ptr_(
+      &wait_for_vertical_blank_event_data);
 }
 
 // MessageFilter class for sending and receiving IPC messages
 // directly, avoiding routing them through the main GPU thread.
 class GpuVSyncMessageFilter : public IPC::MessageFilter {
  public:
   explicit GpuVSyncMessageFilter(
       const scoped_refptr<GpuVSyncWorker>& vsync_worker,
       int32_t route_id)
       : vsync_worker_(vsync_worker), route_id_(route_id) {}
@@ skipping 93 matching lines @@
 void GpuVSyncProviderWin::OnVSync(base::TimeTicks timestamp,
                                   base::TimeDelta interval) {
   DCHECK(vsync_worker_->BelongsToWorkerThread());
 
   message_filter_->Send(
       base::MakeUnique<GpuCommandBufferMsg_UpdateVSyncParameters>(
           message_filter_->route_id(), timestamp, interval));
 }
 
 }  // namespace gpu