servoshell/
webdriver.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::cell::RefCell;
6use std::collections::HashMap;
7use std::rc::Rc;
8
9use log::warn;
10use servo::{
11    EmbedderControl, EmbedderControlId, NewWindowTypeHint, SimpleDialog, WebDriverCommandMsg,
12    WebDriverUserPrompt, WebDriverUserPromptAction, WebViewId,
13};
14use url::Url;
15
16use crate::running_app_state::RunningAppState;
17use crate::window::{PlatformWindow, TopLevelWebViewCreationRequest};
18
19#[derive(Default)]
20pub(crate) struct WebDriverEmbedderControls {
21    embedder_controls: RefCell<HashMap<WebViewId, Vec<EmbedderControl>>>,
22}
23
24impl WebDriverEmbedderControls {
25    pub(crate) fn show_embedder_control(
26        &self,
27        webview_id: WebViewId,
28        embedder_control: EmbedderControl,
29    ) {
30        self.embedder_controls
31            .borrow_mut()
32            .entry(webview_id)
33            .or_default()
34            .push(embedder_control)
35    }
36
37    pub(crate) fn hide_embedder_control(
38        &self,
39        webview_id: WebViewId,
40        embedder_control_id: EmbedderControlId,
41    ) {
42        let mut embedder_controls = self.embedder_controls.borrow_mut();
43        if let Some(controls) = embedder_controls.get_mut(&webview_id) {
44            controls.retain(|control| control.id() != embedder_control_id);
45        }
46        embedder_controls.retain(|_, controls| !controls.is_empty());
47    }
48
49    pub(crate) fn current_active_dialog_webdriver_type(
50        &self,
51        webview_id: WebViewId,
52    ) -> Option<WebDriverUserPrompt> {
53        // From <https://w3c.github.io/webdriver/#dfn-handle-any-user-prompts>
54        // > Step 3: If the current user prompt is an alert dialog, set type to "alert". Otherwise,
55        // > if the current user prompt is a beforeunload dialog, set type to
56        // > "beforeUnload". Otherwise, if the current user prompt is a confirm dialog, set
57        // > type to "confirm". Otherwise, if the current user prompt is a prompt dialog,
58        // > set type to "prompt".
59        let embedder_controls = self.embedder_controls.borrow();
60        match embedder_controls.get(&webview_id)?.last()? {
61            EmbedderControl::SimpleDialog(SimpleDialog::Alert(..)) => {
62                Some(WebDriverUserPrompt::Alert)
63            },
64            EmbedderControl::SimpleDialog(SimpleDialog::Confirm(..)) => {
65                Some(WebDriverUserPrompt::Confirm)
66            },
67            EmbedderControl::SimpleDialog(SimpleDialog::Prompt(..)) => {
68                Some(WebDriverUserPrompt::Prompt)
69            },
70            EmbedderControl::FilePicker { .. } => Some(WebDriverUserPrompt::File),
71            EmbedderControl::SelectElement { .. } => Some(WebDriverUserPrompt::Default),
72            _ => None,
73        }
74    }
75
76    /// Respond to the most recently added dialog if it was a `SimpleDialog` and return
77    /// its message string or return an error if there is no active dialog or the most
78    /// recently added dialog is not a `SimpleDialog`.
79    pub(crate) fn respond_to_active_simple_dialog(
80        &self,
81        webview_id: WebViewId,
82        action: WebDriverUserPromptAction,
83    ) -> Result<String, ()> {
84        let mut embedder_controls = self.embedder_controls.borrow_mut();
85        let Some(controls) = embedder_controls.get_mut(&webview_id) else {
86            return Err(());
87        };
88        let Some(&EmbedderControl::SimpleDialog(simple_dialog)) = controls.last().as_ref() else {
89            return Err(());
90        };
91
92        let result_text = simple_dialog.message().to_owned();
93        if action == WebDriverUserPromptAction::Ignore {
94            return Ok(result_text);
95        }
96
97        let Some(EmbedderControl::SimpleDialog(simple_dialog)) = controls.pop() else {
98            return Err(());
99        };
100        match action {
101            WebDriverUserPromptAction::Accept => simple_dialog.confirm(),
102            WebDriverUserPromptAction::Dismiss => simple_dialog.dismiss(),
103            WebDriverUserPromptAction::Ignore => unreachable!("Should have returned early above"),
104        }
105        Ok(result_text)
106    }
107
108    pub(crate) fn message_of_newest_dialog(&self, webview_id: WebViewId) -> Option<String> {
109        let embedder_controls = self.embedder_controls.borrow();
110        match embedder_controls.get(&webview_id)?.last()? {
111            EmbedderControl::SimpleDialog(simple_dialog) => Some(simple_dialog.message().into()),
112            _ => None,
113        }
114    }
115
116    pub(crate) fn set_prompt_value_of_newest_dialog(&self, webview_id: WebViewId, text: String) {
117        let mut embedder_controls = self.embedder_controls.borrow_mut();
118        let Some(controls) = embedder_controls.get_mut(&webview_id) else {
119            return;
120        };
121        let Some(&mut EmbedderControl::SimpleDialog(SimpleDialog::Prompt(ref mut prompt_dialog))) =
122            controls.last_mut()
123        else {
124            return;
125        };
126        prompt_dialog.set_current_value(&text);
127    }
128}
129
130impl RunningAppState {
131    pub(crate) fn handle_webdriver_messages(
132        self: &Rc<Self>,
133        create_platform_window: Option<&dyn Fn(Url) -> Rc<dyn PlatformWindow>>,
134    ) {
135        let Some(webdriver_receiver) = self.webdriver_receiver() else {
136            return;
137        };
138
139        while let Ok(msg) = webdriver_receiver.try_recv() {
140            match msg {
141                WebDriverCommandMsg::ResetAllCookies(sender) => {
142                    self.servo().site_data_manager().clear_cookies(None);
143                    let _ = sender.send(());
144                },
145                WebDriverCommandMsg::Shutdown => {
146                    self.schedule_exit();
147                },
148                WebDriverCommandMsg::IsWebViewOpen(webview_id, sender) => {
149                    let context = self.webview_by_id(webview_id);
150                    sender.send_or_warn(context.is_some());
151                },
152                WebDriverCommandMsg::IsBrowsingContextOpen(..) => {
153                    self.servo().execute_webdriver_command(msg);
154                },
155                WebDriverCommandMsg::NewWindow(type_hint, response_sender, load_status_sender) => {
156                    let url = Url::parse("about:blank").unwrap();
157                    let new_webview = match (type_hint, create_platform_window) {
158                        (
159                            NewWindowTypeHint::Window | NewWindowTypeHint::Auto,
160                            Some(create_platform_window),
161                        ) => {
162                            let window = self.open_window(
163                                create_platform_window(url.clone()),
164                                TopLevelWebViewCreationRequest::WithUrl(url),
165                            );
166                            window
167                                .active_webview()
168                                .expect("Should have at last one WebView in new window")
169                        },
170                        _ => self
171                            .windows()
172                            .last()
173                            .expect("Expected at least one window to be open")
174                            .create_toplevel_webview(
175                                self.clone(),
176                                TopLevelWebViewCreationRequest::WithUrl(url),
177                            ),
178                    };
179
180                    if let Err(error) = response_sender.send(new_webview.id()) {
181                        warn!("Failed to send response of NewWebview: {error}");
182                    }
183                    if let Some(load_status_sender) = load_status_sender {
184                        self.set_load_status_sender(new_webview.id(), load_status_sender);
185                    }
186                },
187                WebDriverCommandMsg::CloseWebView(webview_id, response_sender) => {
188                    let Some(webview) = self.webview_by_id(webview_id) else {
189                        continue;
190                    };
191                    self.window_for_webview(&webview).close_webview(webview_id);
192                    if let Err(error) = response_sender.send(()) {
193                        warn!("Failed to send response of CloseWebView: {error}");
194                    }
195                },
196                WebDriverCommandMsg::SelectWebViewForInteraction(webview_id) => {
197                    let Some(webview) = self.webview_by_id(webview_id) else {
198                        continue;
199                    };
200                    let window = self.window_for_webview(&webview);
201                    window.activate_webview(webview_id);
202                },
203                WebDriverCommandMsg::FocusBrowsingContext(..) => {
204                    self.servo().execute_webdriver_command(msg);
205                },
206                WebDriverCommandMsg::GetAllWebViews(response_sender) => {
207                    let webviews = self
208                        .windows()
209                        .iter()
210                        .flat_map(|window| window.webview_ids())
211                        .collect();
212                    if let Err(error) = response_sender.send(webviews) {
213                        warn!("Failed to send response of GetAllWebViews: {error}");
214                    }
215                },
216                WebDriverCommandMsg::GetWindowRect(webview_id, response_sender) => {
217                    let Some(webview) = self.webview_by_id(webview_id) else {
218                        continue;
219                    };
220                    let platform_window = self.platform_window_for_webview(&webview);
221                    if let Err(error) = response_sender.send(platform_window.window_rect()) {
222                        warn!("Failed to send response of GetWindowSize: {error}");
223                    }
224                },
225                WebDriverCommandMsg::MaximizeWebView(webview_id, response_sender) => {
226                    let Some(webview) = self.webview_by_id(webview_id) else {
227                        continue;
228                    };
229                    let platform_window = self.platform_window_for_webview(&webview);
230                    platform_window.maximize(&webview);
231
232                    if let Err(error) = response_sender.send(platform_window.window_rect()) {
233                        warn!("Failed to send response of GetWindowSize: {error}");
234                    }
235                },
236                WebDriverCommandMsg::SetWindowRect(webview_id, requested_rect, size_sender) => {
237                    let Some(webview) = self.webview_by_id(webview_id) else {
238                        continue;
239                    };
240
241                    let platform_window = self.platform_window_for_webview(&webview);
242                    let scale = platform_window.hidpi_scale_factor();
243
244                    let requested_physical_rect =
245                        (requested_rect.to_f32() * scale).round().to_i32();
246
247                    // Step 17. Set Width/Height.
248                    platform_window.request_resize(&webview, requested_physical_rect.size());
249
250                    // Step 18. Set position of the window.
251                    platform_window.set_position(requested_physical_rect.min);
252
253                    if let Err(error) = size_sender.send(platform_window.window_rect()) {
254                        warn!("Failed to send window size: {error}");
255                    }
256                },
257                WebDriverCommandMsg::GetViewportSize(webview_id, response_sender) => {
258                    let Some(webview) = self.webview_by_id(webview_id) else {
259                        continue;
260                    };
261                    let platform_window = self.platform_window_for_webview(&webview);
262                    let size = platform_window.rendering_context().size2d().to_f32() /
263                        platform_window.hidpi_scale_factor();
264                    if let Err(error) = response_sender.send(size) {
265                        warn!("Failed to send response of GetViewportSize: {error}");
266                    }
267                },
268                // This is only received when start new session.
269                WebDriverCommandMsg::GetWebViewSelectedForInteraction(sender) => {
270                    let selected_webview = self
271                        .focused_window()
272                        .and_then(|window| window.active_webview())
273                        .map(|webview| webview.id());
274                    if let Err(error) = sender.send(selected_webview) {
275                        warn!(
276                            "Failed to send response of GetWebViewSelectedForInteraction: {error}"
277                        );
278                    };
279                },
280                WebDriverCommandMsg::LoadUrl(webview_id, url, load_status_sender) => {
281                    self.handle_webdriver_load_url(webview_id, url, load_status_sender);
282                },
283                WebDriverCommandMsg::Refresh(webview_id, load_status_sender) => {
284                    if let Some(webview) = self.webview_by_id(webview_id) {
285                        self.set_load_status_sender(webview_id, load_status_sender);
286                        webview.reload();
287                    }
288                },
289                WebDriverCommandMsg::GoBack(webview_id, load_status_sender) => {
290                    if let Some(webview) = self.webview_by_id(webview_id) {
291                        let traversal_id = webview.go_back(1);
292                        self.set_pending_traversal(traversal_id, load_status_sender);
293                    }
294                },
295                WebDriverCommandMsg::GoForward(webview_id, load_status_sender) => {
296                    if let Some(webview) = self.webview_by_id(webview_id) {
297                        let traversal_id = webview.go_forward(1);
298                        self.set_pending_traversal(traversal_id, load_status_sender);
299                    }
300                },
301                WebDriverCommandMsg::InputEvent(webview_id, input_event, response_sender) => {
302                    self.handle_webdriver_input_event(webview_id, input_event, response_sender);
303                },
304                WebDriverCommandMsg::ScriptCommand(_, ref webdriver_script_command) => {
305                    self.handle_webdriver_script_command(webdriver_script_command);
306                    self.servo().execute_webdriver_command(msg);
307                },
308                WebDriverCommandMsg::CurrentUserPrompt(webview_id, response_sender) => {
309                    let current_dialog = self
310                        .webdriver_embedder_controls
311                        .current_active_dialog_webdriver_type(webview_id);
312                    if let Err(error) = response_sender.send(current_dialog) {
313                        warn!("Failed to send response of CurrentUserPrompt: {error}");
314                    };
315                },
316                WebDriverCommandMsg::HandleUserPrompt(webview_id, action, response_sender) => {
317                    let controls = &self.webdriver_embedder_controls;
318                    let result = controls.respond_to_active_simple_dialog(webview_id, action);
319                    if let Err(error) = response_sender.send(result) {
320                        warn!("Failed to send response of HandleUserPrompt: {error}");
321                    };
322                },
323                WebDriverCommandMsg::GetAlertText(webview_id, response_sender) => {
324                    let response = match self
325                        .webdriver_embedder_controls
326                        .message_of_newest_dialog(webview_id)
327                    {
328                        Some(text) => Ok(text),
329                        None => Err(()),
330                    };
331
332                    if let Err(error) = response_sender.send(response) {
333                        warn!("Failed to send response of GetAlertText: {error}");
334                    };
335                },
336                WebDriverCommandMsg::SendAlertText(webview_id, text) => {
337                    self.webdriver_embedder_controls
338                        .set_prompt_value_of_newest_dialog(webview_id, text);
339                },
340                WebDriverCommandMsg::TakeScreenshot(webview_id, rect, result_sender) => {
341                    self.handle_webdriver_screenshot(webview_id, rect, result_sender);
342                },
343            };
344        }
345    }
346}
servoshell/webdriver.rs

servoshell/
webdriver.rs
