Prevents exiting presentation if triggering DON while presenting.

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/css/StylePropertySet.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/FrameRequestCallback.h"
 #include "core/dom/ScriptedAnimationController.h"
@@ skipping 165 matching lines @@
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, vr_presentation_result_histogram,
       ("VRDisplayPresentResult",
        static_cast<int>(PresentationResult::kPresentationResultMax)));
   vr_presentation_result_histogram.Count(static_cast<int>(result));
 }
 
 ScriptPromise VRDisplay::requestPresent(ScriptState* script_state,
                                         const HeapVector<VRLayer>& layers) {
   DVLOG(1) << __FUNCTION__;
+
+  if (in_display_activate_) {
+    requested_present_in_display_activate_ = true;
+  }
+
   ExecutionContext* execution_context = ExecutionContext::From(script_state);
   UseCounter::Count(execution_context, UseCounter::kVRRequestPresent);
   if (!execution_context->IsSecureContext()) {
     UseCounter::Count(execution_context,
                       UseCounter::kVRRequestPresentInsecureOrigin);
   }
 
   ReportPresentationResult(PresentationResult::kRequested);
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
@@ skipping 97 matching lines @@
       return promise;
     }
 
     pending_present_resolvers_.push_back(resolver);
     submit_frame_client_binding_.Close();
     display_->RequestPresent(
         secure_context,
         submit_frame_client_binding_.CreateInterfacePtrAndBind(),
         ConvertToBaseCallback(
             WTF::Bind(&VRDisplay::OnPresentComplete, WrapPersistent(this))));
-    pending_present_request_ = true;

[mthiesse, 2017/05/10 20:12:38]

You should still set the flag here, or you'll do the wrong thing if presentation
fails above.

[tiborg, 2017/05/10 20:48:57]

I'm just reporting if the page requested present in the vrdisplayactivate
handler. If the presentation fails we should be in non-presenting mode anyways.
So, we don't have to stop presenting after the vrdisplayactivate handler is
done. Or am I missing something here?

   } else {
     UpdateLayerBounds();
     resolver->Resolve();
     ReportPresentationResult(PresentationResult::kSuccessAlreadyPresenting);
   }
 
   return promise;
 }
 
 void VRDisplay::OnPresentComplete(bool success) {
-  pending_present_request_ = false;
   if (success) {
     this->BeginPresent();
   } else {
     this->ForceExitPresent();
     DOMException* exception = DOMException::Create(
         kNotAllowedError, "Presentation request was denied.");
 
     while (!pending_present_resolvers_.IsEmpty()) {
       ScriptPromiseResolver* resolver = pending_present_resolvers_.TakeFirst();
       resolver->Reject(exception);
@@ skipping 353 matching lines @@
   context_gl_ = nullptr;
   pending_submit_frame_ = false;
   pending_previous_frame_render_ = false;
 }
 
 void VRDisplay::OnActivate(device::mojom::blink::VRDisplayEventReason reason,
                            const OnActivateCallback& on_handled) {
   AutoReset<bool> activating(&in_display_activate_, true);
   navigator_vr_->DispatchVREvent(VRDisplayEvent::Create(
       EventTypeNames::vrdisplayactivate, true, false, this, reason));
-  on_handled.Run(pending_present_request_);

[mthiesse, 2017/05/10 21:16:06]

I think we can simply change this to:
on_handled.Run(pending_present_request_ || is_presenting_);

And revert the rest of the changes.

[tiborg, 2017/05/16 15:27:01]

Done. And flipped switch as discussed offline.

+  on_handled.Run(requested_present_in_display_activate_);
+  requested_present_in_display_activate_ = false;
 }
 
 void VRDisplay::OnDeactivate(
     device::mojom::blink::VRDisplayEventReason reason) {
   navigator_vr_->EnqueueVREvent(VRDisplayEvent::Create(
       EventTypeNames::vrdisplaydeactivate, true, false, this, reason));
 }
 
 void VRDisplay::ProcessScheduledWindowAnimations(double timestamp) {
   TRACE_EVENT1("gpu", "VRDisplay::window.rAF", "frame", vr_frame_id_);
@@ skipping 168 matching lines @@
   visitor->Trace(stage_parameters_);
   visitor->Trace(eye_parameters_left_);
   visitor->Trace(eye_parameters_right_);
   visitor->Trace(layer_);
   visitor->Trace(rendering_context_);
   visitor->Trace(scripted_animation_controller_);
   visitor->Trace(pending_present_resolvers_);
 }
 
 }  // namespace blink