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
|
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef REMOTING_HOST_IPC_DESKTOP_ENVIRONMENT_H_
#define REMOTING_HOST_IPC_DESKTOP_ENVIRONMENT_H_
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "mojo/public/cpp/bindings/associated_receiver.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
#include "mojo/public/cpp/system/message_pipe.h"
#include "remoting/host/active_display_monitor.h"
#include "remoting/host/base/desktop_environment_options.h"
#include "remoting/host/desktop_environment.h"
#include "remoting/host/desktop_session_connector.h"
#include "remoting/host/mojom/desktop_session.mojom.h"
#include "remoting/host/mojom/remoting_host.mojom.h"
#include "remoting/protocol/desktop_capturer.h"
#include "third_party/webrtc/modules/desktop_capture/desktop_capture_types.h"
namespace base {
class SingleThreadTaskRunner;
} // namespace base
namespace remoting {
class ClientSessionControl;
class DesktopSessionProxy;
class ScreenResolution;
// A variant of desktop environment integrating with the desktop by means of
// a helper process and talking to that process via IPC.
class IpcDesktopEnvironment : public DesktopEnvironment {
public:
// |desktop_session_connector| is used to bind DesktopSessionProxy to
// a desktop session, to be notified every time the desktop process is
// restarted.
IpcDesktopEnvironment(
scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
base::WeakPtr<ClientSessionControl> client_session_control,
base::WeakPtr<ClientSessionEvents> client_session_events,
base::WeakPtr<DesktopSessionConnector> desktop_session_connector,
const DesktopEnvironmentOptions& options);
IpcDesktopEnvironment(const IpcDesktopEnvironment&) = delete;
IpcDesktopEnvironment& operator=(const IpcDesktopEnvironment&) = delete;
~IpcDesktopEnvironment() override;
// DesktopEnvironment implementation.
std::unique_ptr<ActionExecutor> CreateActionExecutor() override;
std::unique_ptr<AudioCapturer> CreateAudioCapturer() override;
std::unique_ptr<InputInjector> CreateInputInjector() override;
std::unique_ptr<ScreenControls> CreateScreenControls() override;
std::unique_ptr<DesktopCapturer> CreateVideoCapturer(
webrtc::ScreenId id) override;
DesktopDisplayInfoMonitor* GetDisplayInfoMonitor() override;
std::unique_ptr<webrtc::MouseCursorMonitor> CreateMouseCursorMonitor()
override;
std::unique_ptr<KeyboardLayoutMonitor> CreateKeyboardLayoutMonitor(
base::RepeatingCallback<void(const protocol::KeyboardLayout&)> callback)
override;
std::unique_ptr<ActiveDisplayMonitor> CreateActiveDisplayMonitor(
ActiveDisplayMonitor::Callback callback) override;
std::unique_ptr<FileOperations> CreateFileOperations() override;
std::unique_ptr<UrlForwarderConfigurator> CreateUrlForwarderConfigurator()
override;
std::string GetCapabilities() const override;
void SetCapabilities(const std::string& capabilities) override;
std::uint32_t GetDesktopSessionId() const override;
std::unique_ptr<RemoteWebAuthnStateChangeNotifier>
CreateRemoteWebAuthnStateChangeNotifier() override;
private:
scoped_refptr<DesktopSessionProxy> desktop_session_proxy_;
};
// Used to create IpcDesktopEnvironment objects integrating with the desktop via
// a helper process and talking to that process via IPC.
class IpcDesktopEnvironmentFactory : public DesktopEnvironmentFactory,
public DesktopSessionConnector {
public:
// Passes a reference to the IPC channel connected to the daemon process and
// relevant task runners. |remote| must be released on |network_task_runner|.
IpcDesktopEnvironmentFactory(
scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
mojo::AssociatedRemote<mojom::DesktopSessionManager> remote);
IpcDesktopEnvironmentFactory(const IpcDesktopEnvironmentFactory&) = delete;
IpcDesktopEnvironmentFactory& operator=(const IpcDesktopEnvironmentFactory&) =
delete;
~IpcDesktopEnvironmentFactory() override;
// DesktopEnvironmentFactory implementation.
void Create(base::WeakPtr<ClientSessionControl> client_session_control,
base::WeakPtr<ClientSessionEvents> client_session_events,
const DesktopEnvironmentOptions& options,
CreateCallback callback) override;
bool SupportsAudioCapture() const override;
// DesktopSessionConnector implementation.
void ConnectTerminal(DesktopSessionProxy* desktop_session_proxy,
const ScreenResolution& resolution,
bool virtual_terminal) override;
void DisconnectTerminal(DesktopSessionProxy* desktop_session_proxy) override;
void SetScreenResolution(DesktopSessionProxy* desktop_session_proxy,
const ScreenResolution& resolution) override;
bool BindConnectionEventsReceiver(
mojo::ScopedInterfaceEndpointHandle handle) override;
void OnDesktopSessionAgentAttached(
int terminal_id,
int session_id,
mojo::ScopedMessagePipeHandle desktop_pipe) override;
void OnTerminalDisconnected(int terminal_id) override;
private:
// Used to run the audio capturer.
scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
// Task runner on which DesktopEnvironmentFactory methods should be called.
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
// Task runner used for running background I/O.
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
// List of DesktopEnvironment instances we've told the daemon process about.
typedef std::map<int, raw_ptr<DesktopSessionProxy, CtnExperimental>>
ActiveConnectionsList;
ActiveConnectionsList active_connections_;
// Next desktop session ID. IDs are allocated sequentially starting from 0.
// This gives us more than 67 years of unique IDs assuming a new ID is
// allocated every second.
int next_id_ = 0;
mojo::AssociatedRemote<mojom::DesktopSessionManager> desktop_session_manager_;
mojo::AssociatedReceiver<mojom::DesktopSessionConnectionEvents>
desktop_session_connection_events_{this};
// Factory for weak pointers to DesktopSessionConnector interface.
base::WeakPtrFactory<DesktopSessionConnector> connector_factory_{this};
};
} // namespace remoting
#endif // REMOTING_HOST_IPC_DESKTOP_ENVIRONMENT_H_
|
