WIP WebVR mojo refactor

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 39 matching lines @@
     visitor->trace(m_vrDisplay);
 
     FrameRequestCallback::trace(visitor);
   }
 
   Member<VRDisplay> m_vrDisplay;
 };
 
 }  // namespace
 
-VRDisplay::VRDisplay(NavigatorVR* navigatorVR)
+VRDisplay::VRDisplay(NavigatorVR* navigatorVR,
+                     device::mojom::blink::VRDisplayPtr display)
     : m_navigatorVR(navigatorVR),
-      m_displayId(0),
       m_isConnected(false),
       m_isPresenting(false),
       m_canUpdateFramePose(true),
       m_capabilities(new VRDisplayCapabilities()),
       m_eyeParametersLeft(new VREyeParameters()),
       m_eyeParametersRight(new VREyeParameters()),
       m_depthNear(0.01),
       m_depthFar(10000.0),
       m_fullscreenCheckTimer(this, &VRDisplay::onFullscreenCheck),
       m_animationCallbackRequested(false),
-      m_inAnimationFrame(false) {}
+      m_inAnimationFrame(false),
+      m_display(std::move(display)),
+      m_binding(this) {
+  m_display->SetClient(m_binding.CreateInterfacePtrAndBind());
+}
 
 VRDisplay::~VRDisplay() {}
 
 VRController* VRDisplay::controller() {
   return m_navigatorVR->controller();
 }
 
-void VRDisplay::update(const device::blink::VRDisplayPtr& display) {
+void VRDisplay::update(const device::mojom::blink::VRDisplayInfoPtr& display) {
   m_displayId = display->index;
   m_displayName = display->displayName;
   m_isConnected = true;
 
   m_capabilities->setHasOrientation(display->capabilities->hasOrientation);
   m_capabilities->setHasPosition(display->capabilities->hasPosition);
   m_capabilities->setHasExternalDisplay(
       display->capabilities->hasExternalDisplay);
   m_capabilities->setCanPresent(display->capabilities->canPresent);
   m_capabilities->setMaxLayers(display->capabilities->canPresent ? 1 : 0);
@@ skipping 34 matching lines @@
   if (!m_framePose)
     return nullptr;
 
   VRPose* pose = VRPose::create();
   pose->setPose(m_framePose);
   return pose;
 }
 
 void VRDisplay::updatePose() {
   if (m_canUpdateFramePose) {
-    m_framePose = controller()->getPose(m_displayId);
+    if (!m_display)
+      return;
+    device::mojom::blink::VRPosePtr pose;
+    m_display->GetPose(&pose);
+    m_framePose = std::move(pose);
     if (m_isPresenting)
       m_canUpdateFramePose = false;
   }
 }
 
 void VRDisplay::resetPose() {
-  controller()->resetPose(m_displayId);
+  if (!m_display)
+    return;
+
+  m_display->ResetPose();
 }
 
 VREyeParameters* VRDisplay::getEyeParameters(const String& whichEye) {
   switch (stringToVREye(whichEye)) {
     case VREyeLeft:
       return m_eyeParametersLeft;
     case VREyeRight:
       return m_eyeParametersRight;
     default:
       return nullptr;
@@ skipping 138 matching lines @@
     Fullscreen::requestFullscreen(*m_layer.source(),
                                   Fullscreen::UnprefixedRequest);
 
     // Check to see if the canvas is still the current fullscreen
     // element once per second.
     m_fullscreenCheckTimer.startRepeating(1.0, BLINK_FROM_HERE);
   }
 
   if (firstPresent) {
     bool secureContext = scriptState->getExecutionContext()->isSecureContext();
-    controller()->requestPresent(resolver, m_displayId, secureContext);
+    if (!m_display) {
+      DOMException* exception = DOMException::create(
+          InvalidStateError, "The service is no longer active.");
+      resolver->reject(exception);
+      return promise;
+    }
+    m_display->RequestPresent(
+        secureContext, convertToBaseCallback(WTF::bind(
+                           &VRDisplay::onPresentComplete, wrapPersistent(this),
+                           wrapPersistent(resolver))));
   } else {
     updateLayerBounds();
     resolver->resolve();
     ReportPresentationResult(PresentationResult::SuccessAlreadyPresenting);
   }
 
   return promise;
 }
 
+void VRDisplay::onPresentComplete(ScriptPromiseResolver* resolver,
+                                  bool success) {
+  if (success) {
+    this->beginPresent(resolver);
+  } else {
+    this->forceExitPresent();
+    DOMException* exception = DOMException::create(
+        NotAllowedError, "Presentation request was denied.");
+    resolver->reject(exception);
+  }
+}
+
 ScriptPromise VRDisplay::exitPresent(ScriptState* scriptState) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   if (!m_isPresenting) {
     // Can't stop presenting if we're not presenting.
     DOMException* exception =
         DOMException::create(InvalidStateError, "VRDisplay is not presenting.");
     resolver->reject(exception);
     return promise;
   }
 
-  controller()->exitPresent(m_displayId);
+  if (!m_display) {
+    DOMException* exception =
+        DOMException::create(InvalidStateError, "VRService is not available.");
+    resolver->reject(exception);
+    return promise;
+  }
+  m_display->ExitPresent();
 
   resolver->resolve();
 
   forceExitPresent();
 
   return promise;
 }
 
 void VRDisplay::beginPresent(ScriptPromiseResolver* resolver) {
   if (m_capabilities->hasExternalDisplay()) {
@@ skipping 27 matching lines @@
     m_navigatorVR->fireVRDisplayPresentChange(this);
   }
 
   m_isPresenting = false;
   m_renderingContext = nullptr;
   m_contextGL = nullptr;
 }
 
 void VRDisplay::updateLayerBounds() {
   // Set up the texture bounds for the provided layer
-  device::blink::VRLayerBoundsPtr leftBounds =
-      device::blink::VRLayerBounds::New();
-  device::blink::VRLayerBoundsPtr rightBounds =
-      device::blink::VRLayerBounds::New();
+  device::mojom::blink::VRLayerBoundsPtr leftBounds =
+      device::mojom::blink::VRLayerBounds::New();
+  device::mojom::blink::VRLayerBoundsPtr rightBounds =
+      device::mojom::blink::VRLayerBounds::New();
 
   if (m_layer.leftBounds().size() == 4) {
     leftBounds->left = m_layer.leftBounds()[0];
     leftBounds->top = m_layer.leftBounds()[1];
     leftBounds->width = m_layer.leftBounds()[2];
     leftBounds->height = m_layer.leftBounds()[3];
   } else {
     // Left eye defaults
     leftBounds->left = 0.0f;
     leftBounds->top = 0.0f;
     leftBounds->width = 0.5f;
     leftBounds->height = 1.0f;
   }
 
   if (m_layer.rightBounds().size() == 4) {
     rightBounds->left = m_layer.rightBounds()[0];
     rightBounds->top = m_layer.rightBounds()[1];
     rightBounds->width = m_layer.rightBounds()[2];
     rightBounds->height = m_layer.rightBounds()[3];
   } else {
     // Right eye defaults
     rightBounds->left = 0.5f;
     rightBounds->top = 0.0f;
     rightBounds->width = 0.5f;
     rightBounds->height = 1.0f;
   }
 
-  controller()->updateLayerBounds(m_displayId, std::move(leftBounds),
-                                  std::move(rightBounds));
+  if (!m_display)
+    return;
+
+  m_display->UpdateLayerBounds(std::move(leftBounds), std::move(rightBounds));
 }
 
 HeapVector<VRLayer> VRDisplay::getLayers() {
   HeapVector<VRLayer> layers;
 
   if (m_isPresenting) {
     layers.append(m_layer);
   }
 
   return layers;
@@ skipping 46 matching lines @@
   gl->ClearColor((idx & 255) / 255.0f, ((idx >> 8) & 255) / 255.0f,
                  ((idx >> 16) & 255) / 255.0f, 1.0f);
   gl->Clear(GL_COLOR_BUFFER_BIT);
 
   // 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();
 
-  controller()->submitFrame(m_displayId, m_framePose.Clone());
+  if (!m_display)
+    return;
+
+  m_display->SubmitFrame(m_framePose.Clone());
   m_canUpdateFramePose = true;
 }
 
+void VRDisplay::OnDisplayChanged(
+    device::mojom::blink::VRDisplayInfoPtr display) {
+  update(display);
+}
+
+void VRDisplay::OnExitPresent() {
+  forceExitPresent();
+}
+
+void VRDisplay::onDisplayConnected() {
+  m_navigatorVR->fireVREvent(VRDisplayEvent::create(
+      EventTypeNames::vrdisplayconnect, true, false, this, "connect"));
+}
+
+void VRDisplay::onDisplayDisconnected() {
+  m_navigatorVR->fireVREvent(VRDisplayEvent::create(
+      EventTypeNames::vrdisplaydisconnect, true, false, this, "disconnect"));
+}
+
 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);
     m_fullscreenCheckTimer.stop();
-    controller()->exitPresent(m_displayId);
+    if (!m_display)
+      return;
+    m_display->ExitPresent();
   }
 }
 
 ScriptedAnimationController& VRDisplay::ensureScriptedAnimationController(
     Document* doc) {
   if (!m_scriptedAnimationController)
     m_scriptedAnimationController = ScriptedAnimationController::create(doc);
 
   return *m_scriptedAnimationController;
 }
 
+void VRDisplay::shutdownMessagePipe() {
+  m_binding.Close();
+}
+
 DEFINE_TRACE(VRDisplay) {
   visitor->trace(m_navigatorVR);
   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