devtools/
lib.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
5//! An actor-based remote devtools server implementation. Only tested with
6//! nightly Firefox versions at time of writing. Largely based on
7//! reverse-engineering of Firefox chrome devtool logs and reading of
8//! [code](https://searchfox.org/mozilla-central/source/devtools/server).
9
10#![crate_name = "devtools"]
11#![crate_type = "rlib"]
12#![deny(unsafe_code)]
13
14use std::borrow::ToOwned;
15use std::collections::HashMap;
16use std::io::Read;
17use std::net::{Ipv4Addr, Shutdown, SocketAddr, TcpListener, TcpStream};
18use std::str::FromStr;
19use std::sync::{Arc, Mutex};
20use std::thread;
21
22use crossbeam_channel::{Receiver, Sender, unbounded};
23use devtools_traits::{
24    ChromeToDevtoolsControlMsg, ConsoleLogLevel, ConsoleMessage, ConsoleMessageFields,
25    DevtoolScriptControlMsg, DevtoolsControlMsg, DevtoolsPageInfo, DomMutation, EnvironmentInfo,
26    FrameInfo, FrameOffset, NavigationState, NetworkEvent, PauseReason, ScriptToDevtoolsControlMsg,
27    SourceInfo, WorkerId, get_time_stamp,
28};
29use embedder_traits::{AllowOrDeny, EmbedderMsg, EmbedderProxy};
30use log::{trace, warn};
31use malloc_size_of::MallocSizeOf;
32use malloc_size_of_derive::MallocSizeOf;
33use profile_traits::path;
34use rand::{RngCore, rng};
35use resource::{ResourceArrayType, ResourceAvailable};
36use rustc_hash::FxHashMap;
37use serde::Serialize;
38use servo_base::generic_channel::{self, GenericSender};
39use servo_base::id::{BrowsingContextId, PipelineId, WebViewId};
40use servo_config::pref;
41
42use crate::actor::{Actor, ActorEncode, ActorError, ActorRegistry};
43use crate::actors::browsing_context::BrowsingContextActor;
44use crate::actors::console::{ConsoleActor, ConsoleResource, DevtoolsConsoleMessage, Root};
45use crate::actors::environment::EnvironmentActor;
46use crate::actors::frame::FrameActor;
47use crate::actors::framerate::FramerateActor;
48use crate::actors::inspector::InspectorActor;
49use crate::actors::inspector::walker::WalkerActor;
50use crate::actors::network_event::NetworkEventActor;
51use crate::actors::pause::PauseActor;
52use crate::actors::root::RootActor;
53use crate::actors::source::SourceActor;
54use crate::actors::thread::{ThreadActor, ThreadInterruptedReply};
55use crate::actors::watcher::WatcherActor;
56use crate::actors::worker::{WorkerActor, WorkerType};
57use crate::id::IdMap;
58use crate::network_handler::handle_network_event;
59use crate::protocol::{DevtoolsConnection, JsonPacketStream};
60
61mod actor;
62/// <https://searchfox.org/mozilla-central/source/devtools/server/actors>
63mod actors {
64    pub mod breakpoint;
65    pub mod browsing_context;
66    pub mod console;
67    pub mod device;
68    pub mod environment;
69    pub mod frame;
70    pub mod framerate;
71    pub mod inspector;
72    pub mod long_string;
73    pub mod memory;
74    pub mod network_event;
75    pub mod object;
76    pub mod pause;
77    pub mod performance;
78    pub mod preference;
79    pub mod process;
80    pub mod property_iterator;
81    pub mod reflow;
82    pub mod root;
83    pub mod source;
84    pub mod stylesheets;
85    pub mod tab;
86    pub mod thread;
87    pub mod timeline;
88    pub mod watcher;
89    pub mod worker;
90}
91mod id;
92mod network_handler;
93mod protocol;
94mod resource;
95use profile_traits::mem::{
96    ProcessReports, ProfilerChan, Report, ReportKind, perform_memory_report,
97};
98
99#[derive(Clone, Debug, Eq, Hash, PartialEq, MallocSizeOf)]
100enum UniqueId {
101    Pipeline(PipelineId),
102    Worker(WorkerId),
103}
104
105#[derive(Serialize)]
106pub(crate) struct EmptyReplyMsg {
107    pub from: String,
108}
109
110#[derive(Serialize)]
111pub(crate) struct ActorMsg {
112    pub actor: String,
113}
114
115/// Spin up a devtools server that listens for connections on the specified port.
116pub fn start_server(
117    embedder: EmbedderProxy,
118    mem_profiler_chan: ProfilerChan,
119) -> Sender<DevtoolsControlMsg> {
120    let (sender, receiver) = unbounded();
121    {
122        let sender = sender.clone();
123        let sender2 = sender.clone();
124        thread::Builder::new()
125            .name("Devtools".to_owned())
126            .spawn(move || {
127                mem_profiler_chan.run_with_memory_reporting(
128                    || {
129                        if let Some(instance) = DevtoolsInstance::create(sender, receiver, embedder)
130                        {
131                            instance.run()
132                        }
133                    },
134                    String::from("devtools-reporter"),
135                    sender2,
136                    |chan| {
137                        DevtoolsControlMsg::FromChrome(
138                            ChromeToDevtoolsControlMsg::CollectMemoryReport(chan),
139                        )
140                    },
141                )
142            })
143            .expect("Thread spawning failed");
144    }
145    sender
146}
147
148#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, MallocSizeOf)]
149pub(crate) struct StreamId(u32);
150
151#[derive(MallocSizeOf)]
152struct DevtoolsInstance {
153    #[conditional_malloc_size_of]
154    registry: Arc<ActorRegistry>,
155    #[conditional_malloc_size_of]
156    id_map: Arc<Mutex<IdMap>>,
157    browsing_contexts: FxHashMap<BrowsingContextId, String>,
158    /// This is handed to clients so they can notify the devtools instance when
159    /// their connection closes.
160    sender: Sender<DevtoolsControlMsg>,
161    receiver: Receiver<DevtoolsControlMsg>,
162    pipelines: FxHashMap<PipelineId, BrowsingContextId>,
163    actor_workers: FxHashMap<WorkerId, String>,
164    actor_requests: HashMap<String, String>,
165    /// A map of active TCP connections to devtools clients.
166    ///
167    /// Client threads remove their connection from here once they exit.
168    #[conditional_malloc_size_of]
169    connections: Arc<Mutex<FxHashMap<StreamId, DevtoolsConnection>>>,
170    next_resource_id: u64,
171}
172
173impl DevtoolsInstance {
174    fn create(
175        sender: Sender<DevtoolsControlMsg>,
176        receiver: Receiver<DevtoolsControlMsg>,
177        embedder: EmbedderProxy,
178    ) -> Option<Self> {
179        let address = if pref!(devtools_server_listen_address).is_empty() {
180            SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), 7000)
181        } else if let Ok(addr) = SocketAddr::from_str(&pref!(devtools_server_listen_address)) {
182            addr
183        } else if let Ok(port) = pref!(devtools_server_listen_address).parse() {
184            SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), port)
185        } else {
186            SocketAddr::new(Ipv4Addr::new(127, 0, 0, 1).into(), 7000)
187        };
188        println!("Binding devtools to {address}");
189
190        let bound = TcpListener::bind(address).ok().and_then(|l| {
191            l.local_addr()
192                .map(|addr| addr.port())
193                .ok()
194                .map(|port| (l, port))
195        });
196
197        // A token shared with the embedder to bypass permission prompt.
198        let port = if bound.is_some() {
199            Ok(address.port())
200        } else {
201            Err(())
202        };
203        let token = format!("{:X}", rng().next_u32());
204        embedder.send(EmbedderMsg::OnDevtoolsStarted(port, token.clone()));
205
206        let listener = match bound {
207            Some((l, _)) => l,
208            None => {
209                return None;
210            },
211        };
212
213        // Create basic actors
214        let mut registry = ActorRegistry::default();
215        RootActor::register(&mut registry);
216
217        let instance = Self {
218            registry: Arc::new(registry),
219            id_map: Arc::new(Mutex::new(IdMap::default())),
220            browsing_contexts: FxHashMap::default(),
221            pipelines: FxHashMap::default(),
222            sender: sender.clone(),
223            receiver,
224            actor_requests: HashMap::new(),
225            actor_workers: FxHashMap::default(),
226            connections: Default::default(),
227            next_resource_id: 1,
228        };
229
230        thread::Builder::new()
231            .name("DevtoolsCliAcceptor".to_owned())
232            .spawn(move || {
233                // accept connections and process them, spawning a new thread for each one
234                for stream in listener.incoming() {
235                    let mut stream = stream.expect("Can't retrieve stream");
236                    if !allow_devtools_client(&mut stream, &embedder, &token) {
237                        continue;
238                    };
239                    // connection succeeded and accepted
240                    sender
241                        .send(DevtoolsControlMsg::FromChrome(
242                            ChromeToDevtoolsControlMsg::AddClient(stream),
243                        ))
244                        .unwrap();
245                }
246            })
247            .expect("Thread spawning failed");
248
249        Some(instance)
250    }
251
252    fn run(mut self) {
253        let mut next_id = StreamId(0);
254        while let Ok(msg) = self.receiver.recv() {
255            trace!("{:?}", msg);
256            match msg {
257                DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::AddClient(stream)) => {
258                    let id = next_id;
259                    next_id = StreamId(id.0 + 1);
260
261                    {
262                        let connections = self.connections.lock().unwrap();
263                        if connections.is_empty() {
264                            // We used to have no connection, now we have one.
265                            // Therefore, we need updates from script threads.
266                            for browsing_context_name in self.browsing_contexts.values() {
267                                let browsing_context_actor = self
268                                    .registry
269                                    .find::<BrowsingContextActor>(browsing_context_name);
270                                browsing_context_actor.instruct_script_to_send_live_updates(true);
271                            }
272                        }
273                    }
274
275                    let connection: DevtoolsConnection = stream.into();
276                    let registry = self.registry.clone();
277                    let connections = self.connections.clone();
278                    let sender_clone = self.sender.clone();
279                    thread::Builder::new()
280                        .name("DevtoolsClientHandler".to_owned())
281                        .spawn(move || {
282                            handle_client(registry, connection, id, connections, sender_clone)
283                        })
284                        .expect("Thread spawning failed");
285                },
286                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::FramerateTick(
287                    actor_name,
288                    tick,
289                )) => self.handle_framerate_tick(actor_name, tick),
290                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::TitleChanged(
291                    pipeline,
292                    title,
293                )) => self.handle_title_changed(pipeline, title),
294                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::NewGlobal(
295                    ids,
296                    script_sender,
297                    pageinfo,
298                )) => self.handle_new_global(ids, script_sender, pageinfo),
299                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::Navigate(
300                    browsing_context,
301                    state,
302                )) => self.handle_navigate(browsing_context, state),
303                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::ConsoleAPI(
304                    pipeline_id,
305                    console_message,
306                    worker_id,
307                )) => {
308                    let console_message =
309                        DevtoolsConsoleMessage::new(console_message, &self.registry);
310                    self.handle_console_resource(
311                        pipeline_id,
312                        worker_id,
313                        ConsoleResource::ConsoleMessage(console_message),
314                    );
315                },
316                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::ClearConsole(
317                    pipeline_id,
318                    worker_id,
319                )) => self.handle_clear_console(pipeline_id, worker_id),
320                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::CreateSourceActor(
321                    script_sender,
322                    pipeline_id,
323                    source_info,
324                )) => self.handle_create_source_actor(script_sender, pipeline_id, source_info),
325                DevtoolsControlMsg::FromScript(
326                    ScriptToDevtoolsControlMsg::UpdateSourceContent(pipeline_id, source_content),
327                ) => self.handle_update_source_content(pipeline_id, source_content),
328                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::ReportPageError(
329                    pipeline_id,
330                    page_error,
331                )) => self.handle_console_resource(
332                    pipeline_id,
333                    None,
334                    ConsoleResource::PageError(page_error.into()),
335                ),
336                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::ReportCSSError(
337                    pipeline_id,
338                    css_error,
339                )) => {
340                    let console_message = ConsoleMessage {
341                        fields: ConsoleMessageFields {
342                            level: ConsoleLogLevel::Warn,
343                            filename: css_error.filename,
344                            line_number: css_error.line,
345                            column_number: css_error.column,
346                            time_stamp: get_time_stamp(),
347                        },
348                        arguments: vec![css_error.msg.into()],
349                        stacktrace: None,
350                    };
351                    let console_message =
352                        DevtoolsConsoleMessage::new(console_message, &self.registry);
353
354                    self.handle_console_resource(
355                        pipeline_id,
356                        None,
357                        ConsoleResource::ConsoleMessage(console_message),
358                    )
359                },
360                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::DomMutation(
361                    pipeline_id,
362                    dom_mutation,
363                )) => {
364                    self.handle_dom_mutation(pipeline_id, dom_mutation).unwrap();
365                },
366                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::DebuggerPause(
367                    pipeline_id,
368                    frame_offset,
369                    pause_reason,
370                )) => self.handle_debugger_pause(pipeline_id, frame_offset, pause_reason),
371                DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::CreateFrameActor(
372                    result_sender,
373                    pipeline_id,
374                    frame_info,
375                )) => self.handle_create_frame_actor(result_sender, pipeline_id, frame_info),
376                DevtoolsControlMsg::FromScript(
377                    ScriptToDevtoolsControlMsg::CreateEnvironmentActor(
378                        result_sender,
379                        environment,
380                        parent,
381                    ),
382                ) => self.handle_create_environment_actor(result_sender, environment, parent),
383                DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::NetworkEvent(
384                    request_id,
385                    network_event,
386                )) => {
387                    // copy the connections vector
388                    // FIXME: Why do we need to do this? Cloning the connections here is
389                    // almost certainly wrong and means that they might shut down without
390                    // us noticing.
391                    let mut connections = Vec::<DevtoolsConnection>::new();
392                    for connection in self.connections.lock().unwrap().values() {
393                        connections.push(connection.clone());
394                    }
395                    self.handle_network_event(connections, request_id, network_event);
396                },
397                DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::ServerExitMsg) => break,
398                DevtoolsControlMsg::FromChrome(
399                    ChromeToDevtoolsControlMsg::CollectMemoryReport(chan),
400                ) => {
401                    perform_memory_report(|ops| {
402                        let reports = vec![Report {
403                            path: path!["devtools"],
404                            kind: ReportKind::ExplicitSystemHeapSize,
405                            size: self.size_of(ops),
406                        }];
407                        chan.send(ProcessReports::new(reports));
408                    });
409                },
410                DevtoolsControlMsg::ClientExited => {
411                    if self.connections.lock().unwrap().is_empty() {
412                        // Tell every browsing context to stop sending us updates, because we have nowhere to
413                        // send them to.
414                        for browsing_context_name in self.browsing_contexts.values() {
415                            let browsing_context_actor = self
416                                .registry
417                                .find::<BrowsingContextActor>(browsing_context_name);
418                            browsing_context_actor.instruct_script_to_send_live_updates(false);
419                        }
420                    }
421                },
422            }
423        }
424
425        // Shut down all active connections
426        let mut connections = self.connections.lock().unwrap();
427        for connection in connections.values_mut() {
428            let _ = connection.shutdown(Shutdown::Both);
429        }
430        connections.clear();
431    }
432
433    fn handle_framerate_tick(&self, actor_name: String, tick: f64) {
434        let framerate_actor = self.registry.find::<FramerateActor>(&actor_name);
435        framerate_actor.add_tick(tick);
436    }
437
438    fn handle_navigate(&self, browsing_context_id: BrowsingContextId, state: NavigationState) {
439        let browsing_context_name = self.browsing_contexts.get(&browsing_context_id).unwrap();
440        let browsing_context_actor = self
441            .registry
442            .find::<BrowsingContextActor>(browsing_context_name);
443        let mut id_map = self.id_map.lock().unwrap();
444        let mut connections = self.connections.lock().unwrap();
445        if let NavigationState::Start(url) = &state {
446            let watcher_actor = self
447                .registry
448                .find::<WatcherActor>(&browsing_context_actor.watcher_name);
449            watcher_actor.emit_will_navigate(
450                browsing_context_id,
451                url.clone(),
452                &mut connections.values_mut(),
453                &mut id_map,
454            );
455        }
456
457        browsing_context_actor.handle_navigate(state, &mut id_map, connections.values_mut());
458    }
459
460    // We need separate actor representations for each script global that exists;
461    // clients can theoretically connect to multiple globals simultaneously.
462    // TODO: move this into the root or target modules?
463    fn handle_new_global(
464        &mut self,
465        ids: (BrowsingContextId, PipelineId, Option<WorkerId>, WebViewId),
466        script_sender: GenericSender<DevtoolScriptControlMsg>,
467        page_info: DevtoolsPageInfo,
468    ) {
469        let (browsing_context_id, pipeline_id, worker_id, webview_id) = ids;
470        let id_map = &mut self.id_map.lock().unwrap();
471        let devtools_browser_id = id_map.browser_id(webview_id);
472        let devtools_browsing_context_id = id_map.browsing_context_id(browsing_context_id);
473        let devtools_outer_window_id = id_map.outer_window_id(pipeline_id);
474
475        let console_name = self.registry.new_name::<ConsoleActor>();
476
477        let parent_actor = if let Some(id) = worker_id {
478            let thread_name = ThreadActor::register(&self.registry, script_sender.clone(), None);
479
480            let worker_type = if page_info.is_service_worker {
481                WorkerType::Service
482            } else {
483                WorkerType::Dedicated
484            };
485            let worker_name = self.registry.new_name::<WorkerActor>();
486            let worker = WorkerActor {
487                name: worker_name.clone(),
488                console_name: console_name.clone(),
489                thread_name,
490                worker_id: id,
491                url: page_info.url,
492                type_: worker_type,
493                script_chan: script_sender,
494                streams: Default::default(),
495            };
496            let root_actor = self.registry.find::<RootActor>("root");
497            if page_info.is_service_worker {
498                root_actor
499                    .service_workers
500                    .borrow_mut()
501                    .push(worker.name.clone());
502            } else {
503                root_actor.workers.borrow_mut().push(worker.name.clone());
504            }
505
506            self.actor_workers.insert(id, worker_name.clone());
507            self.registry.register(worker);
508
509            Root::DedicatedWorker(worker_name)
510        } else {
511            self.pipelines.insert(pipeline_id, browsing_context_id);
512            let browsing_context_name = self
513                .browsing_contexts
514                .entry(browsing_context_id)
515                .or_insert_with(|| {
516                    BrowsingContextActor::register(
517                        &self.registry,
518                        console_name.clone(),
519                        devtools_browser_id,
520                        devtools_browsing_context_id,
521                        page_info,
522                        pipeline_id,
523                        devtools_outer_window_id,
524                        script_sender.clone(),
525                    )
526                });
527            let browsing_context_actor = self
528                .registry
529                .find::<BrowsingContextActor>(browsing_context_name);
530            browsing_context_actor.handle_new_global(pipeline_id, script_sender);
531            Root::BrowsingContext(browsing_context_name.clone())
532        };
533
534        ConsoleActor::register(&self.registry, console_name, parent_actor);
535    }
536
537    fn handle_title_changed(&self, pipeline_id: PipelineId, title: String) {
538        let browsing_context_id = match self.pipelines.get(&pipeline_id) {
539            Some(bc) => bc,
540            None => return,
541        };
542        let browsing_context_name = match self.browsing_contexts.get(browsing_context_id) {
543            Some(name) => name,
544            None => return,
545        };
546        let browsing_context_actor = self
547            .registry
548            .find::<BrowsingContextActor>(browsing_context_name);
549        browsing_context_actor.title_changed(pipeline_id, title);
550    }
551
552    fn handle_console_resource(
553        &mut self,
554        pipeline_id: PipelineId,
555        worker_id: Option<WorkerId>,
556        resource: ConsoleResource,
557    ) {
558        let console_actor_name = match self.find_console_actor(pipeline_id, worker_id) {
559            Some(name) => name,
560            None => return,
561        };
562        let console_actor = self.registry.find::<ConsoleActor>(&console_actor_name);
563        let id = worker_id.map_or(UniqueId::Pipeline(pipeline_id), UniqueId::Worker);
564
565        for connection in self.connections.lock().unwrap().values_mut() {
566            console_actor.handle_console_resource(
567                resource.clone(),
568                id.clone(),
569                &self.registry,
570                connection,
571            );
572        }
573    }
574
575    fn handle_dom_mutation(
576        &mut self,
577        pipeline_id: PipelineId,
578        dom_mutation: DomMutation,
579    ) -> Result<(), ActorError> {
580        let Some(browsing_context_id) = self.pipelines.get(&pipeline_id) else {
581            log::warn!("Devtools received notification for unknown pipeline {pipeline_id}");
582            return Err(ActorError::Internal);
583        };
584        let Some(browsing_context_name) = self.browsing_contexts.get(browsing_context_id) else {
585            return Err(ActorError::Internal);
586        };
587        let browsing_context_actor = self
588            .registry
589            .find::<BrowsingContextActor>(browsing_context_name);
590        let inspector_actor = self
591            .registry
592            .find::<InspectorActor>(&browsing_context_actor.inspector_name);
593        let walker_actor = self
594            .registry
595            .find::<WalkerActor>(&inspector_actor.walker_name);
596
597        for connection in self.connections.lock().unwrap().values_mut() {
598            walker_actor.handle_dom_mutation(dom_mutation.clone(), connection)?;
599        }
600
601        Ok(())
602    }
603
604    fn handle_clear_console(&mut self, pipeline_id: PipelineId, worker_id: Option<WorkerId>) {
605        let console_actor_name = match self.find_console_actor(pipeline_id, worker_id) {
606            Some(name) => name,
607            None => return,
608        };
609        let console_actor = self.registry.find::<ConsoleActor>(&console_actor_name);
610        let id = worker_id.map_or(UniqueId::Pipeline(pipeline_id), UniqueId::Worker);
611
612        for stream in self.connections.lock().unwrap().values_mut() {
613            console_actor.send_clear_message(id.clone(), &self.registry, stream);
614        }
615    }
616
617    fn find_console_actor(
618        &self,
619        pipeline_id: PipelineId,
620        worker_id: Option<WorkerId>,
621    ) -> Option<String> {
622        if let Some(worker_id) = worker_id {
623            let worker_name = self.actor_workers.get(&worker_id)?;
624            Some(
625                self.registry
626                    .find::<WorkerActor>(worker_name)
627                    .console_name
628                    .clone(),
629            )
630        } else {
631            let browsing_context_id = self.pipelines.get(&pipeline_id)?;
632            let browsing_context_name = self.browsing_contexts.get(browsing_context_id)?;
633            Some(
634                self.registry
635                    .find::<BrowsingContextActor>(browsing_context_name)
636                    .console_name
637                    .clone(),
638            )
639        }
640    }
641
642    fn handle_network_event(
643        &mut self,
644        connections: Vec<DevtoolsConnection>,
645        request_id: String,
646        network_event: NetworkEvent,
647    ) {
648        let browsing_context_id = match &network_event {
649            NetworkEvent::HttpRequest(req) => req.browsing_context_id,
650            NetworkEvent::HttpRequestUpdate(req) => req.browsing_context_id,
651            NetworkEvent::HttpResponse(resp) => resp.browsing_context_id,
652            NetworkEvent::SecurityInfo(update) => update.browsing_context_id,
653        };
654
655        let Some(browsing_context_name) = self.browsing_contexts.get(&browsing_context_id) else {
656            return;
657        };
658        let watcher_name = self
659            .registry
660            .find::<BrowsingContextActor>(browsing_context_name)
661            .watcher_name
662            .clone();
663
664        let network_event_name = match self.actor_requests.get(&request_id) {
665            Some(name) => name.clone(),
666            None => self.create_network_event_actor(request_id, watcher_name),
667        };
668
669        handle_network_event(
670            Arc::clone(&self.registry),
671            network_event_name,
672            connections,
673            network_event,
674        )
675    }
676
677    /// Create a new NetworkEventActor for a given request ID and watcher name.
678    fn create_network_event_actor(&mut self, request_id: String, watcher_name: String) -> String {
679        let resource_id = self.next_resource_id;
680        self.next_resource_id += 1;
681
682        let network_event_name =
683            NetworkEventActor::register(&self.registry, resource_id, watcher_name);
684
685        self.actor_requests
686            .insert(request_id, network_event_name.clone());
687
688        network_event_name
689    }
690
691    fn handle_create_source_actor(
692        &mut self,
693        script_sender: GenericSender<DevtoolScriptControlMsg>,
694        pipeline_id: PipelineId,
695        source_info: SourceInfo,
696    ) {
697        let source_content = source_info
698            .content
699            .or_else(|| self.registry.inline_source_content(pipeline_id));
700        let source_actor = SourceActor::register(
701            &self.registry,
702            pipeline_id,
703            source_info.url,
704            source_content,
705            source_info.content_type,
706            source_info.spidermonkey_id,
707            source_info.introduction_type,
708            script_sender,
709        );
710        let source_form = self
711            .registry
712            .find::<SourceActor>(&source_actor)
713            .source_form();
714
715        if let Some(worker_id) = source_info.worker_id {
716            let Some(worker_name) = self.actor_workers.get(&worker_id) else {
717                return;
718            };
719
720            let thread_actor_name = self
721                .registry
722                .find::<WorkerActor>(worker_name)
723                .thread_name
724                .clone();
725            let thread_actor = self.registry.find::<ThreadActor>(&thread_actor_name);
726
727            thread_actor.source_manager.add_source(&source_actor);
728
729            let worker_actor = self.registry.find::<WorkerActor>(worker_name);
730
731            for stream in self.connections.lock().unwrap().values_mut() {
732                worker_actor.resource_array(
733                    &source_form,
734                    "source".into(),
735                    ResourceArrayType::Available,
736                    stream,
737                );
738            }
739        } else {
740            let Some(browsing_context_id) = self.pipelines.get(&pipeline_id) else {
741                return;
742            };
743            let Some(browsing_context_name) = self.browsing_contexts.get(browsing_context_id)
744            else {
745                return;
746            };
747
748            let thread_actor_name = {
749                let browsing_context_actor = self
750                    .registry
751                    .find::<BrowsingContextActor>(browsing_context_name);
752                browsing_context_actor.thread_name.clone()
753            };
754
755            let thread_actor = self.registry.find::<ThreadActor>(&thread_actor_name);
756            thread_actor.source_manager.add_source(&source_actor);
757
758            // Notify browsing context about the new source
759            let browsing_context_actor = self
760                .registry
761                .find::<BrowsingContextActor>(browsing_context_name);
762
763            for stream in self.connections.lock().unwrap().values_mut() {
764                browsing_context_actor.resource_array(
765                    &source_form,
766                    "source".into(),
767                    ResourceArrayType::Available,
768                    stream,
769                );
770            }
771        }
772    }
773
774    fn handle_update_source_content(&mut self, pipeline_id: PipelineId, source_content: String) {
775        for source_name in self.registry.source_actor_names_for_pipeline(pipeline_id) {
776            let source_actor = self.registry.find::<SourceActor>(&source_name);
777            let mut content = source_actor.content.borrow_mut();
778            if content.is_none() {
779                *content = Some(source_content.clone());
780            }
781        }
782
783        // Store the source content separately for any future source actors that get created *after* we finish parsing
784        // the HTML. For example, adding an `import` to an inline module script can delay it until after parsing.
785        self.registry
786            .set_inline_source_content(pipeline_id, source_content);
787    }
788
789    fn handle_debugger_pause(
790        &mut self,
791        pipeline_id: PipelineId,
792        frame_offset: FrameOffset,
793        pause_reason: PauseReason,
794    ) {
795        let Some(browsing_context_name) = self
796            .pipelines
797            .get(&pipeline_id)
798            .and_then(|id| self.browsing_contexts.get(id))
799        else {
800            return;
801        };
802
803        let browsing_context_actor = self
804            .registry
805            .find::<BrowsingContextActor>(browsing_context_name);
806        let thread = self
807            .registry
808            .find::<ThreadActor>(&browsing_context_actor.thread_name);
809
810        let pause_name = self.registry.new_name::<PauseActor>();
811        self.registry.register(PauseActor {
812            name: pause_name.clone(),
813        });
814
815        let frame_actor = self.registry.find::<FrameActor>(&frame_offset.actor);
816        frame_actor.set_offset(frame_offset.column, frame_offset.line);
817
818        let msg = ThreadInterruptedReply {
819            from: thread.name(),
820            type_: "paused".to_owned(),
821            actor: pause_name,
822            frame: frame_actor.encode(&self.registry),
823            why: pause_reason,
824        };
825
826        for stream in self.connections.lock().unwrap().values_mut() {
827            let _ = stream.write_json_packet(&msg);
828        }
829    }
830
831    fn handle_create_frame_actor(
832        &mut self,
833        result_sender: GenericSender<String>,
834        pipeline_id: PipelineId,
835        frame: FrameInfo,
836    ) {
837        let Some(browsing_context_name) = self
838            .pipelines
839            .get(&pipeline_id)
840            .and_then(|id| self.browsing_contexts.get(id))
841        else {
842            return;
843        };
844
845        let browsing_context_actor = self
846            .registry
847            .find::<BrowsingContextActor>(browsing_context_name);
848        let thread = self
849            .registry
850            .find::<ThreadActor>(&browsing_context_actor.thread_name);
851
852        let source = match thread
853            .source_manager
854            .find_source(&self.registry, &frame.url)
855        {
856            Some(source) => source.name(),
857            None => {
858                warn!("No source actor found for URL: {}", frame.url);
859                return;
860            },
861        };
862
863        let frame_name = FrameActor::register(&self.registry, source, frame);
864
865        let _ = result_sender.send(frame_name);
866    }
867
868    fn handle_create_environment_actor(
869        &mut self,
870        result_sender: GenericSender<String>,
871        environment_info: EnvironmentInfo,
872        parent: Option<String>,
873    ) {
874        let environment_name = EnvironmentActor::register(&self.registry, environment_info, parent);
875        let _ = result_sender.send(environment_name);
876    }
877}
878
879fn allow_devtools_client(stream: &mut TcpStream, embedder: &EmbedderProxy, token: &str) -> bool {
880    // By-pass prompt if we receive a valid token.
881    let token = format!("25:{{\"auth_token\":\"{}\"}}", token);
882    let mut buf = [0; 28];
883    let timeout = std::time::Duration::from_millis(500);
884    // This will read but not consume the bytes from the stream.
885    stream.set_read_timeout(Some(timeout)).unwrap();
886    let peek = stream.peek(&mut buf);
887    stream.set_read_timeout(None).unwrap();
888    if let Ok(len) = peek {
889        if len == buf.len() {
890            if let Ok(s) = std::str::from_utf8(&buf) {
891                if s == token {
892                    // Consume the message as it was relevant to us.
893                    let _ = stream.read_exact(&mut buf);
894                    return true;
895                }
896            }
897        }
898    };
899
900    // No token found. Prompt user
901    let (request_sender, request_receiver) =
902        generic_channel::channel().expect("Failed to create IPC channel!");
903    embedder.send(EmbedderMsg::RequestDevtoolsConnection(request_sender));
904    request_receiver.recv().unwrap() == AllowOrDeny::Allow
905}
906
907/// Process the input from a single devtools client until EOF.
908fn handle_client(
909    registry: Arc<ActorRegistry>,
910    mut stream: DevtoolsConnection,
911    stream_id: StreamId,
912    connections: Arc<Mutex<FxHashMap<StreamId, DevtoolsConnection>>>,
913    sender: Sender<DevtoolsControlMsg>,
914) {
915    connections
916        .lock()
917        .unwrap()
918        .insert(stream_id, stream.clone());
919
920    log::info!("Connection established to {}", stream.peer_addr().unwrap());
921    let msg = registry.encode::<RootActor, _>("root");
922    if let Err(error) = stream.write_json_packet(&msg) {
923        warn!("Failed to send initial packet from root actor: {error:?}");
924        return;
925    }
926
927    loop {
928        match stream.read_json_packet() {
929            Ok(Some(json_packet)) => {
930                if let Err(()) = registry.handle_message(
931                    json_packet.as_object().unwrap(),
932                    &mut stream,
933                    stream_id,
934                ) {
935                    log::error!("Devtools actor stopped responding");
936                    let _ = stream.shutdown(Shutdown::Both);
937                    break;
938                }
939            },
940            Ok(None) => {
941                log::info!("Devtools connection closed");
942                break;
943            },
944            Err(err_msg) => {
945                log::error!("Failed to read message from devtools client: {}", err_msg);
946                break;
947            },
948        }
949    }
950
951    connections.lock().unwrap().remove(&stream_id);
952    let _ = sender.send(DevtoolsControlMsg::ClientExited);
953
954    registry.cleanup(stream_id);
955}
devtools/lib.rs

devtools/
lib.rs
