1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_XR_SERVICE_VR_SERVICE_IMPL_H_
#define CONTENT_BROWSER_XR_SERVICE_VR_SERVICE_IMPL_H_
#include <map>
#include <memory>
#include <set>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "base/types/pass_key.h"
#include "build/build_config.h"
#include "content/browser/xr/metrics/session_metrics_helper.h"
#include "content/common/content_export.h"
#include "content/public/browser/web_contents_observer.h"
#include "device/vr/public/mojom/isolated_xr_service.mojom-forward.h"
#include "device/vr/public/mojom/vr_service.mojom.h"
#include "device/vr/public/mojom/xr_device.mojom.h"
#include "device/vr/public/mojom/xr_session.mojom.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "mojo/public/cpp/bindings/remote_set.h"
#include "mojo/public/cpp/bindings/self_owned_receiver.h"
#include "third_party/blink/public/mojom/permissions/permission_status.mojom-forward.h"
namespace blink {
enum class PermissionType;
}
namespace content {
class RenderFrameHost;
class WebContents;
} // namespace content
namespace content {
class XRRuntimeManagerImpl;
class XRRuntimeManagerTest;
class BrowserXRRuntimeImpl;
// Browser process implementation of the VRService mojo interface. Instantiated
// through Mojo once the user loads a page containing WebXR.
class CONTENT_EXPORT VRServiceImpl : public device::mojom::VRService,
content::WebContentsObserver {
public:
explicit VRServiceImpl(content::RenderFrameHost* render_frame_host);
// Constructor for tests.
explicit VRServiceImpl(base::PassKey<XRRuntimeManagerTest>);
VRServiceImpl(const VRServiceImpl&) = delete;
VRServiceImpl& operator=(const VRServiceImpl&) = delete;
~VRServiceImpl() override;
static void Create(content::RenderFrameHost* render_frame_host,
mojo::PendingReceiver<device::mojom::VRService> receiver);
// device::mojom::VRService implementation
void SetClient(mojo::PendingRemote<device::mojom::VRServiceClient>
service_client) override;
void RequestSession(
device::mojom::XRSessionOptionsPtr options,
device::mojom::VRService::RequestSessionCallback callback) override;
void SupportsSession(
device::mojom::XRSessionOptionsPtr options,
device::mojom::VRService::SupportsSessionCallback callback) override;
void ExitPresent(ExitPresentCallback on_exited) override;
void SetFramesThrottled(bool throttled) override;
void MakeXrCompatible(
device::mojom::VRService::MakeXrCompatibleCallback callback) override;
void InitializationComplete();
// Called when inline session gets disconnected. |session_id| is the value
// returned by |magic_window_controllers_| when adding session controller to
// it.
void OnInlineSessionDisconnected(mojo::RemoteSetElementId session_id);
// Notifications/calls from BrowserXRRuntimeImpl:
void OnExitPresent();
void OnVisibilityStateChanged(
device::mojom::XRVisibilityState visibility_state);
void RuntimesChanged();
void OnMakeXrCompatibleComplete(device::mojom::XrCompatibleResult result);
base::WeakPtr<VRServiceImpl> GetWeakPtr() {
return weak_ptr_factory_.GetWeakPtr();
}
content::WebContents* GetWebContents();
private:
struct SessionRequestData {
device::mojom::VRService::RequestSessionCallback callback;
std::unordered_set<device::mojom::XRSessionFeature> required_features;
std::unordered_set<device::mojom::XRSessionFeature> optional_features;
device::mojom::XRSessionOptionsPtr options;
device::mojom::XRDeviceId runtime_id;
SessionRequestData(
device::mojom::XRSessionOptionsPtr options,
device::mojom::VRService::RequestSessionCallback callback,
device::mojom::XRDeviceId runtime_id);
~SessionRequestData();
SessionRequestData(SessionRequestData&&);
private:
SessionRequestData(const SessionRequestData&) = delete;
SessionRequestData& operator=(const SessionRequestData&) = delete;
};
// Wrapper around MakeXrCompatibleCallback so that the callback gets executed
// on destruction if it hasn't already. Otherwise, mojom throws a DCHECK if
// the callback is not executed before being destroyed.
struct XrCompatibleCallback {
device::mojom::VRService::MakeXrCompatibleCallback callback;
explicit XrCompatibleCallback(
device::mojom::VRService::MakeXrCompatibleCallback callback);
XrCompatibleCallback(XrCompatibleCallback&& wrapper);
~XrCompatibleCallback();
};
// content::WebContentsObserver implementation
void OnWebContentsFocused(content::RenderWidgetHost* host) override;
void OnWebContentsLostFocus(content::RenderWidgetHost* host) override;
void RenderFrameDeleted(content::RenderFrameHost* host) override;
void OnWebContentsFocusChanged(content::RenderWidgetHost* host, bool focused);
void ResolvePendingRequests();
// Returns currently active instance of SessionMetricsHelper from WebContents.
// If the instance is not present on WebContents, it will be created with the
// assumption that we are not already in VR.
SessionMetricsHelper* GetSessionMetricsHelper();
bool InternalSupportsSession(device::mojom::XRSessionOptions* options);
void DoRequestPermissions(
const std::vector<blink::PermissionType> request_permissions,
base::OnceCallback<void(
const std::vector<blink::mojom::PermissionStatus>&)> result_callback);
// The following steps are ordered in the general flow for "RequestSession"
// GetPermissionStatus will result in a call to OnPermissionResult which then
// calls EnsureRuntimeInstalled (with a callback to OnInstallResult), which
// then feeds into DoRequestSession, which will continue with OnInline or
// OnImmersive SessionCreated depending on the type of session created.
void GetPermissionStatus(SessionRequestData request,
BrowserXRRuntimeImpl* runtime);
void OnPermissionResultsForMode(
SessionRequestData request,
const std::vector<blink::PermissionType>& permissions,
const std::vector<blink::mojom::PermissionStatus>& permission_statuses);
void OnPermissionResultsForFeatures(
SessionRequestData request,
const std::vector<blink::PermissionType>& permissions,
const std::vector<blink::mojom::PermissionStatus>& permission_statuses);
void EnsureRuntimeInstalled(SessionRequestData request,
BrowserXRRuntimeImpl* runtime);
void OnInstallResult(SessionRequestData request_data, bool install_succeeded);
void DoRequestSession(SessionRequestData request);
void OnInlineSessionCreated(
SessionRequestData request,
device::mojom::XRRuntimeSessionResultPtr session_result);
void OnImmersiveSessionCreated(
SessionRequestData request,
device::mojom::XRRuntimeSessionResultPtr session_result);
void OnSessionCreated(
SessionRequestData request,
device::mojom::XRSessionPtr session,
mojo::PendingRemote<device::mojom::XRSessionMetricsRecorder>
session_metrics_recorder,
mojo::PendingRemote<device::mojom::WebXrInternalsRendererListener>
xr_internals_listener);
mojo::PendingRemote<device::mojom::WebXrInternalsRendererListener>
WebXrInternalsRendererListener();
ExitPresentCallback on_exit_present_;
scoped_refptr<XRRuntimeManagerImpl> runtime_manager_;
mojo::RemoteSet<device::mojom::XRSessionClient> session_clients_;
mojo::Remote<device::mojom::VRServiceClient> service_client_;
raw_ptr<content::RenderFrameHost> render_frame_host_;
mojo::SelfOwnedReceiverRef<device::mojom::VRService> receiver_;
mojo::RemoteSet<device::mojom::XRSessionController> magic_window_controllers_;
device::mojom::XRVisibilityState visibility_state_ =
device::mojom::XRVisibilityState::VISIBLE;
// List of callbacks to run when initialization is completed.
std::vector<base::OnceCallback<void()>> pending_requests_;
bool initialization_complete_ = false;
bool in_focused_frame_ = false;
bool frames_throttled_ = false;
std::vector<XrCompatibleCallback> xr_compatible_callbacks_;
base::WeakPtrFactory<VRServiceImpl> weak_ptr_factory_{this};
};
} // namespace content
#endif // CONTENT_BROWSER_XR_SERVICE_VR_SERVICE_IMPL_H_
|
