Updated VRService to match the latest Blink WebVR interface.

content/browser/vr/vr_device_manager.cc

 // Copyright 2015 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 "content/browser/vr/vr_device_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/singleton.h"
@@ skipping 59 matching lines @@
   // non-nullptr and vica versa.
   CHECK_NE(!!instance, !!g_vr_device_manager);
   g_vr_device_manager = instance;
 }
 
 bool VRDeviceManager::HasInstance() {
   // For testing. Checks to see if a VRDeviceManager instance is active.
   return !!g_vr_device_manager;
 }
 
-mojo::Array<blink::mojom::VRDeviceInfoPtr> VRDeviceManager::GetVRDevices() {
+mojo::Array<blink::mojom::VRDisplayPtr> VRDeviceManager::GetVRDevices() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   InitializeProviders();
 
   std::vector<VRDevice*> devices;
   for (const auto& provider : providers_)
     provider->GetDevices(&devices);
 
-  mojo::Array<blink::mojom::VRDeviceInfoPtr> out_devices;
+  mojo::Array<blink::mojom::VRDisplayPtr> out_devices;
   for (const auto& device : devices) {
     if (device->id() == VR_DEVICE_LAST_ID)
       continue;
 
     if (devices_.find(device->id()) == devices_.end())
       devices_[device->id()] = device;
 
-    blink::mojom::VRDeviceInfoPtr vr_device_info = device->GetVRDevice();
+    blink::mojom::VRDisplayPtr vr_device_info = device->GetVRDevice();
     if (vr_device_info.is_null())
       continue;
 
     vr_device_info->index = device->id();
     out_devices.push_back(std::move(vr_device_info));
   }
 
   return out_devices;
 }
 
 VRDevice* VRDeviceManager::GetDevice(unsigned int index) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (index == 0) {
+    return NULL;
+  }
+
   DeviceMap::iterator iter = devices_.find(index);
   if (iter == devices_.end()) {
     return nullptr;
   }
   return iter->second;
 }
 
 void VRDeviceManager::InitializeProviders() {
   if (vr_initialized_) {
     return;
   }
 
   for (const auto& provider : providers_)
     provider->Initialize();
 
   vr_initialized_ = true;
 }
 
 void VRDeviceManager::RegisterProvider(
     std::unique_ptr<VRDeviceProvider> provider) {
   providers_.push_back(make_linked_ptr(provider.release()));
 }
 
-void VRDeviceManager::GetDevices(const GetDevicesCallback& callback) {
+void VRDeviceManager::GetDisplays(const GetDisplaysCallback& callback) {
   callback.Run(GetVRDevices());
 }
 
-void VRDeviceManager::GetSensorState(uint32_t index,
-                                     const GetSensorStateCallback& callback) {
+void VRDeviceManager::GetPose(uint32_t index,
+                              const GetPoseCallback& callback) {
   VRDevice* device = GetDevice(index);
   if (device) {
-    callback.Run(device->GetSensorState());
+    callback.Run(device->GetPose());
   } else {
     callback.Run(nullptr);
   }
 }
 
-void VRDeviceManager::ResetSensor(uint32_t index) {
+void VRDeviceManager::ResetPose(uint32_t index) {
   VRDevice* device = GetDevice(index);
   if (device)
-    device->ResetSensor();
+    device->ResetPose();
 }
 
 }  // namespace content