Wired up vrdisplayactivate/deactivate

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

 // Copyright 2016 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/VRDisplay.h"
 
 #include "core/dom/DOMException.h"
 #include "core/dom/FrameRequestCallback.h"
 #include "core/dom/Fullscreen.h"
 #include "core/dom/ScriptedAnimationController.h"
@@ skipping 177 matching lines @@
   callback->m_useLegacyTimeBase = false;
   return ensureScriptedAnimationController(doc).registerCallback(callback);
 }
 
 void VRDisplay::cancelAnimationFrame(int id) {
   if (!m_scriptedAnimationController)
     return;
   m_scriptedAnimationController->cancelCallback(id);
 }
 
-void VRDisplay::OnDisplayBlur() {
+void VRDisplay::OnBlur() {
   m_displayBlurred = true;
-  m_navigatorVR->fireVrDisplayOnBlur(this);
+
+  m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
+      EventTypeNames::vrdisplayblur, true, false, this, ""));
 }
 
-void VRDisplay::OnDisplayFocus() {
+void VRDisplay::OnFocus() {
   m_displayBlurred = false;
   // Restart our internal doc requestAnimationFrame callback, if it fired while
   // the display was blurred.
   // TODO(bajones): Don't use doc->requestAnimationFrame() at all. Animation
   // frames should be tied to the presenting VR display (e.g. should be serviced
   // by GVR library callbacks on Android), and not the doc frame rate.
   if (!m_animationCallbackRequested) {
     Document* doc = m_navigatorVR->document();
     if (!doc)
       return;
     doc->requestAnimationFrame(new VRDisplayFrameRequestCallback(this));
   }
-  m_navigatorVR->fireVrDisplayOnFocus(this);
+  m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
+      EventTypeNames::vrdisplayfocus, true, false, this, ""));
 }
 
 void VRDisplay::serviceScriptedAnimations(double monotonicAnimationStartTime) {
   if (!m_scriptedAnimationController)
     return;
   AutoReset<bool> animating(&m_inAnimationFrame, true);
   m_animationCallbackRequested = false;
 
   // We use an internal rAF callback to run the animation loop at the display
   // speed, and run the user's callback after our internal callback fires.
@@ skipping 195 matching lines @@
     Platform::current()->recordRapporURL("VR.WebVR.PresentSuccess",
                                          WebURL(doc->url()));
   }
 
   m_isPresenting = true;
   ReportPresentationResult(PresentationResult::Success);
 
   updateLayerBounds();
 
   resolver->resolve();
-  m_navigatorVR->fireVRDisplayPresentChange(this);
+  OnPresentChange();
 }
 
 void VRDisplay::forceExitPresent() {
   if (m_isPresenting) {
     if (!m_capabilities->hasExternalDisplay()) {
       Fullscreen::fullyExitFullscreen(m_layer.source()->document());
       m_fullscreenCheckTimer.stop();
     } else {
       // Can't get into this presentation mode, so nothing to do here.
     }
-    m_navigatorVR->fireVRDisplayPresentChange(this);
+    OnPresentChange();
   }
 
   m_isPresenting = false;
   m_renderingContext = nullptr;
   m_contextGL = nullptr;
 }
 
 void VRDisplay::updateLayerBounds() {
   if (!m_display)
     return;
@@ skipping 97 matching lines @@
   // Set the GL state back to what was set by the WebVR application.
   m_renderingContext->restoreScissorEnabled();
   m_renderingContext->restoreScissorBox();
   m_renderingContext->restoreColorMask();
   m_renderingContext->restoreClearColor();
 
   m_display->SubmitFrame(m_framePose.Clone());
   m_canUpdateFramePose = true;
 }
 
-void VRDisplay::OnDisplayChanged(
-    device::mojom::blink::VRDisplayInfoPtr display) {
+void VRDisplay::OnPresentChange() {
+  m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
+      EventTypeNames::vrdisplaypresentchange, true, false, this, ""));
+}
+
+void VRDisplay::OnChanged(device::mojom::blink::VRDisplayInfoPtr display) {
   update(display);
 }
 
 void VRDisplay::OnExitPresent() {
   forceExitPresent();
 }
 
-void VRDisplay::onDisplayConnected() {
-  m_navigatorVR->fireVREvent(VRDisplayEvent::create(
+void VRDisplay::onConnected() {
+  m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
       EventTypeNames::vrdisplayconnect, true, false, this, "connect"));
 }
 
-void VRDisplay::onDisplayDisconnected() {
-  m_navigatorVR->fireVREvent(VRDisplayEvent::create(
+void VRDisplay::onDisconnected() {
+  m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
       EventTypeNames::vrdisplaydisconnect, true, false, this, "disconnect"));
 }
 
+void VRDisplay::OnActivate(device::mojom::blink::VRDisplayEventReason reason) {
+  m_navigatorVR->dispatchVRGestureEvent(VRDisplayEvent::create(
+      EventTypeNames::vrdisplayactivate, true, false, this, reason));
+}
+
+void VRDisplay::OnDeactivate(
+    device::mojom::blink::VRDisplayEventReason reason) {
+  m_navigatorVR->enqueueVREvent(VRDisplayEvent::create(
+      EventTypeNames::vrdisplaydeactivate, true, false, this, reason));
+}
+
 void VRDisplay::onFullscreenCheck(TimerBase*) {
   // TODO: This is a temporary measure to track if fullscreen mode has been
   // exited by the UA. If so we need to end VR presentation. Soon we won't
   // depend on the Fullscreen API to fake VR presentation, so this will
   // become unnessecary. Until that point, though, this seems preferable to
   // adding a bunch of notification plumbing to Fullscreen.
   if (!Fullscreen::isCurrentFullScreenElement(*m_layer.source())) {
     m_isPresenting = false;
-    m_navigatorVR->fireVRDisplayPresentChange(this);
+    OnPresentChange();
     m_fullscreenCheckTimer.stop();
     if (!m_display)
       return;
     m_display->ExitPresent();
   }
 }
 
 ScriptedAnimationController& VRDisplay::ensureScriptedAnimationController(
     Document* doc) {
   if (!m_scriptedAnimationController)
@@ skipping 11 matching lines @@
   visitor->trace(m_capabilities);
   visitor->trace(m_stageParameters);
   visitor->trace(m_eyeParametersLeft);
   visitor->trace(m_eyeParametersRight);
   visitor->trace(m_layer);
   visitor->trace(m_renderingContext);
   visitor->trace(m_scriptedAnimationController);
 }
 
 }  // namespace blink