Provide WebVR pose data only to the focused frame.

third_party/WebKit/Source/modules/vr/NavigatorVR.cpp

 // 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 "modules/vr/NavigatorVR.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/Fullscreen.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Navigator.h"
 #include "core/frame/UseCounter.h"
+#include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "modules/vr/VRController.h"
 #include "modules/vr/VRDisplay.h"
 #include "modules/vr/VRGetDevicesCallback.h"
 #include "modules/vr/VRPose.h"
 #include "platform/UserGestureIndicator.h"
 #include "public/platform/Platform.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
+namespace {
+bool isFrameFocused(LocalFrame* frame) {

[haraken, 2017/02/03 18:46:18]

I'd move this to FocusChangedObserver.

[mthiesse, 2017/02/03 20:47:29]

Done.

+  if (!frame)
+    return false;
+  Page* page = frame->page();
+  if (!page)
+    return false;
+  const FocusController& controller = page->focusController();
+  return controller.isFocused() && (controller.focusedOrMainFrame() == frame);
+}
+}  // namespace
+
 NavigatorVR* NavigatorVR::from(Document& document) {
   if (!document.frame() || !document.frame()->domWindow())
     return 0;
   Navigator& navigator = *document.frame()->domWindow()->navigator();
   return &from(navigator);
 }
 
 NavigatorVR& NavigatorVR::from(Navigator& navigator) {
   NavigatorVR* supplement = static_cast<NavigatorVR*>(
       Supplement<Navigator>::from(navigator, supplementName()));
@@ skipping 32 matching lines @@
 
   return promise;
 }
 
 VRController* NavigatorVR::controller() {
   if (!supplementable()->frame())
     return 0;
 
   if (!m_controller) {
     m_controller = new VRController(this);
+    m_controller->setListeningForActivate(m_focused && m_listeningForActivate);
+    m_controller->focusChanged(m_focused);
   }
 
   return m_controller;
 }
 
 Document* NavigatorVR::document() {
   return supplementable()->frame() ? supplementable()->frame()->document()
                                    : nullptr;
 }
 
 DEFINE_TRACE(NavigatorVR) {
   visitor->trace(m_controller);
   Supplement<Navigator>::trace(visitor);
-  PageVisibilityObserver::trace(visitor);
 }
 
 NavigatorVR::NavigatorVR(Navigator& navigator)
-    : Supplement<Navigator>(navigator),
-      PageVisibilityObserver(navigator.frame()->page()) {
+    : Supplement<Navigator>(navigator) {
   navigator.frame()->domWindow()->registerEventListenerObserver(this);
+  navigator.frame()->page()->focusController().registerFocusChangedObserver(
+      this);
+  focusedFrameChanged();
 }
 
 NavigatorVR::~NavigatorVR() {}
 
 const char* NavigatorVR::supplementName() {
   return "NavigatorVR";
 }
 
 void NavigatorVR::enqueueVREvent(VRDisplayEvent* event) {
   if (supplementable()->frame()) {
     supplementable()->frame()->domWindow()->enqueueWindowEvent(event);
   }
 }
 
 void NavigatorVR::dispatchVRGestureEvent(VRDisplayEvent* event) {
   if (!(supplementable()->frame()))
     return;
   UserGestureIndicator gestureIndicator(
       DocumentUserGestureToken::create(document()));
   LocalDOMWindow* window = supplementable()->frame()->domWindow();
   DCHECK(window);
   event->setTarget(window);
   window->dispatchEvent(event);
 }
 
-void NavigatorVR::pageVisibilityChanged() {
-  if (!page())
+void NavigatorVR::focusedFrameChanged() {
+  bool focused = isFrameFocused(supplementable()->frame());
+  if (focused == m_focused)
     return;
+  m_focused = focused;
   if (m_controller) {
-    m_controller->setListeningForActivate(page()->isPageVisible() &&
-                                          m_listeningForActivate);
+    m_controller->setListeningForActivate(m_listeningForActivate && focused);
+    m_controller->focusChanged(focused);
   }
 }
 
 void NavigatorVR::didAddEventListener(LocalDOMWindow* window,
                                       const AtomicString& eventType) {
   // TODO(mthiesse): Remove fullscreen requirement for presentation. See
   // crbug.com/687369
   if (eventType == EventTypeNames::vrdisplayactivate &&
       supplementable()->frame() && supplementable()->frame()->document() &&
       Fullscreen::fullscreenEnabled(*supplementable()->frame()->document())) {
-    controller()->setListeningForActivate(true);
     m_listeningForActivate = true;
+    controller()->setListeningForActivate(m_focused);
   } else if (eventType == EventTypeNames::vrdisplayconnect) {
     // If the page is listening for connection events make sure we've created a
     // controller so that we'll be notified of new devices.
     controller();
   }
 }
 
 void NavigatorVR::didRemoveEventListener(LocalDOMWindow* window,
                                          const AtomicString& eventType) {
   if (eventType == EventTypeNames::vrdisplayactivate &&
       !window->hasEventListeners(EventTypeNames::vrdisplayactivate)) {
+    m_listeningForActivate = false;
     controller()->setListeningForActivate(false);
-    m_listeningForActivate = false;
   }
 }
 
 void NavigatorVR::didRemoveAllEventListeners(LocalDOMWindow* window) {
   if (m_controller) {
     m_controller->setListeningForActivate(false);
     m_listeningForActivate = false;
   }
 }
 
 }  // namespace blink