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

devtools/
lib.rs
