Add event listening function to openvr device

device/vr/openvr/openvr_device.cc

 // Copyright (c) 2017 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.
 
 #define _USE_MATH_DEFINES  // for M_PI
 #include "device/vr/openvr/openvr_device.h"
 #include <math.h>
 #include "third_party/openvr/src/headers/openvr.h"
 
 namespace {
@@ skipping 58 matching lines @@
   transform[13] = mat.m[1][3];
   transform[14] = mat.m[2][3];
   transform[15] = 1.0f;
   return transform;
 }
 
 }  // namespace
 
 namespace device {
 
-OpenVRDevice::OpenVRDevice(vr::IVRSystem* vr) : vr_system_(vr) {}
+OpenVRDevice::OpenVRDevice(vr::IVRSystem* vr)
+    : vr_system_(vr), weak_ptr_factory_(this), is_polling_events_(false) {}
 OpenVRDevice::~OpenVRDevice() {}
 
 void OpenVRDevice::CreateVRDisplayInfo(
     const base::Callback<void(mojom::VRDisplayInfoPtr)>& on_created) {
   if (!vr_system_) {
     on_created.Run(nullptr);
     return;
   }
 
   mojom::VRDisplayInfoPtr device = mojom::VRDisplayInfo::New();
@@ skipping 45 matching lines @@
 
   vr::IVRChaperone* chaperone = vr::VRChaperone();
   if (chaperone) {
     chaperone->GetPlayAreaSize(&device->stageParameters->sizeX,
                                &device->stageParameters->sizeZ);
   } else {
     device->stageParameters->sizeX = 0.0f;
     device->stageParameters->sizeZ = 0.0f;
   }
 
-  render_loop_ = std::make_unique<OpenVRRenderLoop>(vr_system_);
+  // If it is first initialization, OpenVRRenderLoop instance need to be
+  // careated and callback need to be registed.

[bajones, 2017/04/26 18:06:05]

careated => created, I assume

+  if (!render_loop_) {
+    render_loop_ = std::make_unique<OpenVRRenderLoop>(vr_system_);
+
+    render_loop_->RegistPollingEventCallback(base::Bind(
+        &OpenVRDevice::OnPollingEvents, weak_ptr_factory_.GetWeakPtr()));
+  }
 
   on_created.Run(std::move(device));
 }
 
 void OpenVRDevice::RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                                   const base::Callback<void(bool)>& callback) {
   callback.Run(false);
   // We don't support presentation currently.
 }
 
@@ skipping 70 matching lines @@
     pose->position.value()[1] = m[1][3];
     pose->position.value()[2] = m[2][3];
 
     pose->linearVelocity = HmdVector3ToWebVR(hmdPose.vVelocity);
     pose->angularVelocity = HmdVector3ToWebVR(hmdPose.vAngularVelocity);
   }
 
   return std::move(pose);
 }
 
+// Only deal with event which will cause displayInfo changed now.
+void OpenVRDevice::OnPollingEvents() {
+  if (!vr_system_ || is_polling_events_)
+    return;
+
+  vr::VREvent_t event;
+  bool is_changed = false;
+  while (vr_system_->PollNextEvent(&event, sizeof(event))) {
+    if (event.trackedDeviceIndex != vr::k_unTrackedDeviceIndex_Hmd &&
+        event.trackedDeviceIndex != vr::k_unTrackedDeviceIndexInvalid) {
+      continue;
+    }
+
+    switch (event.eventType) {
+      case vr::VREvent_TrackedDeviceUpdated:
+      case vr::VREvent_IpdChanged:
+      case vr::VREvent_ChaperoneDataHasChanged:
+      case vr::VREvent_ChaperoneSettingsHaveChanged:
+      case vr::VREvent_ChaperoneUniverseHasChanged:
+        is_changed = true;
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  if (is_changed) {
+    OnChanged();
+  }
+}
+
+// Regist a callback function to deal with system event.
+void OpenVRDevice::OpenVRRenderLoop::RegistPollingEventCallback(
+    const base::Callback<void()>& onPollingEvents) {
+  if (onPollingEvents.is_null())
+    return;
+
+  on_polling_events_ = onPollingEvents;
+}
+
+void OpenVRDevice::OpenVRRenderLoop::UnregistPollingEventCallback() {
+  on_polling_events_.Reset();
+}
+
 void OpenVRDevice::OpenVRRenderLoop::GetVSync(
     const mojom::VRVSyncProvider::GetVSyncCallback& callback) {
   static int16_t next_frame = 0;
   int16_t frame = next_frame++;
 
+  // VSync could be used as a signal to poll event.
+  if (!on_polling_events_.is_null()) {
+    on_polling_events_.Run();

[bajones, 2017/04/26 18:06:05]

This does not appear to be thread safe to me, given that the OpenVRRenderLoop is
in a different thread from the OpenVRDevice.

Given that the OpenVRRenderLoop already has access to vr_system_, though, it
seems like the cleanest thing to do would be to put OnPollingEvents on the
OpenVRRenderLoop object as well and, if changes are detected, call OnChanged via
a PostMessage.

[mthiesse, 2017/04/26 18:14:16]

Alternatively you can post to an anonymous-namespace function that just runs the
callback on the thread you post to. See RunVRDisplayInfoCallback in
vr_shell_gl.cc for an example.

+  }
+
   // TODO(BillOrr): Give real values when VSync loop is hooked up.  This is the
   // presentation time for the frame. Just returning a default value for now
   // since we don't have VSync hooked up.
   base::TimeDelta time = base::TimeDelta::FromSecondsD(2.0);
 
   device::mojom::VRPosePtr pose = getPose();
   Sleep(11);  // TODO (billorr): Use real vsync timing instead of a sleep (this
               // sleep just throttles vsyncs so we don't fill message queues).
   callback.Run(std::move(pose), time, frame,
                device::mojom::VRVSyncProvider::Status::SUCCESS);
 }
 
 }  // namespace device