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
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
import { MessageHandler } from "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs";
const lazy = {};
ChromeUtils.defineESModuleGetters(lazy, {
FrameTransport:
"chrome://remote/content/shared/messagehandler/transports/FrameTransport.sys.mjs",
SessionData:
"chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
SessionDataMethod:
"chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
WindowGlobalMessageHandler:
"chrome://remote/content/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs",
});
/**
* A RootMessageHandler is the root node of a MessageHandler network. It lives
* in the parent process. It can forward commands to MessageHandlers in other
* layers (at the moment WindowGlobalMessageHandlers in content processes).
*/
export class RootMessageHandler extends MessageHandler {
#frameTransport;
#sessionData;
/**
* Returns the RootMessageHandler module path.
*
* @return {String}
*/
static get modulePath() {
return "root";
}
/**
* Returns the RootMessageHandler type.
*
* @return {String}
*/
static get type() {
return "ROOT";
}
/**
* The ROOT MessageHandler is unique for a given MessageHandler network
* (ie for a given sessionId). Reuse the type as context id here.
*/
static getIdFromContext(context) {
return RootMessageHandler.type;
}
/**
* Create a new RootMessageHandler instance.
*
* @param {String} sessionId
* ID of the session the handler is used for.
*/
constructor(sessionId) {
super(sessionId, null);
this.#frameTransport = new lazy.FrameTransport(this);
this.#sessionData = new lazy.SessionData(this);
}
get sessionData() {
return this.#sessionData;
}
destroy() {
this.#sessionData.destroy();
super.destroy();
}
/**
* Add new session data items of a given module, category and
* contextDescriptor.
*
* Forwards the call to the SessionData instance owned by this
* RootMessageHandler and propagates the information via a command to existing
* MessageHandlers.
*/
addSessionData(sessionData = {}) {
sessionData.method = lazy.SessionDataMethod.Add;
return this.updateSessionData([sessionData]);
}
/**
* Emit a public protocol event. This event will be sent over to the client.
*
* @param {String} name
* Name of the event. Protocol level events should be of the
* form [module name].[event name].
* @param {Object} data
* The event's data.
*/
emitProtocolEvent(name, data) {
this.emit("message-handler-protocol-event", {
name,
data,
sessionId: this.sessionId,
});
}
/**
* Forward the provided command to WINDOW_GLOBAL MessageHandlers via the
* FrameTransport.
*
* @param {Command} command
* The command to forward. See type definition in MessageHandler.js
* @return {Promise}
* Returns a promise that resolves with the result of the command.
*/
forwardCommand(command) {
switch (command.destination.type) {
case lazy.WindowGlobalMessageHandler.type:
return this.#frameTransport.forwardCommand(command);
default:
throw new Error(
`Cannot forward command to "${command.destination.type}" from "${this.constructor.type}".`
);
}
}
matchesContext() {
return true;
}
/**
* Remove session data items of a given module, category and
* contextDescriptor.
*
* Forwards the call to the SessionData instance owned by this
* RootMessageHandler and propagates the information via a command to existing
* MessageHandlers.
*/
removeSessionData(sessionData = {}) {
sessionData.method = lazy.SessionDataMethod.Remove;
return this.updateSessionData([sessionData]);
}
/**
* Update session data items of a given module, category and
* contextDescriptor.
*
* Forwards the call to the SessionData instance owned by this
* RootMessageHandler.
*/
async updateSessionData(sessionData = []) {
await this.#sessionData.updateSessionData(sessionData);
}
}
|
