Adding WebVR temporary presentation handling on mobile

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"
 #include "modules/vr/VRController.h"
 #include "modules/vr/VRDisplayCapabilities.h"
 #include "modules/vr/VREyeParameters.h"
 #include "modules/vr/VRLayer.h"
 #include "modules/vr/VRPose.h"
 #include "modules/vr/VRStageParameters.h"
 #include "modules/webgl/WebGLRenderingContextBase.h"
 #include "public/platform/Platform.h"
@@ skipping 15 matching lines @@
 
 VRDisplay::VRDisplay(NavigatorVR* navigatorVR)
     : 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_fullscreenCheckTimer(this, &VRDisplay::onFullscreenCheck)
 {
 }
 
 VRDisplay::~VRDisplay()
 {
 }
 
 VRController* VRDisplay::controller()
 {
     return m_navigatorVR->controller();
@@ skipping 71 matching lines @@
 {
     if (Document* document = m_navigatorVR->document())
         document->cancelAnimationFrame(id);
 }
 
 ScriptPromise VRDisplay::requestPresent(ScriptState* scriptState, const HeapVector<VRLayer>& layers)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
+    m_isPresenting = false;
+
     if (!m_capabilities->canPresent()) {
         DOMException* exception = DOMException::create(InvalidStateError, "VRDisplay cannot present");
         resolver->reject(exception);
         return promise;
     }
 
     if (layers.size() == 0 || layers.size() > m_capabilities->maxLayers()) {
         DOMException* exception = DOMException::create(InvalidStateError, "Invalid number of layers.");
         if (m_isPresenting) {
             exitPresent(scriptState);
         }
         resolver->reject(exception);
         return promise;
     }
 
-    // TODO: Implement VR presentation
-    NOTIMPLEMENTED();
+    m_layer = layers[0];
 
-    DOMException* exception = DOMException::create(InvalidStateError, "VR Presentation not implemented");
-    resolver->reject(exception);
+    if (m_layer.source()) {
+        if (!m_capabilities->hasExternalDisplay()) {
+            // TODO: Need a proper VR compositor, but for the moment on mobile
+            // we'll just make the canvas fullscreen so that VrShell can pick it
+            // up through the standard (high latency) compositing path.
+            Fullscreen::from(m_layer.source()->document()).requestFullscreen(*m_layer.source(), Fullscreen::UnprefixedRequest);
+
+            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);

[haraken, 2016/08/23 00:51:29]

It's unfortunate that we need to invoke timers every 1 second just to check the
fullscreen state...

Is there any way to avoid invoking many timers by adding some observer?

+        } else {
+            DOMException* exception = DOMException::create(InvalidStateError, "VR Presentation not implemented for this VRDisplay");
+            resolver->reject(exception);
+        }
+    }
 
     return promise;
 }
 
 ScriptPromise VRDisplay::exitPresent(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
-    // Can't stop presenting if we're not presenting.
-    DOMException* exception = DOMException::create(InvalidStateError, "VRDisplay is not presenting");
-    resolver->reject(exception);
+    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();
+    } 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)
 {
-    NOTIMPLEMENTED();
+    if (!pose) {
+        pose = m_framePose;
+    }
+
+    // Get last orientation
+    float ox = 0.0f, oy = 0.0f, oz = 0.0f, ow = 1.0f;
+    if (!pose || pose->orientation()) {
+        ox = pose->orientation()->data()[0];
+        oy = pose->orientation()->data()[1];
+        oz = pose->orientation()->data()[2];
+        ow = pose->orientation()->data()[3];
+    }
 }
 
 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();
+    }
+}
+
 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