Fix a CHECK when monitor configuration changes

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"
@@ skipping 66 matching lines @@
   void Reschedule();
   void OpenAdapter(const wchar_t* device_name);
   void CloseAdapter();
   NTSTATUS WaitForVBlankEvent();
 
   void SendGpuVSyncUpdate(base::TimeTicks now,
                           base::TimeTicks timestamp,
                           base::TimeDelta interval);
   void InvokeCallbackAndReschedule(base::TimeTicks timestamp,
                                    base::TimeDelta interval);
+  void UseDelayBasedVSyncOnError();
   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;
@@ skipping 85 matching lines @@
   }
 }
 
 void GpuVSyncWorker::WaitForVSyncOnThread() {
   DCHECK(BelongsToWorkerThread());
 
   TRACE_EVENT0("gpu", "GpuVSyncWorker::WaitForVSyncOnThread");
 
   HMONITOR monitor =
       MonitorFromWindow(surface_handle_, MONITOR_DEFAULTTONEAREST);
-  MONITORINFOEX monitor_info;
+  MONITORINFOEX monitor_info = {};
   monitor_info.cbSize = sizeof(MONITORINFOEX);
   BOOL success = GetMonitorInfo(monitor, &monitor_info);
-  CHECK(success);
+  if (!success) {
+    // This is possible when a monitor is switched off or disconnected.
+    CloseAdapter();
+    UseDelayBasedVSyncOnError();
+    return;
+  }
 
   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);
   }
 
   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)));
+      UseDelayBasedVSyncOnError();
       return;
     } else {
       base::debug::Alias(&wait_result);
       CHECK(false);
     }
   }
 
   vsync_provider_->GetVSyncParameters(
       base::Bind(&GpuVSyncWorker::SendGpuVSyncUpdate, base::Unretained(this),
                  base::TimeTicks::Now()));
@@ skipping 30 matching lines @@
   if (base::subtle::NoBarrier_Load(&enabled_)) {
     callback_.Run(timestamp, interval);
     task_runner()->PostTask(FROM_HERE,
                             base::Bind(&GpuVSyncWorker::WaitForVSyncOnThread,
                                        base::Unretained(this)));
   } else {
     running_ = false;
   }
 }
 
+void GpuVSyncWorker::UseDelayBasedVSyncOnError() {
+  // This is called in a case of an error.
+  // Use timer based mechanism as a backup for one v-sync cycle, 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)));
+}
+
 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);
@@ skipping 150 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