Add class to keep track of outstanding `XR:requestSession()` calls

This change adds PendingRequestSessionQuery class to encapsulate
outstanding `requestSession()` calls. It will automatically record
UKM entries when the request is resolved or rejected.

Rename PendingSessionQuery to PendingSupportsSessionQuery.

Bug: 968622
Change-Id: Id33524182eb555802d1ef02fc78741b4276ec290
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1648788Reviewed-by: Alexander Cooper <alcooper@chromium.org>
Commit-Queue: Piotr Bialecki <bialpio@chromium.org>
Cr-Commit-Position: refs/heads/master@{#667364}

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

@@ -86,13 +86,75 @@ bool AreArRuntimeFeaturesEnabled(const FeatureContext* context) {
 
 }  // namespace
 
-XR::PendingSessionQuery::PendingSessionQuery(
+XR::PendingSupportsSessionQuery::PendingSupportsSessionQuery(
     ScriptPromiseResolver* resolver,
     XRSession::SessionMode session_mode)
-    : resolver(resolver), mode(session_mode) {}
+    : resolver_(resolver), mode_(session_mode) {}
 
-void XR::PendingSessionQuery::Trace(blink::Visitor* visitor) {
-  visitor->Trace(resolver);
+void XR::PendingSupportsSessionQuery::Trace(blink::Visitor* visitor) {
+  visitor->Trace(resolver_);
+}
+
+void XR::PendingSupportsSessionQuery::Resolve() {
+  resolver_->Resolve();
+}
+
+void XR::PendingSupportsSessionQuery::Reject(DOMException* exception) {
+  resolver_->Reject(exception);
+}
+
+void XR::PendingSupportsSessionQuery::Reject(v8::Local<v8::Value> value) {
+  resolver_->Reject(value);
+}
+
+XRSession::SessionMode XR::PendingSupportsSessionQuery::mode() const {
+  return mode_;
+}
+
+XR::PendingRequestSessionQuery::PendingRequestSessionQuery(
+    int64_t ukm_source_id,
+    ScriptPromiseResolver* resolver,
+    XRSession::SessionMode session_mode)
+    : resolver_(resolver), mode_(session_mode), ukm_source_id_(ukm_source_id) {}
+
+void XR::PendingRequestSessionQuery::Resolve(XRSession* session) {
+  ReportRequestSessionResult(SessionRequestStatus::kSuccess);
+  resolver_->Resolve(session);
+}
+
+void XR::PendingRequestSessionQuery::Reject(DOMException* exception) {
+  ReportRequestSessionResult(SessionRequestStatus::kOtherError);
+  resolver_->Reject(exception);
+}
+
+void XR::PendingRequestSessionQuery::Reject(v8::Local<v8::Value> value) {
+  ReportRequestSessionResult(SessionRequestStatus::kOtherError);
+  resolver_->Reject(value);
+}
+
+XRSession::SessionMode XR::PendingRequestSessionQuery::mode() const {
+  return mode_;
+}
+
+ScriptState* XR::PendingRequestSessionQuery::GetScriptState() const {
+  return resolver_->GetScriptState();
+}
+
+void XR::PendingRequestSessionQuery::Trace(blink::Visitor* visitor) {
+  visitor->Trace(resolver_);
+}
+
+void XR::PendingRequestSessionQuery::ReportRequestSessionResult(
+    SessionRequestStatus status) {
+  Document* doc =
+      resolver_->GetFrame() ? resolver_->GetFrame()->GetDocument() : nullptr;
+  if (!doc)
+    return;
+
+  ukm::builders::XR_WebXR_SessionRequest(ukm_source_id_)
+      .SetMode(static_cast<int64_t>(mode_))
+      .SetStatus(static_cast<int64_t>(status))
+      .Record(doc->UkmRecorder());
 }
 
 XR::XR(LocalFrame& frame, int64_t ukm_source_id)
@@ -180,35 +242,34 @@ ScriptPromise XR::supportsSession(ScriptState* script_state,
   Document* doc = frame->GetDocument();
   XRSession::SessionMode session_mode = stringToSessionMode(mode);
 
+  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
+  ScriptPromise promise = resolver->Promise();
+
+  PendingSupportsSessionQuery* query =
+      MakeGarbageCollected<PendingSupportsSessionQuery>(resolver, session_mode);
+
   if (session_mode == XRSession::kModeImmersiveAR &&
       !AreArRuntimeFeaturesEnabled(doc)) {
-    return ScriptPromise::Reject(
-        script_state, V8ThrowException::CreateTypeError(
+    query->Reject(V8ThrowException::CreateTypeError(
         script_state->GetIsolate(),
         String::Format(kImmersiveArModeNotValid, __func__)));
+    return promise;
   }
 
   if (!doc->IsFeatureEnabled(mojom::FeaturePolicyFeature::kWebVr,
                              ReportOptions::kReportOnFailure)) {
     // Only allow the call to be made if the appropriate feature policy is in
     // place.
-    return ScriptPromise::RejectWithDOMException(
-        script_state,
-        MakeGarbageCollected<DOMException>(DOMExceptionCode::kSecurityError,
-                                           kFeaturePolicyBlocked));
+    query->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kSecurityError, kFeaturePolicyBlocked));
+    return promise;
   }
 
-  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
-  ScriptPromise promise = resolver->Promise();
-
   if (session_mode == XRSession::kModeInline) {
     // `inline` sessions are always supported if not blocked by feature policy.
-    resolver->Resolve();
+    query->Resolve();
   } else {
     // For all other modes we need to check with the service.
-    PendingSessionQuery* query =
-        MakeGarbageCollected<PendingSessionQuery>(resolver, session_mode);
-
     if (!device_) {
       pending_mode_queries_.push_back(query);
 
@@ -222,17 +283,17 @@ ScriptPromise XR::supportsSession(ScriptState* script_state,
   return promise;
 }
 
-void XR::DispatchSupportsSession(PendingSessionQuery* query) {
+void XR::DispatchSupportsSession(PendingSupportsSessionQuery* query) {
   if (!device_) {
     // If we don't have a device by the time we reach this call it indicates
     // that there's no WebXR hardware. Reject as not supported.
-    query->resolver->Reject(MakeGarbageCollected<DOMException>(
+    query->Reject(MakeGarbageCollected<DOMException>(
         DOMExceptionCode::kNotSupportedError, kSessionNotSupported));
     return;
   }
 
   device::mojom::blink::XRSessionOptionsPtr session_options =
-      convertModeToMojo(query->mode);
+      convertModeToMojo(query->mode());
 
   outstanding_support_queries_.insert(query);
   device_->SupportsSession(
@@ -262,13 +323,20 @@ ScriptPromise XR::requestSession(ScriptState* script_state,
   Document* doc = frame->GetDocument();
   XRSession::SessionMode session_mode = stringToSessionMode(mode);
 
+  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
+  ScriptPromise promise = resolver->Promise();
+
+  PendingRequestSessionQuery* query =
+      MakeGarbageCollected<PendingRequestSessionQuery>(GetSourceId(), resolver,
+                                                       session_mode);
+
   if (session_mode == XRSession::kModeImmersiveAR &&
       !AreArRuntimeFeaturesEnabled(doc)) {
-    ReportRequestSessionResult(session_mode, SessionRequestStatus::kOtherError);
-    return ScriptPromise::Reject(
-        script_state, V8ThrowException::CreateTypeError(
+    query->Reject(V8ThrowException::CreateTypeError(
         script_state->GetIsolate(),
         String::Format(kImmersiveArModeNotValid, __func__)));
+
+    return promise;
   }
 
   bool is_immersive = session_mode == XRSession::kModeImmersiveVR ||
@@ -285,30 +353,24 @@ ScriptPromise XR::requestSession(ScriptState* script_state,
                              ReportOptions::kReportOnFailure)) {
     // Only allow the call to be made if the appropriate feature policy is in
     // place.
-    ReportRequestSessionResult(session_mode, SessionRequestStatus::kOtherError);
-    return ScriptPromise::RejectWithDOMException(
-        script_state,
-        MakeGarbageCollected<DOMException>(DOMExceptionCode::kSecurityError,
-                                           kFeaturePolicyBlocked));
+    query->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kSecurityError, kFeaturePolicyBlocked));
+    return promise;
   }
 
   // Only one immersive session can be active at a time.
   if (is_immersive && frameProvider()->immersive_session()) {
-    ReportRequestSessionResult(session_mode, SessionRequestStatus::kOtherError);
-    return ScriptPromise::RejectWithDOMException(
-        script_state,
-        MakeGarbageCollected<DOMException>(DOMExceptionCode::kInvalidStateError,
-                                           kActiveImmersiveSession));
+    query->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kInvalidStateError, kActiveImmersiveSession));
+    return promise;
   }
 
   // All immersive sessions require a user gesture.
   bool has_user_activation = LocalFrame::HasTransientUserActivation(frame);
   if (is_immersive && !has_user_activation) {
-    ReportRequestSessionResult(session_mode, SessionRequestStatus::kOtherError);
-    return ScriptPromise::RejectWithDOMException(
-        script_state,
-        MakeGarbageCollected<DOMException>(DOMExceptionCode::kSecurityError,
-                                           kRequestRequiresUserActivation));
+    query->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kSecurityError, kRequestRequiresUserActivation));
+    return promise;
   }
 
   // TODO(https://crbug.com/962991): The error handling here is not spec
@@ -318,19 +380,11 @@ ScriptPromise XR::requestSession(ScriptState* script_state,
   // it was for an inline mode.  In which case, we'll end up creating the
   // session in OnRequestSessionReturned.
   if (!service_ && session_mode != XRSession::kModeInline) {
-    ReportRequestSessionResult(session_mode, SessionRequestStatus::kOtherError);
-    return ScriptPromise::RejectWithDOMException(
-        script_state,
-        MakeGarbageCollected<DOMException>(DOMExceptionCode::kNotSupportedError,
-                                           kNoDevicesMessage));
+    query->Reject(MakeGarbageCollected<DOMException>(
+        DOMExceptionCode::kNotSupportedError, kNoDevicesMessage));
+    return promise;
   }
 
-  auto* resolver = MakeGarbageCollected<ScriptPromiseResolver>(script_state);
-  ScriptPromise promise = resolver->Promise();
-
-  PendingSessionQuery* query =
-      MakeGarbageCollected<PendingSessionQuery>(resolver, session_mode);
-
   if (!device_) {
     pending_session_requests_.push_back(query);
 
@@ -343,7 +397,7 @@ ScriptPromise XR::requestSession(ScriptState* script_state,
   return promise;
 }
 
-void XR::DispatchRequestSession(PendingSessionQuery* query) {
+void XR::DispatchRequestSession(PendingRequestSessionQuery* query) {
   // TODO(https://crbug.com/968622): Make sure we don't forget to call
   // metrics-related methods when the promise gets resolved/rejected.
 
@@ -352,25 +406,23 @@ void XR::DispatchRequestSession(PendingSessionQuery* query) {
     // hardware. Attempt to create a sensorless session.
     // TODO(https://crbug.com/944987): When device_ is eliminated, unify with
     // OnRequestSessionReturned() and inline CreateSensorlessInlineSession().
-    if (query->mode == XRSession::kModeInline) {
+    if (query->mode() == XRSession::kModeInline) {
       XRSession* session = CreateSensorlessInlineSession();
 
-      ReportRequestSessionResult(query->mode, SessionRequestStatus::kSuccess);
-      query->resolver->Resolve(session);
+      query->Resolve(session);
       return;
     }
 
-    ReportRequestSessionResult(query->mode, SessionRequestStatus::kOtherError);
     // TODO(https://crbug.com/962991): The spec says to reject with null.
     // Clarify/fix the spec. In other places where we have no device or no
     // service we return kNotSupportedError.
-    query->resolver->Reject(MakeGarbageCollected<DOMException>(
+    query->Reject(MakeGarbageCollected<DOMException>(
         DOMExceptionCode::kNotSupportedError, kSessionNotSupported));
     return;
   }
 
   device::mojom::blink::XRSessionOptionsPtr session_options =
-      convertModeToMojo(query->mode);
+      convertModeToMojo(query->mode());
 
   outstanding_request_queries_.insert(query);
   device_->RequestSession(
@@ -439,7 +491,7 @@ void XR::DispatchPendingSessionCalls() {
   pending_session_requests_.clear();
 }
 
-void XR::OnSupportsSessionReturned(PendingSessionQuery* query,
+void XR::OnSupportsSessionReturned(PendingSupportsSessionQuery* query,
                                    bool supports_session) {
   // The session query has returned and we're about to resolve or reject the
   // promise, so remove it from our outstanding list.
@@ -447,13 +499,13 @@ void XR::OnSupportsSessionReturned(PendingSessionQuery* query,
   outstanding_support_queries_.erase(query);
 
   supports_session
-      ? query->resolver->Resolve()
-      : query->resolver->Reject(MakeGarbageCollected<DOMException>(
+      ? query->Resolve()
+      : query->Reject(MakeGarbageCollected<DOMException>(
             DOMExceptionCode::kNotSupportedError, kSessionNotSupported));
 }
 
 void XR::OnRequestSessionReturned(
-    PendingSessionQuery* query,
+    PendingRequestSessionQuery* query,
     device::mojom::blink::XRSessionPtr session_ptr) {
   // The session query has returned and we're about to resolve or reject the
   // promise, so remove it from our outstanding list.
@@ -467,23 +519,20 @@ void XR::OnRequestSessionReturned(
     // sensorless session.
     // TODO(https://crbug.com/944987): When device_ is eliminated, unify with
     // DispatchRequestSession() and inline CreateSensorlessInlineSession().
-    if (query->mode == XRSession::kModeInline) {
+    if (query->mode() == XRSession::kModeInline) {
       XRSession* session = CreateSensorlessInlineSession();
 
-      ReportRequestSessionResult(query->mode, SessionRequestStatus::kSuccess);
-
-      query->resolver->Resolve(session);
+      query->Resolve(session);
       return;
     }
 
-    ReportRequestSessionResult(query->mode, SessionRequestStatus::kOtherError);
     auto* exception = MakeGarbageCollected<DOMException>(
         DOMExceptionCode::kNotSupportedError, kSessionNotSupported);
-    query->resolver->Reject(exception);
+    query->Reject(exception);
     return;
   }
 
-  bool environment_integration = query->mode == XRSession::kModeImmersiveAR;
+  bool environment_integration = query->mode() == XRSession::kModeImmersiveAR;
 
   // immersive sessions must supply display info.
   DCHECK(session_ptr->display_info);
@@ -502,12 +551,12 @@ void XR::OnRequestSessionReturned(
   if (environment_integration)
     blend_mode = XRSession::kBlendModeAlphaBlend;
 
-  XRSession* session = CreateSession(query->mode, blend_mode,
+  XRSession* session = CreateSession(query->mode(), blend_mode,
                                      std::move(session_ptr->client_request),
                                      std::move(session_ptr->display_info));
 
-  if (query->mode == XRSession::kModeImmersiveVR ||
-      query->mode == XRSession::kModeImmersiveAR) {
+  if (query->mode() == XRSession::kModeImmersiveVR ||
+      query->mode() == XRSession::kModeImmersiveAR) {
     frameProvider()->BeginImmersiveSession(session, std::move(session_ptr));
     if (environment_integration) {
       // See Task Sources spreadsheet for more information:
@@ -525,11 +574,10 @@ void XR::OnRequestSessionReturned(
         &XR::OnMagicWindowProviderDisconnect, WrapWeakPersistent(this)));
   }
 
-  UseCounter::Count(ExecutionContext::From(query->resolver->GetScriptState()),
+  UseCounter::Count(ExecutionContext::From(query->GetScriptState()),
                     WebFeature::kWebXrSessionCreated);
 
-  ReportRequestSessionResult(query->mode, SessionRequestStatus::kSuccess);
-  query->resolver->Resolve(session);
+  query->Resolve(session);
 }
 
 void XR::ReportImmersiveSupported(bool supported) {
@@ -542,18 +590,6 @@ void XR::ReportImmersiveSupported(bool supported) {
   }
 }
 
-void XR::ReportRequestSessionResult(XRSession::SessionMode session_mode,
-                                    SessionRequestStatus status) {
-  Document* doc = GetFrame() ? GetFrame()->GetDocument() : nullptr;
-  if (!doc)
-    return;
-
-  ukm::builders::XR_WebXR_SessionRequest(GetSourceId())
-      .SetMode(static_cast<int64_t>(session_mode))
-      .SetStatus(static_cast<int64_t>(status))
-      .Record(doc->UkmRecorder());
-}
-
 void XR::AddedEventListener(const AtomicString& event_type,
                             RegisteredEventListener& registered_listener) {
   EventTargetWithInlineData::AddedEventListener(event_type,
@@ -632,14 +668,14 @@ void XR::OnDeviceDisconnect() {
 
   device_ = nullptr;
 
-  HeapHashSet<Member<PendingSessionQuery>> support_queries =
+  HeapHashSet<Member<PendingSupportsSessionQuery>> support_queries =
       outstanding_support_queries_;
   for (const auto& query : support_queries) {
     OnSupportsSessionReturned(query, false);
   }
   DCHECK(outstanding_support_queries_.IsEmpty());
 
-  HeapHashSet<Member<PendingSessionQuery>> request_queries =
+  HeapHashSet<Member<PendingRequestSessionQuery>> request_queries =
       outstanding_request_queries_;
   for (const auto& query : request_queries) {
     // We had a device, so rejecting the session request as though the mode

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

@@ -86,30 +86,81 @@ class XR final : public EventTargetWithInlineData,
     kMaxValue = kOtherError,
   };
 
-  class PendingSessionQuery final
-      : public GarbageCollected<PendingSessionQuery> {
-    DISALLOW_COPY_AND_ASSIGN(PendingSessionQuery);
+  // Encapsulates blink-side `XR::requestSession()` call. It is a wrapper around
+  // ScriptPromiseResolver that allows us to add additional logic as certain
+  // things related to promise's life cycle happen.
+  class PendingRequestSessionQuery final
+      : public GarbageCollected<PendingRequestSessionQuery> {
+    DISALLOW_COPY_AND_ASSIGN(PendingRequestSessionQuery);
 
    public:
-    PendingSessionQuery(ScriptPromiseResolver*, XRSession::SessionMode);
-    virtual ~PendingSessionQuery() = default;
+    PendingRequestSessionQuery(int64_t ukm_source_id,
+                               ScriptPromiseResolver* resolver,
+                               XRSession::SessionMode mode);
+    virtual ~PendingRequestSessionQuery() = default;
+
+    // Resolves underlying promise with passed in XR session.
+    void Resolve(XRSession* session);
+    // Rejects underlying promise with passed in DOM exception.
+    void Reject(DOMException* exception);
+    // Rejects underlying promise with passed in v8 value. Used to raise
+    // TypeError which is not a DOM exception.
+    void Reject(v8::Local<v8::Value> value);
+
+    XRSession::SessionMode mode() const;
+
+    // Returns underlying resolver's script state.
+    ScriptState* GetScriptState() const;
 
     virtual void Trace(blink::Visitor*);
 
-    Member<ScriptPromiseResolver> resolver;
-    const XRSession::SessionMode mode;
-    bool has_user_activation = false;
+   private:
+    void ReportRequestSessionResult(SessionRequestStatus status);
+
+    Member<ScriptPromiseResolver> resolver_;
+    const XRSession::SessionMode mode_;
+
+    const int64_t ukm_source_id_;
+  };
+
+  // Encapsulates blink-side `XR::supportsSession()` call.  It is a wrapper
+  // around ScriptPromiseResolver that allows us to add additional logic as
+  // certain things related to promise's life cycle happen.
+  class PendingSupportsSessionQuery final
+      : public GarbageCollected<PendingSupportsSessionQuery> {
+    DISALLOW_COPY_AND_ASSIGN(PendingSupportsSessionQuery);
+
+   public:
+    PendingSupportsSessionQuery(ScriptPromiseResolver*, XRSession::SessionMode);
+    virtual ~PendingSupportsSessionQuery() = default;
+
+    // Resolves underlying promise.
+    void Resolve();
+    // Rejects underlying promise with passed in DOM exception.
+    void Reject(DOMException* exception);
+    // Rejects underlying promise with passed in v8 value. Used to raise
+    // TypeError which is not a DOM exception.
+    void Reject(v8::Local<v8::Value> value);
+
+    XRSession::SessionMode mode() const;
+
+    virtual void Trace(blink::Visitor*);
+
+   private:
+    Member<ScriptPromiseResolver> resolver_;
+    const XRSession::SessionMode mode_;
   };
 
   void OnRequestDeviceReturned(device::mojom::blink::XRDevicePtr device);
   void DispatchPendingSessionCalls();
 
-  void DispatchRequestSession(PendingSessionQuery*);
-  void OnRequestSessionReturned(PendingSessionQuery*,
+  void DispatchRequestSession(PendingRequestSessionQuery*);
+  void OnRequestSessionReturned(PendingRequestSessionQuery*,
                                 device::mojom::blink::XRSessionPtr);
 
-  void DispatchSupportsSession(PendingSessionQuery*);
-  void OnSupportsSessionReturned(PendingSessionQuery*, bool supports_session);
+  void DispatchSupportsSession(PendingSupportsSessionQuery*);
+  void OnSupportsSessionReturned(PendingSupportsSessionQuery*,
+                                 bool supports_session);
 
   void EnsureDevice();
   void ReportImmersiveSupported(bool supported);
@@ -148,11 +199,11 @@ class XR final : public EventTargetWithInlineData,
   // Track calls that were made prior to the internal device successfully being
   // queried. Can be removed once the service has been updated to allow the
   // respective calls to be made directly.
-  HeapVector<Member<PendingSessionQuery>> pending_mode_queries_;
-  HeapVector<Member<PendingSessionQuery>> pending_session_requests_;
+  HeapVector<Member<PendingSupportsSessionQuery>> pending_mode_queries_;
+  HeapVector<Member<PendingRequestSessionQuery>> pending_session_requests_;
 
-  HeapHashSet<Member<PendingSessionQuery>> outstanding_support_queries_;
-  HeapHashSet<Member<PendingSessionQuery>> outstanding_request_queries_;
+  HeapHashSet<Member<PendingSupportsSessionQuery>> outstanding_support_queries_;
+  HeapHashSet<Member<PendingRequestSessionQuery>> outstanding_request_queries_;
 
   Vector<EnvironmentProviderErrorCallback>
       environment_provider_error_callbacks_;