mojo VR interface simplified

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/Fullscreen.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/ConsoleMessage.h"
@@ skipping 28 matching lines @@
     : 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_fullscreenCheckTimer(this, &VRDisplay::onFullscreenCheck),
+      m_binding(this) {}
 
 VRDisplay::~VRDisplay() {}
 
 VRController* VRDisplay::controller() {
   return m_navigatorVR->controller();
 }
 
 void VRDisplay::update(const device::blink::VRDisplayPtr& display) {
   m_displayId = display->index;
   m_displayName = display->displayName;
@@ skipping 42 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_service)
+      return;
+    device::blink::VRPosePtr pose;
+    m_service->GetPose(&pose);
+    m_framePose = std::move(pose);
     if (m_isPresenting)
       m_canUpdateFramePose = false;
   }
 }
 
 void VRDisplay::resetPose() {
-  controller()->resetPose(m_displayId);
+  if (!m_service)
+    return;
+
+  m_service->ResetPose();
 }
 
 VREyeParameters* VRDisplay::getEyeParameters(const String& whichEye) {
   switch (stringToVREye(whichEye)) {
     case VREyeLeft:
       return m_eyeParametersLeft;
     case VREyeRight:
       return m_eyeParametersRight;
     default:
       return nullptr;
@@ skipping 102 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_service) {
+      DOMException* exception = DOMException::create(
+          InvalidStateError, "The service is no longer active.");
+      resolver->reject(exception);
+      return promise;
+    }
+    m_service->RequestPresent(
+        secureContext, convertToBaseCallback(WTF::bind(
+                           &VRDisplay::onPresentComplete, wrapPersistent(this),
+                           wrapPersistent(resolver))));
   } else {
     updateLayerBounds();
     resolver->resolve();
   }
 
   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_service) {
+    DOMException* exception =
+        DOMException::create(InvalidStateError, "VRService is not available.");
+    resolver->reject(exception);
+    return promise;
+  }
+  m_service->ExitPresent();
 
   resolver->resolve();
 
   forceExitPresent();
 
   return promise;
 }
 
 void VRDisplay::beginPresent(ScriptPromiseResolver* resolver) {
   if (m_capabilities->hasExternalDisplay()) {
@@ skipping 59 matching lines @@
     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_service)
+    return;
+
+  m_service->UpdateLayerBounds(std::move(leftBounds), std::move(rightBounds));
 }
 
 HeapVector<VRLayer> VRDisplay::getLayers() {
   HeapVector<VRLayer> layers;
 
   if (m_isPresenting) {
     layers.append(m_layer);
   }
 
   return layers;
@@ skipping 26 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_service)
+    return;
+
+  m_service->SubmitFrame(m_framePose.Clone());
   m_canUpdateFramePose = true;
 }
 
+void VRDisplay::OnDisplayChanged(device::blink::VRDisplayPtr display) {
+  update(display);
+}
+
+void VRDisplay::OnExitPresent() {
+  forceExitPresent();
+}
+
+void VRDisplay::OnDisplayConnected(device::blink::VRDisplayPtr display) {
+  update(display);
+
+  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_service)
+      return;
+    m_service->ExitPresent();
   }
 }
 
+void VRDisplay::RegisterDisplayService() {
+  m_service->RegisterDisplayService(m_binding.CreateInterfacePtrAndBind());

[leonhsl(Using Gerrit), 2016/10/17 09:03:29]

As mentioned before, m_binding can only be bound once, but I suppose this
function would be called multiple times.

[shaobo.yan, 2016/10/18 01:10:48]

Yes. Will update it.

+}
+
+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);
 }
 
 }  // namespace blink