OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "content/browser/vr/vr_service.h" |
| 6 |
| 7 #include "base/memory/singleton.h" |
| 8 #include "third_party/WebKit/public/platform/WebVR.h" |
| 9 |
| 10 #if defined(OS_ANDROID) |
| 11 #include "content/browser/vr/cardboard/cardboard_vr_device_provider.h" |
| 12 #endif |
| 13 |
| 14 namespace content { |
| 15 |
| 16 namespace { |
| 17 VRService* g_vr_service = nullptr; |
| 18 } |
| 19 |
| 20 VRService::VRService() : vr_initialized_(false), keep_alive_(false) { |
| 21 #if defined(OS_ANDROID) |
| 22 scoped_ptr<VRDeviceProvider> cardboard_provider( |
| 23 new CardboardVRDeviceProvider()); |
| 24 RegisterProvider(cardboard_provider.Pass()); |
| 25 #endif |
| 26 } |
| 27 |
| 28 VRService::VRService(scoped_ptr<VRDeviceProvider> provider) |
| 29 : vr_initialized_(false), keep_alive_(true) { |
| 30 thread_checker_.DetachFromThread(); |
| 31 RegisterProvider(provider.Pass()); |
| 32 SetInstance(this); |
| 33 } |
| 34 |
| 35 VRService::~VRService() { |
| 36 DCHECK(thread_checker_.CalledOnValidThread()); |
| 37 g_vr_service = nullptr; |
| 38 } |
| 39 |
| 40 VRService* VRService::GetInstance() { |
| 41 if (!g_vr_service) |
| 42 g_vr_service = new VRService(); |
| 43 return g_vr_service; |
| 44 } |
| 45 |
| 46 void VRService::SetInstance(VRService* instance) { |
| 47 // Unit tests can create multiple instances but only one should exist at any |
| 48 // given time so g_vr_service should only go from nullptr to non-nullptr and |
| 49 // vica versa. |
| 50 CHECK_NE(!!instance, !!g_vr_service); |
| 51 g_vr_service = instance; |
| 52 } |
| 53 |
| 54 bool VRService::HasInstance() { |
| 55 // For testing. Checks to see if a VRService instance is active. |
| 56 return !!g_vr_service; |
| 57 } |
| 58 |
| 59 void VRService::GetVRDevices(std::vector<blink::WebVRDevice>* webvr_devices) { |
| 60 DCHECK(thread_checker_.CalledOnValidThread()); |
| 61 |
| 62 if (!webvr_devices) |
| 63 return; |
| 64 |
| 65 InitializeProviders(); |
| 66 |
| 67 webvr_devices->clear(); |
| 68 |
| 69 ProviderList::iterator iter; |
| 70 |
| 71 std::vector<VRDevice*> devices; |
| 72 |
| 73 for (iter = providers_.begin(); iter != providers_.end(); ++iter) { |
| 74 (*iter)->GetDevices(devices); |
| 75 } |
| 76 |
| 77 std::vector<VRDevice*>::iterator diter; |
| 78 for (diter = devices.begin(); diter != devices.end(); ++diter) { |
| 79 VRDevice* device = *diter; |
| 80 |
| 81 if (device->id() == VR_DEVICE_LAST_ID) |
| 82 continue; |
| 83 |
| 84 if (devices_.find(device->id()) == devices_.end()) { |
| 85 devices_[device->id()] = device; |
| 86 } |
| 87 |
| 88 blink::WebVRDevice webvr_device; |
| 89 device->GetVRDevice(&webvr_device); |
| 90 webvr_device.index = device->id(); |
| 91 webvr_devices->push_back(webvr_device); |
| 92 } |
| 93 } |
| 94 |
| 95 VRDevice* VRService::GetDevice(unsigned int index) { |
| 96 DCHECK(thread_checker_.CalledOnValidThread()); |
| 97 |
| 98 DeviceMap::iterator iter = devices_.find(index); |
| 99 if (iter == devices_.end()) { |
| 100 return nullptr; |
| 101 } |
| 102 return iter->second; |
| 103 } |
| 104 |
| 105 void VRService::AddConsumer(VRServiceConsumer* consumer) { |
| 106 VRService* service = GetInstance(); |
| 107 DCHECK(service->thread_checker_.CalledOnValidThread()); |
| 108 |
| 109 // Explicitly does not initialize the providers. That's done lazily the first |
| 110 // time GetVRDevices is called. |
| 111 service->consumers_.insert(consumer); |
| 112 } |
| 113 |
| 114 void VRService::RemoveConsumer(VRServiceConsumer* consumer) { |
| 115 CHECK(g_vr_service); |
| 116 DCHECK(g_vr_service->thread_checker_.CalledOnValidThread()); |
| 117 |
| 118 ConsumerSet::iterator it = g_vr_service->consumers_.find(consumer); |
| 119 DCHECK(it != g_vr_service->consumers_.end()); |
| 120 |
| 121 if (it != g_vr_service->consumers_.end()) { |
| 122 g_vr_service->consumers_.erase(it); |
| 123 if (g_vr_service->consumers_.size() == 0 && !g_vr_service->keep_alive_) { |
| 124 // Delete the service when it has no consumers left. |
| 125 delete g_vr_service; |
| 126 } |
| 127 } |
| 128 } |
| 129 |
| 130 void VRService::InitializeProviders() { |
| 131 if (vr_initialized_) { |
| 132 return; |
| 133 } |
| 134 |
| 135 ProviderList::iterator iter; |
| 136 for (iter = providers_.begin(); iter != providers_.end(); ++iter) { |
| 137 (*iter)->Initialize(); |
| 138 } |
| 139 |
| 140 vr_initialized_ = true; |
| 141 } |
| 142 |
| 143 void VRService::RegisterProvider(scoped_ptr<VRDeviceProvider> provider) { |
| 144 providers_.push_back(make_linked_ptr(provider.release())); |
| 145 } |
| 146 |
| 147 } // namespace content |
OLD | NEW |