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

servoshell/
webdriver.rs
