Revert "WebXR: Do not provide poses to frames without focus"

This reverts commit 666960b1.

Reason for revert: Causing a test bug.  Reverting while I investigate that bug (crbug.com/835047).



Original change's description:
> WebXR: Do not provide poses to frames without focus
>
> This change plumbs through focus (both blink/frame and device) to XRSessions, so we
> only call raf callbacks when focused.
>
> BUG=813230
>
> Change-Id: I0aefdce989f6dd60b4cd0acf1a1477fdb2e845b8
> Reviewed-on: https://chromium-review.googlesource.com/1011288
> Reviewed-by: Brandon Jones <bajones@chromium.org>
> Reviewed-by: David Dorwin <ddorwin@chromium.org>
> Commit-Queue: Bill Orr <billorr@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#551842}

TBR=ddorwin@chromium.org,bajones@chromium.org,billorr@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 813230
Change-Id: I5c1e1dcb9aaef3fe46c085d6572cea81673e4789
Reviewed-on: https://chromium-review.googlesource.com/1020800
Commit-Queue: Bill Orr <billorr@chromium.org>
Reviewed-by: Bill Orr <billorr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#552268}

third_party/blink/renderer/modules/xr/xr.cc

@@ -34,7 +34,6 @@ const char kNoDevicesMessage[] = "No devices found.";
 
 XR::XR(LocalFrame& frame)
     : ContextLifecycleObserver(frame.GetDocument()),
-      FocusChangedObserver(frame.GetPage()),
       devices_synced_(false),
       binding_(this) {
   frame.GetInterfaceProvider().GetInterface(mojo::MakeRequest(&service_));
@@ -50,16 +49,6 @@ XR::XR(LocalFrame& frame)
                       WTF::Bind(&XR::OnDevicesSynced, WrapPersistent(this)));
 }
 
-void XR::FocusedFrameChanged() {
-  // Tell devices that focus changed.
-  for (const auto& device : devices_)
-    device->OnFrameFocusChanged();
-}
-
-bool XR::IsFrameFocused() {
-  return FocusChangedObserver::IsFrameFocused(GetFrame());
-}
-
 ExecutionContext* XR::GetExecutionContext() const {
   return ContextLifecycleObserver::GetExecutionContext();
 }

third_party/blink/renderer/modules/xr/xr.h

@@ -11,7 +11,6 @@
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/core/dom/context_lifecycle_observer.h"
 #include "third_party/blink/renderer/core/dom/events/event_target.h"
-#include "third_party/blink/renderer/core/page/focus_changed_observer.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/wtf/forward.h"
 
@@ -22,8 +21,7 @@ class XRDevice;
 
 class XR final : public EventTargetWithInlineData,
                  public ContextLifecycleObserver,
-                 public device::mojom::blink::VRServiceClient,
-                 public FocusChangedObserver {
+                 public device::mojom::blink::VRServiceClient {
   DEFINE_WRAPPERTYPEINFO();
   USING_GARBAGE_COLLECTED_MIXIN(XR);
 
@@ -46,18 +44,16 @@ class XR final : public EventTargetWithInlineData,
 
   // ContextLifecycleObserver overrides.
   void ContextDestroyed(ExecutionContext*) override;
-  void Trace(blink::Visitor*) override;
 
-  // FocusChangedObserver overrides.
-  void FocusedFrameChanged() override;
-  bool IsFrameFocused();
+  void Dispose();
+
+  void Trace(blink::Visitor*) override;
 
  private:
   explicit XR(LocalFrame& frame);
 
   void OnDevicesSynced();
   void ResolveRequestDevice();
-  void Dispose();
 
   bool devices_synced_;
 

third_party/blink/renderer/modules/xr/xr_device.cc

@@ -128,7 +128,6 @@ ScriptPromise XRDevice::requestSession(
   }
 
   XRSession* session = new XRSession(this, options.exclusive(), output_context);
-  sessions_.insert(session);
 
   if (options.exclusive()) {
     frameProvider()->BeginExclusiveSession(session, resolver);
@@ -139,48 +138,20 @@ ScriptPromise XRDevice::requestSession(
   return promise;
 }
 
-void XRDevice::OnFrameFocusChanged() {
-  OnFocusChanged();
-}
-
-void XRDevice::OnFocusChanged() {
-  // Tell all sessions that focus changed.
-  for (const auto& session : sessions_) {
-    session->OnFocusChanged();
-  }
-
-  if (frame_provider_)
-    frame_provider_->OnFocusChanged();
-}
-
-bool XRDevice::IsFrameFocused() {
-  return xr_->IsFrameFocused();
-}
-
 // TODO: Forward these calls on to the sessions once they've been implemented.
 void XRDevice::OnChanged(device::mojom::blink::VRDisplayInfoPtr display_info) {
   SetXRDisplayInfo(std::move(display_info));
 }
 void XRDevice::OnExitPresent() {}
-void XRDevice::OnBlur() {
-  // The device is reporting to us that it is blurred.  This could happen for a
-  // variety of reasons, such as browser UI, a different application using the
-  // headset, or another page entering an exclusive session.
-  has_device_focus_ = false;
-  OnFocusChanged();
-}
-void XRDevice::OnFocus() {
-  has_device_focus_ = true;
-  OnFocusChanged();
-}
+void XRDevice::OnBlur() {}
+void XRDevice::OnFocus() {}
 void XRDevice::OnActivate(device::mojom::blink::VRDisplayEventReason,
                           OnActivateCallback on_handled) {}
 void XRDevice::OnDeactivate(device::mojom::blink::VRDisplayEventReason) {}
 
 XRFrameProvider* XRDevice::frameProvider() {
-  if (!frame_provider_) {
+  if (!frame_provider_)
     frame_provider_ = new XRFrameProvider(this);
-  }
 
   return frame_provider_;
 }
@@ -202,7 +173,6 @@ void XRDevice::SetXRDisplayInfo(
 void XRDevice::Trace(blink::Visitor* visitor) {
   visitor->Trace(xr_);
   visitor->Trace(frame_provider_);
-  visitor->Trace(sessions_);
   EventTargetWithInlineData::Trace(visitor);
 }
 

third_party/blink/renderer/modules/xr/xr_device.h

@@ -18,7 +18,6 @@ namespace blink {
 
 class XR;
 class XRFrameProvider;
-class XRSession;
 
 class XRDevice final : public EventTargetWithInlineData,
                        public device::mojom::blink::VRDisplayClient {
@@ -41,7 +40,6 @@ class XRDevice final : public EventTargetWithInlineData,
   // EventTarget overrides.
   ExecutionContext* GetExecutionContext() const override;
   const AtomicString& InterfaceName() const override;
-  void Trace(blink::Visitor*) override;
 
   // XRDisplayClient
   void OnChanged(device::mojom::blink::VRDisplayInfoPtr) override;
@@ -70,31 +68,17 @@ class XRDevice final : public EventTargetWithInlineData,
   // depend on it can know when they need to update.
   unsigned int xrDisplayInfoPtrId() const { return display_info_id_; }
 
-  void OnFrameFocusChanged();
-  // The device may report focus to us - for example if another application is
-  // using the headset, or some browsing UI is shown, we may not have device
-  // focus.
-  bool HasDeviceFocus() { return has_device_focus_; }
-  bool HasDeviceAndFrameFocus() { return IsFrameFocused() && HasDeviceFocus(); }
+  void Trace(blink::Visitor*) override;
 
  private:
   void SetXRDisplayInfo(device::mojom::blink::VRDisplayInfoPtr);
 
   const char* checkSessionSupport(const XRSessionCreationOptions&) const;
 
-  // There are two components to focus - whether the frame itself has
-  // traditional focus and whether the device reports that we have focus. These
-  // are aggregated so we can hand out focus/blur events on sessions and
-  // determine when to call animation frame callbacks.
-  void OnFocusChanged();
-  bool IsFrameFocused();
-
   Member<XR> xr_;
   Member<XRFrameProvider> frame_provider_;
-  HeapHashSet<WeakMember<XRSession>> sessions_;
   bool is_external_;
   bool supports_exclusive_;
-  bool has_device_focus_ = true;
 
   device::mojom::blink::VRMagicWindowProviderPtr magic_window_provider_;
   device::mojom::blink::VRDisplayHostPtr display_;

third_party/blink/renderer/modules/xr/xr_frame_provider.cc

@@ -84,8 +84,7 @@ std::unique_ptr<TransformationMatrix> getPoseMatrix(
 
 }  // namespace
 
-XRFrameProvider::XRFrameProvider(XRDevice* device)
-    : device_(device), last_has_focus_(device->HasDeviceAndFrameFocus()) {}
+XRFrameProvider::XRFrameProvider(XRDevice* device) : device_(device) {}
 
 void XRFrameProvider::BeginExclusiveSession(XRSession* session,
                                             ScriptPromiseResolver* resolver) {
@@ -148,20 +147,6 @@ void XRFrameProvider::OnPresentComplete(
   pending_exclusive_session_resolver_ = nullptr;
 }
 
-void XRFrameProvider::OnFocusChanged() {
-  bool focus = device_->HasDeviceAndFrameFocus();
-
-  // If we are gaining focus, schedule a frame.
-  if (focus && !last_has_focus_) {
-    if (exclusive_session_) {
-      ScheduleExclusiveFrame();
-    } else if (requesting_sessions_.size() > 0) {
-      ScheduleNonExclusiveFrame();
-    }
-  }
-  last_has_focus_ = focus;
-}
-
 void XRFrameProvider::OnPresentationProviderConnectionError() {
   if (pending_exclusive_session_resolver_) {
     DOMException* exception = DOMException::Create(
@@ -312,11 +297,6 @@ void XRFrameProvider::ProcessScheduledFrame(double timestamp) {
   TRACE_EVENT1("gpu", "XRFrameProvider::ProcessScheduledFrame", "frame",
                frame_id_);
 
-  if (!device_->HasDeviceAndFrameFocus() && !exclusive_session_) {
-    return;  // Not currently focused, so we won't expose poses (except to
-             // exclusive sessions).
-  }
-
   if (exclusive_session_can_send_frames_) {
     if (frame_pose_ && frame_pose_->input_state.has_value()) {
       exclusive_session_->OnInputStateChange(frame_id_,

third_party/blink/renderer/modules/xr/xr_frame_provider.h

@@ -39,7 +39,6 @@ class XRFrameProvider final
   void UpdateWebGLLayerViewports(XRWebGLLayer*);
 
   void Dispose();
-  void OnFocusChanged();
 
   virtual void Trace(blink::Visitor*);
 
@@ -89,7 +88,6 @@ class XRFrameProvider final
   bool vsync_connection_failed_ = false;
 
   base::Optional<gpu::MailboxHolder> buffer_mailbox_holder_;
-  bool last_has_focus_ = false;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/xr/xr_session.cc

@@ -90,8 +90,6 @@ XRSession::XRSession(XRDevice* device,
       exclusive_(exclusive),
       output_context_(output_context),
       callback_collection_(device->GetExecutionContext()) {
-  blurred_ = !HasAppropriateFocus();
-
   // When an output context is provided, monitor it for resize events.
   if (output_context_) {
     HTMLCanvasElement* canvas = outputContext()->canvas();
@@ -303,22 +301,6 @@ void XRSession::OnBlur() {
   DispatchEvent(XRSessionEvent::Create(EventTypeNames::blur, this));
 }
 
-// Exclusive sessions may still not be blurred in headset even if the page isn't
-// focused.  This prevents the in-headset experience from freezing on an
-// external display headset when the user clicks on another tab.
-bool XRSession::HasAppropriateFocus() {
-  return exclusive_ ? device_->HasDeviceFocus()
-                    : device_->HasDeviceAndFrameFocus();
-}
-
-void XRSession::OnFocusChanged() {
-  if (HasAppropriateFocus()) {
-    OnFocus();
-  } else {
-    OnBlur();
-  }
-}
-
 void XRSession::OnFrame(
     std::unique_ptr<TransformationMatrix> base_pose_matrix,
     const base::Optional<gpu::MailboxHolder>& buffer_mailbox_holder) {

third_party/blink/renderer/modules/xr/xr_session.h

@@ -99,7 +99,8 @@ class XRSession final : public EventTargetWithInlineData {
   ExecutionContext* GetExecutionContext() const override;
   const AtomicString& InterfaceName() const override;
 
-  void OnFocusChanged();
+  void OnFocus();
+  void OnBlur();
   void OnFrame(std::unique_ptr<TransformationMatrix>,
                const base::Optional<gpu::MailboxHolder>&);
   void OnInputStateChange(
@@ -127,10 +128,6 @@ class XRSession final : public EventTargetWithInlineData {
   XRInputSourceEvent* CreateInputSourceEvent(const AtomicString&,
                                              XRInputSource*);
 
-  void OnFocus();
-  void OnBlur();
-  bool HasAppropriateFocus();
-
   const Member<XRDevice> device_;
   const bool exclusive_;
   const Member<XRPresentationContext> output_context_;
@@ -145,7 +142,7 @@ class XRSession final : public EventTargetWithInlineData {
 
   double depth_near_ = 0.1;
   double depth_far_ = 1000.0;
-  bool blurred_;
+  bool blurred_ = false;
   bool ended_ = false;
   bool pending_frame_ = false;
   bool resolving_frame_ = false;