Notify VRDeviceProviders when there are pages listening for vrdisplayactivate

device/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 "device/vr/vr_device_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "build/build_config.h"
 
 #if defined(OS_ANDROID)
 #include "device/vr/android/gvr/gvr_device_provider.h"
 #endif
 
 namespace device {
 
 namespace {
 VRDeviceManager* g_vr_device_manager = nullptr;
 }
 
 VRDeviceManager::VRDeviceManager()
     : vr_initialized_(false),
       keep_alive_(false),
-      has_scheduled_poll_(false) {
+      has_scheduled_poll_(false),
+      has_activate_listeners_(false) {
 // Register VRDeviceProviders for the current platform
 #if defined(OS_ANDROID)
   RegisterProvider(base::MakeUnique<GvrDeviceProvider>());
 #endif
 }
 
 VRDeviceManager::VRDeviceManager(std::unique_ptr<VRDeviceProvider> provider)
     : vr_initialized_(false), keep_alive_(true), has_scheduled_poll_(false) {
   thread_checker_.DetachFromThread();
   RegisterProvider(std::move(provider));
@@ skipping 35 matching lines @@
 }
 
 void VRDeviceManager::RemoveService(VRServiceImpl* service) {
   services_.erase(std::remove(services_.begin(), services_.end(), service),
                   services_.end());
 
   for (auto device : devices_) {
     device.second->RemoveService(service);
   }
 
+  if (service->listening_for_activate()) {
+    ListeningForActivateChanged(false);
+  }
+
   if (services_.empty() && !keep_alive_) {
     // Delete the device manager when it has no active connections.
     delete g_vr_device_manager;
   }
 }
 
 bool VRDeviceManager::GetVRDevices(VRServiceImpl* service) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   InitializeProviders();
@@ skipping 17 matching lines @@
 
   return true;
 }
 
 unsigned int VRDeviceManager::GetNumberOfConnectedDevices() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return static_cast<unsigned int>(devices_.size());
 }
 
+void VRDeviceManager::ListeningForActivateChanged(bool listening) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  bool activate_listeners = listening;
+  if (!activate_listeners) {
+    for (const auto& service : services_) {
+      if (service->listening_for_activate()) {
+        activate_listeners = true;
+        break;
+      }
+    }
+  }
+
+  // Notify all the providers if this changes
+  if (has_activate_listeners_ != activate_listeners) {
+    has_activate_listeners_ = activate_listeners;
+    for (const auto& provider : providers_)
+      provider->SetListeningForActivate(has_activate_listeners_);
+  }
+}
+
 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;
@@ skipping 32 matching lines @@
   for (const auto& provider : providers_)
     provider->PollEvents();
 }
 
 void VRDeviceManager::StopSchedulingPollEvents() {
   if (has_scheduled_poll_)
     timer_.Stop();
 }
 
 }  // namespace device