Plumbing through more WebVR presentation code

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/inspector/ConsoleMessage.h"
 #include "modules/vr/NavigatorVR.h"
@@ skipping 150 matching lines @@
 
             m_isPresenting = true;
 
             resolver->resolve();
 
             m_navigatorVR->fireVRDisplayPresentChange(this);
 
             // Check to see if the canvas is still the current fullscreen
             // element once per second.
             m_fullscreenCheckTimer.startRepeating(1.0, BLINK_FROM_HERE);
+
+            controller()->requestPresent(m_displayId);
         } else {
             DOMException* exception = DOMException::create(InvalidStateError, "VR Presentation not implemented for this VRDisplay");
             resolver->reject(exception);
         }
+
+        // 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();
+
+        if (m_layer.hasLeftBounds()) {
+            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.hasRightBounds()) {
+            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));
     } else {
         DOMException* exception = DOMException::create(InvalidStateError, "Invalid layer source");
         resolver->reject(exception);
     }
 
     return promise;
 }
 
 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;
     }
 
     if (!m_capabilities->hasExternalDisplay()) {
         Fullscreen::fullyExitFullscreen(m_layer.source()->document());
         m_fullscreenCheckTimer.stop();
+        controller()->exitPresent(m_displayId);
     } else {
         // Can't get into this presentation mode, so nothing to do here.
     }
 
     m_isPresenting = false;
 
     // TODO: Resolve when exit is confirmed
     resolver->resolve();
 
     m_navigatorVR->fireVRDisplayPresentChange(this);
 
     return promise;
 }
 
 HeapVector<VRLayer> VRDisplay::getLayers()
 {
     HeapVector<VRLayer> layers;
 
     if (m_isPresenting) {
         layers.append(m_layer);
     }
 
     return layers;
 }
 
 void VRDisplay::submitFrame(VRPose* pose)
 {
+    controller()->submitFrame(m_displayId);
 }
 
 void VRDisplay::didProcessTask()
 {
     // Pose should be stable until control is returned to the user agent.
     if (!m_canUpdateFramePose) {
         Platform::current()->currentThread()->removeTaskObserver(this);
         m_canUpdateFramePose = true;
     }
 }
 
 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);
     }
 }
 
 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_framePose);
     visitor->trace(m_layer);
 }
 
 } // namespace blink