WebVR: Defer GetVSync calls until the current frame is submitted.

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 111 matching lines @@
   switch (StringToVREye(which_eye)) {
     case kVREyeLeft:
       return eye_parameters_left_;
     case kVREyeRight:
       return eye_parameters_right_;
     default:
       return nullptr;
   }
 }
 
-int VRDisplay::requestAnimationFrame(FrameRequestCallback* callback) {
-  DVLOG(2) << __FUNCTION__;
-  Document* doc = this->GetDocument();
-  if (!doc)
-    return 0;
-  pending_vrdisplay_raf_ = true;
+void VRDisplay::RequestVSync() {
+  DVLOG(2) << __FUNCTION__
+           << " start: pending_vrdisplay_raf_=" << pending_vrdisplay_raf_
+           << " in_animation_frame_=" << in_animation_frame_
+           << " did_submit_this_frame_=" << did_submit_this_frame_;
+
+  // The logic here is a bit subtle. We get called from one of the following
+  // four contexts:
+  //
+  // (a) from requestAnimationFrame if outside an animating context (i.e. the
+  //     first rAF call from inside a getVRDisplays() promise)
+  //
+  // (b) from requestAnimationFrame in an animating context if the JS code
+  //     calls rAF after submitFrame.
+  //
+  // (c) from submitFrame if that is called after rAF.
+  //
+  // (d) from ProcessScheduledAnimations if a rAF callback finishes without
+  //     submitting a frame.
+  //
+  // These cases are mutually exclusive which prevents duplicate RequestVSync
+  // calls. Case (a) only applies outside an animating context
+  // (in_animation_frame_ is false), and (b,c,d) all require an animating
+  // context. While in an animating context, submitFrame is called either
+  // before rAF (b), after rAF (c), or not at all (d). If rAF isn't called at
+  // all, there won't be future frames.
+
   if (!vr_v_sync_provider_.is_bound()) {
     ConnectVSyncProvider();
   } else if (!display_blurred_ && !pending_vsync_) {
     pending_vsync_ = true;
     vr_v_sync_provider_->GetVSync(ConvertToBaseCallback(
         WTF::Bind(&VRDisplay::OnVSync, WrapWeakPersistent(this))));
   }
+
+  DVLOG(2) << __FUNCTION__ << " done:"
+           << " vr_v_sync_provider_.is_bound()="
+           << vr_v_sync_provider_.is_bound()
+           << " pending_vsync_=" << pending_vsync_;
+}
+
+int VRDisplay::requestAnimationFrame(FrameRequestCallback* callback) {
+  DVLOG(2) << __FUNCTION__;
+  Document* doc = this->GetDocument();
+  if (!doc)
+    return 0;
+  pending_vrdisplay_raf_ = true;
+
+  // We want to delay the GetVSync call while presenting to ensure it doesn't
+  // arrive earlier than frame submission, but other than that we want to call
+  // it as early as possible. See comments inside RequestVSync() for more
+  // details on the applicable cases.
+  if (!in_animation_frame_ || did_submit_this_frame_) {
+    RequestVSync();
+  }
   callback->use_legacy_time_base_ = false;
   return EnsureScriptedAnimationController(doc).RegisterCallback(callback);
 }
 
 void VRDisplay::cancelAnimationFrame(int id) {
   DVLOG(2) << __FUNCTION__;
   if (!scripted_animation_controller_)
     return;
   scripted_animation_controller_->CancelCallback(id);
 }
@@ skipping 325 matching lines @@
   HeapVector<VRLayer> layers;
 
   if (is_presenting_) {
     layers.push_back(layer_);
   }
 
   return layers;
 }
 
 void VRDisplay::submitFrame() {
+  DVLOG(2) << __FUNCTION__;
+
   if (!display_)
     return;
   TRACE_EVENT1("gpu", "submitFrame", "frame", vr_frame_id_);
 
   Document* doc = this->GetDocument();
   if (!is_presenting_) {
     if (doc) {
       doc->AddConsoleMessage(ConsoleMessage::Create(
           kRenderingMessageSource, kWarningMessageLevel,
           "submitFrame has no effect when the VRDisplay is not presenting."));
@@ skipping 99 matching lines @@
       }
     }
   }
 
   pending_previous_frame_render_ = true;
   pending_submit_frame_ = true;
   display_->SubmitFrame(
       vr_frame_id_,
       gpu::MailboxHolder(static_image->GetMailbox(),
                          static_image->GetSyncToken(), GL_TEXTURE_2D));
+  did_submit_this_frame_ = true;
+  // If we were deferring a rAF-triggered vsync request, do this now.
+  if (pending_vrdisplay_raf_)
+    RequestVSync();
 
   // If preserveDrawingBuffer is false, must clear now. Normally this
   // happens as part of compositing, but that's not active while
   // presenting, so run the responsible code directly.
   rendering_context_->MarkCompositedAndClearBackbufferIfNeeded();
 
   // If we're not deferring the wait for transferring the mailbox,
   // we need to wait for it now to prevent the image going out of
   // scope before its mailbox is retrieved.
   if (!wait_for_previous_transfer_to_finish) {
     TRACE_EVENT0("gpu", "waitForCurrentTransferToFinish");
     while (pending_submit_frame_) {
       if (!submit_frame_client_binding_.WaitForIncomingMethodCall()) {
         DLOG(ERROR) << "Failed to receive SubmitFrame response";
         break;
       }
     }
   }
 }
 
 void VRDisplay::OnSubmitFrameTransferred() {
+  DVLOG(3) << __FUNCTION__;
   pending_submit_frame_ = false;
 }
 
 void VRDisplay::OnSubmitFrameRendered() {
+  DVLOG(3) << __FUNCTION__;
   pending_previous_frame_render_ = false;
 }
 
 Document* VRDisplay::GetDocument() {
   return navigator_vr_->GetDocument();
 }
 
 void VRDisplay::OnPresentChange() {
   DVLOG(1) << __FUNCTION__ << ": is_presenting_=" << is_presenting_;
   if (is_presenting_ && !is_valid_device_for_presenting_) {
@@ skipping 41 matching lines @@
     // Record user action for stop presenting.  Note that this could be
     // user-triggered or not.
     Platform::Current()->RecordAction(
         UserMetricsAction("VR.WebVR.StopPresenting"));
   }
 
   rendering_context_ = nullptr;
   context_gl_ = nullptr;
   pending_submit_frame_ = false;
   pending_previous_frame_render_ = false;
+  did_submit_this_frame_ = 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_);
 }
 
@@ skipping 44 matching lines @@
   }
 
   TRACE_EVENT1("gpu", "VRDisplay::OnVSync", "frame", vr_frame_id_);
 
   if (pending_vrdisplay_raf_ && scripted_animation_controller_) {
     // Run the callback, making sure that in_animation_frame_ is only
     // true for the vrDisplay rAF and not for a legacy window rAF
     // that may be called later.
     AutoReset<bool> animating(&in_animation_frame_, true);
     pending_vrdisplay_raf_ = false;
+    did_submit_this_frame_ = false;
     scripted_animation_controller_->ServiceScriptedAnimations(timestamp);
+    if (pending_vrdisplay_raf_ && !did_submit_this_frame_) {
+      DVLOG(2) << __FUNCTION__ << ": vrDisplay.rAF did not submit a frame";
+      RequestVSync();
+    }
   }
 
+  // Sanity check: If pending_vrdisplay_raf_ is true and the vsync provider
+  // is connected, we must now have a pending vsync.
+  DCHECK(!pending_vrdisplay_raf_ || !vr_v_sync_provider_.is_bound() ||
+         pending_vsync_);
+
   // For GVR, we shut down normal vsync processing during VR presentation.
   // Trigger any callbacks on window.rAF manually so that they run after
   // completing the vrDisplay.rAF processing.
   if (is_presenting_ && !capabilities_->hasExternalDisplay()) {
     Platform::Current()->CurrentThread()->GetWebTaskRunner()->PostTask(
         BLINK_FROM_HERE, WTF::Bind(&VRDisplay::ProcessScheduledWindowAnimations,
                                    WrapWeakPersistent(this), timestamp));
   }
 }
 
@@ skipping 109 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