servo/
responders.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;
6
7use crossbeam_channel::{Receiver, Sender, TryRecvError, unbounded};
8use log::warn;
9use serde::{Deserialize, Serialize};
10use servo_base::generic_channel::{GenericCallback, GenericSender, SendError, SendResult};
11use tokio::sync::mpsc::UnboundedSender as TokioSender;
12use tokio::sync::oneshot::Sender as TokioOneshotSender;
13
14use crate::ServoError;
15
16/// Sender for errors raised by delegate request objects.
17///
18/// This allows errors to be raised asynchronously.
19pub(crate) struct ServoErrorSender {
20    sender: Sender<ServoError>,
21}
22
23impl ServoErrorSender {
24    pub(crate) fn raise_response_send_error(&self, error: SendError) {
25        if let Err(error) = self.sender.send(ServoError::ResponseFailedToSend(error)) {
26            warn!("Failed to send Servo error: {error:?}");
27        }
28    }
29}
30
31/// Channel for errors raised by [`WebViewDelegate`](crate::WebViewDelegate) request objects.
32///
33/// This allows errors to be raised asynchronously.
34pub(crate) struct ServoErrorChannel {
35    sender: Sender<ServoError>,
36    receiver: Receiver<ServoError>,
37}
38
39impl Default for ServoErrorChannel {
40    fn default() -> Self {
41        let (sender, receiver) = unbounded();
42        Self { sender, receiver }
43    }
44}
45
46impl ServoErrorChannel {
47    pub(crate) fn sender(&self) -> ServoErrorSender {
48        ServoErrorSender {
49            sender: self.sender.clone(),
50        }
51    }
52
53    pub(crate) fn try_recv(&self) -> Option<ServoError> {
54        match self.receiver.try_recv() {
55            Ok(result) => Some(result),
56            Err(error) => {
57                debug_assert_eq!(error, TryRecvError::Empty);
58                None
59            },
60        }
61    }
62}
63
64pub(crate) trait AbstractSender {
65    type Message;
66    fn send(&self, value: Self::Message) -> SendResult;
67}
68
69impl<T: Serialize> AbstractSender for GenericSender<T> {
70    type Message = T;
71    fn send(&self, value: T) -> SendResult {
72        GenericSender::send(self, value)
73    }
74}
75
76impl<T: for<'de> Deserialize<'de> + Serialize + Send + 'static> AbstractSender
77    for GenericCallback<T>
78{
79    type Message = T;
80    fn send(&self, value: T) -> SendResult {
81        GenericCallback::send(self, value)
82    }
83}
84
85impl<T> AbstractSender for TokioSender<T> {
86    type Message = T;
87    fn send(&self, value: T) -> SendResult {
88        TokioSender::send(self, value).map_err(|_| SendError::Disconnected)
89    }
90}
91
92pub(crate) struct OneshotSender<T>(RefCell<Option<TokioOneshotSender<T>>>);
93
94impl<T> From<TokioOneshotSender<T>> for OneshotSender<T> {
95    fn from(sender: TokioOneshotSender<T>) -> Self {
96        Self(RefCell::new(Some(sender)))
97    }
98}
99
100impl<T> AbstractSender for OneshotSender<T> {
101    type Message = T;
102    fn send(&self, value: T) -> SendResult {
103        let sender = self.0.borrow_mut().take();
104        if let Some(sender) = sender {
105            TokioOneshotSender::send(sender, value).map_err(|_| SendError::Disconnected)
106        } else {
107            Err(SendError::Disconnected)
108        }
109    }
110}
111
112/// Sends a response over an IPC channel, or a default response on [`Drop`] if no response was sent.
113pub(crate) struct IpcResponder<T> {
114    response_sender: Box<dyn AbstractSender<Message = T>>,
115    response_sent: bool,
116    /// Always present, except when taken by [`Drop`].
117    default_response: Option<T>,
118}
119
120impl<T: Serialize + 'static> IpcResponder<T> {
121    pub(crate) fn new(response_sender: GenericSender<T>, default_response: T) -> Self {
122        Self {
123            response_sender: Box::new(response_sender),
124            response_sent: false,
125            default_response: Some(default_response),
126        }
127    }
128}
129
130impl<T: 'static> IpcResponder<T> {
131    pub(crate) fn new_same_process(
132        response_sender: Box<dyn AbstractSender<Message = T>>,
133        default_response: T,
134    ) -> Self {
135        Self {
136            response_sender,
137            response_sent: false,
138            default_response: Some(default_response),
139        }
140    }
141}
142
143impl<T> IpcResponder<T> {
144    pub(crate) fn send(&mut self, response: T) -> SendResult {
145        let result = self.response_sender.send(response);
146        self.response_sent = true;
147        result
148    }
149}
150
151impl<T> Drop for IpcResponder<T> {
152    fn drop(&mut self) {
153        if !self.response_sent {
154            let response = self
155                .default_response
156                .take()
157                .expect("Guaranteed by inherent impl");
158            // Don’t notify embedder about send errors for the default response,
159            // since they didn’t send anything and probably don’t care.
160            let _ = self.response_sender.send(response);
161        }
162    }
163}
servo/responders.rs

servo/
responders.rs
