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;
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();
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
151                    if let Err(error) = sender.send(context.is_some()) {
152                        warn!("Failed to send response of IsWebViewOpen: {error}");
153                    }
154                },
155                WebDriverCommandMsg::IsBrowsingContextOpen(..) => {
156                    self.servo().execute_webdriver_command(msg);
157                },
158                WebDriverCommandMsg::NewWindow(type_hint, response_sender, load_status_sender) => {
159                    let url = Url::parse("about:blank").unwrap();
160                    let new_webview = match (type_hint, create_platform_window) {
161                        (
162                            NewWindowTypeHint::Window | NewWindowTypeHint::Auto,
163                            Some(create_platform_window),
164                        ) => {
165                            let window = self.open_window(create_platform_window(url.clone()), url);
166                            window
167                                .active_webview()
168                                .expect("Should have at last one WebView in new window")
169                        },
170                        _ => self
171                            .windows()
172                            .values()
173                            .nth(0)
174                            .expect("Expected at least one window to be open")
175                            .create_toplevel_webview(self.clone(), url),
176                    };
177
178                    if let Err(error) = response_sender.send(new_webview.id()) {
179                        warn!("Failed to send response of NewWebview: {error}");
180                    }
181                    if let Some(load_status_sender) = load_status_sender {
182                        self.set_load_status_sender(new_webview.id(), load_status_sender);
183                    }
184                },
185                WebDriverCommandMsg::CloseWebView(webview_id, response_sender) => {
186                    self.window_for_webview_id(webview_id)
187                        .close_webview(webview_id);
188                    if let Err(error) = response_sender.send(()) {
189                        warn!("Failed to send response of CloseWebView: {error}");
190                    }
191                },
192                WebDriverCommandMsg::FocusWebView(webview_id) => {
193                    let window = self.window_for_webview_id(webview_id);
194                    window.activate_webview(webview_id);
195                    self.focus_window(window);
196                },
197                WebDriverCommandMsg::FocusBrowsingContext(..) => {
198                    self.servo().execute_webdriver_command(msg);
199                },
200                WebDriverCommandMsg::GetAllWebViews(response_sender) => {
201                    let webviews = self
202                        .windows()
203                        .values()
204                        .flat_map(|window| window.webview_ids())
205                        .collect();
206                    if let Err(error) = response_sender.send(webviews) {
207                        warn!("Failed to send response of GetAllWebViews: {error}");
208                    }
209                },
210                WebDriverCommandMsg::GetWindowRect(webview_id, response_sender) => {
211                    let platform_window = self.platform_window_for_webview_id(webview_id);
212                    if let Err(error) = response_sender.send(platform_window.window_rect()) {
213                        warn!("Failed to send response of GetWindowSize: {error}");
214                    }
215                },
216                WebDriverCommandMsg::MaximizeWebView(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_id(webview_id);
221                    platform_window.maximize(&webview);
222
223                    if let Err(error) = response_sender.send(platform_window.window_rect()) {
224                        warn!("Failed to send response of GetWindowSize: {error}");
225                    }
226                },
227                WebDriverCommandMsg::SetWindowRect(webview_id, requested_rect, size_sender) => {
228                    let Some(webview) = self.webview_by_id(webview_id) else {
229                        continue;
230                    };
231
232                    let platform_window = self.platform_window_for_webview_id(webview_id);
233                    let scale = platform_window.hidpi_scale_factor();
234
235                    let requested_physical_rect =
236                        (requested_rect.to_f32() * scale).round().to_i32();
237
238                    // Step 17. Set Width/Height.
239                    platform_window.request_resize(&webview, requested_physical_rect.size());
240
241                    // Step 18. Set position of the window.
242                    platform_window.set_position(requested_physical_rect.min);
243
244                    if let Err(error) = size_sender.send(platform_window.window_rect()) {
245                        warn!("Failed to send window size: {error}");
246                    }
247                },
248                WebDriverCommandMsg::GetViewportSize(webview_id, response_sender) => {
249                    let platform_window = self.platform_window_for_webview_id(webview_id);
250                    let size = platform_window.rendering_context().size2d().to_f32() /
251                        platform_window.hidpi_scale_factor();
252                    if let Err(error) = response_sender.send(size) {
253                        warn!("Failed to send response of GetViewportSize: {error}");
254                    }
255                },
256                // This is only received when start new session.
257                WebDriverCommandMsg::GetFocusedWebView(sender) => {
258                    let focused_webview = self
259                        .focused_window()
260                        .and_then(|window| window.active_webview())
261                        .map(|webview| webview.id());
262                    if let Err(error) = sender.send(focused_webview) {
263                        warn!("Failed to send response of GetFocusedWebView: {error}");
264                    };
265                },
266                WebDriverCommandMsg::LoadUrl(webview_id, url, load_status_sender) => {
267                    self.handle_webdriver_load_url(webview_id, url, load_status_sender);
268                },
269                WebDriverCommandMsg::Refresh(webview_id, load_status_sender) => {
270                    if let Some(webview) = self.webview_by_id(webview_id) {
271                        self.set_load_status_sender(webview_id, load_status_sender);
272                        webview.reload();
273                    }
274                },
275                WebDriverCommandMsg::GoBack(webview_id, load_status_sender) => {
276                    if let Some(webview) = self.webview_by_id(webview_id) {
277                        let traversal_id = webview.go_back(1);
278                        self.set_pending_traversal(traversal_id, load_status_sender);
279                    }
280                },
281                WebDriverCommandMsg::GoForward(webview_id, load_status_sender) => {
282                    if let Some(webview) = self.webview_by_id(webview_id) {
283                        let traversal_id = webview.go_forward(1);
284                        self.set_pending_traversal(traversal_id, load_status_sender);
285                    }
286                },
287                WebDriverCommandMsg::InputEvent(webview_id, input_event, response_sender) => {
288                    self.handle_webdriver_input_event(webview_id, input_event, response_sender);
289                },
290                WebDriverCommandMsg::ScriptCommand(_, ref webdriver_script_command) => {
291                    self.handle_webdriver_script_command(webdriver_script_command);
292                    self.servo().execute_webdriver_command(msg);
293                },
294                WebDriverCommandMsg::CurrentUserPrompt(webview_id, response_sender) => {
295                    let current_dialog = self
296                        .webdriver_embedder_controls
297                        .current_active_dialog_webdriver_type(webview_id);
298                    if let Err(error) = response_sender.send(current_dialog) {
299                        warn!("Failed to send response of CurrentUserPrompt: {error}");
300                    };
301                },
302                WebDriverCommandMsg::HandleUserPrompt(webview_id, action, response_sender) => {
303                    let controls = &self.webdriver_embedder_controls;
304                    let result = controls.respond_to_active_simple_dialog(webview_id, action);
305                    if let Err(error) = response_sender.send(result) {
306                        warn!("Failed to send response of HandleUserPrompt: {error}");
307                    };
308                },
309                WebDriverCommandMsg::GetAlertText(webview_id, response_sender) => {
310                    let response = match self
311                        .webdriver_embedder_controls
312                        .message_of_newest_dialog(webview_id)
313                    {
314                        Some(text) => Ok(text),
315                        None => Err(()),
316                    };
317
318                    if let Err(error) = response_sender.send(response) {
319                        warn!("Failed to send response of GetAlertText: {error}");
320                    };
321                },
322                WebDriverCommandMsg::SendAlertText(webview_id, text) => {
323                    self.webdriver_embedder_controls
324                        .set_prompt_value_of_newest_dialog(webview_id, text);
325                },
326                WebDriverCommandMsg::TakeScreenshot(webview_id, rect, result_sender) => {
327                    self.handle_webdriver_screenshot(webview_id, rect, result_sender);
328                },
329            };
330        }
331    }
332}
servoshell/webdriver.rs

servoshell/
webdriver.rs
