Fix WebVR so we don't animation when stopped at a JS breakpoint

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 37 matching lines @@
   if (which_eye == "right")
     return kVREyeRight;
   return kVREyeNone;
 }
 
 }  // namespace
 
 VRDisplay::VRDisplay(NavigatorVR* navigator_vr,
                      device::mojom::blink::VRDisplayPtr display,
                      device::mojom::blink::VRDisplayClientRequest request)
-    : ContextLifecycleObserver(navigator_vr->GetDocument()),
+    : SuspendableObject(navigator_vr->GetDocument()),
       navigator_vr_(navigator_vr),
       capabilities_(new VRDisplayCapabilities()),
       eye_parameters_left_(new VREyeParameters()),
       eye_parameters_right_(new VREyeParameters()),
       display_(std::move(display)),
       submit_frame_client_binding_(this),
-      display_client_binding_(this, std::move(request)) {}
+      display_client_binding_(this, std::move(request)) {
+  SuspendIfNeeded();  // Initialize suspended_.
+}
 
 VRDisplay::~VRDisplay() {}
 
+void VRDisplay::Suspend() {
+  suspended_ = true;
+}
+
+void VRDisplay::Resume() {
+  suspended_ = false;
+  if (request_vsync_on_resume_) {

[mthiesse, 2017/06/08 03:26:30]

No need for this boolean. RequestVSync() is always safe to call, and returns
early if you shouldn't schedule the vsync.

[billorr, 2017/06/08 04:20:21]

Done.

+    RequestVSync();
+  }
+}
+
 VRController* VRDisplay::Controller() {
   return navigator_vr_->Controller();
 }
 
 void VRDisplay::Update(const device::mojom::blink::VRDisplayInfoPtr& display) {
   display_id_ = display->index;
   display_name_ = display->displayName;
   is_connected_ = true;
 
   capabilities_->SetHasPosition(display->capabilities->hasPosition);
@@ skipping 715 matching lines @@
   DVLOG(2) << __FUNCTION__;
   // Check if we still have a valid context, the animation controller
   // or document may have disappeared since we scheduled this.
   Document* doc = this->GetDocument();
   if (!doc || display_blurred_) {
     DVLOG(2) << __FUNCTION__ << ": early exit, doc=" << doc
              << " display_blurred_=" << display_blurred_;
     return;
   }
 
+  if (suspended_) {
+    // We are currently suspended - try ProcessScheduledAnimations again later
+    // when we resume.
+    request_vsync_on_resume_ = true;
+    return;
+  }
+
   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);
@@ skipping 89 matching lines @@
 }
 
 ExecutionContext* VRDisplay::GetExecutionContext() const {
   return ContextLifecycleObserver::GetExecutionContext();
 }
 
 const AtomicString& VRDisplay::InterfaceName() const {
   return EventTargetNames::VRDisplay;
 }
 
-void VRDisplay::ContextDestroyed(ExecutionContext*) {
+void VRDisplay::ContextDestroyed(ExecutionContext* context) {
+  SuspendableObject::ContextDestroyed(context);
   ForceExitPresent();
   scripted_animation_controller_.Clear();
 }
 
 bool VRDisplay::HasPendingActivity() const {
   // Prevent V8 from garbage collecting the wrapper object if there are
   // event listeners attached to it.
   return GetExecutionContext() && HasEventListeners();
 }
 
@@ skipping 18 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