Create source actors from Debugger API notifications

Co-authored-by: atbrakhi <atbrakhi@igalia.com>
Signed-off-by: Delan Azabani <dazabani@igalia.com>

components/script/dom/debuggerglobalscope.rs

@@ -4,18 +4,22 @@
 
 use std::sync::Arc;
 
-use base::id::PipelineId;
+use base::id::{Index, PipelineId, PipelineNamespaceId};
 use constellation_traits::ScriptToConstellationChan;
 use crossbeam_channel::Sender;
-use devtools_traits::ScriptToDevtoolsControlMsg;
+use devtools_traits::{ScriptToDevtoolsControlMsg, SourceInfo};
 use dom_struct::dom_struct;
 use embedder_traits::resources::{self, Resource};
 use ipc_channel::ipc::IpcSender;
-use js::jsval::UndefinedValue;
+use js::gc::HandleValue;
+use js::jsval::{UInt32Value, UndefinedValue};
 use js::rust::Runtime;
 use js::rust::wrappers::JS_DefineDebuggerObject;
 use net_traits::ResourceThreads;
 use profile_traits::{mem, time};
+use script_bindings::codegen::GenericBindings::DebuggerGlobalScopeBinding::{
+    DebuggerGlobalScopeMethods, NotifyNewSource,
+};
 use script_bindings::conversions::SafeToJSValConvertible;
 use script_bindings::realms::InRealm;
 use script_bindings::reflector::DomObject;
@@ -102,6 +106,10 @@ impl DebuggerGlobalScope {
         GlobalScope::get_cx()
     }
 
+    pub(crate) fn as_global_scope(&self) -> &GlobalScope {
+        self.upcast::<GlobalScope>()
+    }
+
     fn evaluate_js(&self, script: &str, can_gc: CanGc) -> bool {
         rooted!(in (*Self::get_cx()) let mut rval = UndefinedValue());
         self.global_scope.evaluate_js_on_global_with_result(
@@ -120,29 +128,83 @@ impl DebuggerGlobalScope {
     }
 
     #[allow(unsafe_code)]
-    pub(crate) fn execute_with_global(&self, can_gc: CanGc, global: &GlobalScope) {
+    pub(crate) fn execute_new_global(
+        &self,
+        can_gc: CanGc,
+        global: &GlobalScope,
+        pipeline_id: PipelineId,
+    ) {
         let cx = Self::get_cx();
-        rooted!(in(*cx) let mut property_value = UndefinedValue());
+        rooted!(in(*cx) let pipeline_namespace_id = UInt32Value(pipeline_id.namespace_id.0));
+        rooted!(in(*cx) let pipeline_index = UInt32Value(pipeline_id.index.0.get()));
+        rooted!(in(*cx) let mut debuggee = UndefinedValue());
 
         let _realm = enter_realm(self);
         // Convert the debuggee global’s reflector to a Value, wrapping it from its originating realm (debuggee realm)
         // into the active realm (debugger realm) so that it can be passed across compartments.
-        global
-            .reflector()
-            .safe_to_jsval(cx, property_value.handle_mut());
+        global.reflector().safe_to_jsval(cx, debuggee.handle_mut());
 
         // TODO: what invariants do we need to uphold for the unsafe call?
-        if let Err(()) = unsafe {
-            set_dictionary_property(
-                *cx,
-                self.global_scope.reflector().get_jsobject(),
-                "debuggee",
-                property_value.handle(),
-            )
-        } {
-            warn!("Failed to set debuggee");
+        if let Err(()) = (|| -> Result<(), ()> {
+            unsafe {
+                set_dictionary_property(
+                    *cx,
+                    self.global_scope.reflector().get_jsobject(),
+                    "pipelineNamespaceId",
+                    pipeline_namespace_id.handle(),
+                )?;
+                set_dictionary_property(
+                    *cx,
+                    self.global_scope.reflector().get_jsobject(),
+                    "pipelineIndex",
+                    pipeline_index.handle(),
+                )?;
+                set_dictionary_property(
+                    *cx,
+                    self.global_scope.reflector().get_jsobject(),
+                    "debuggee",
+                    debuggee.handle(),
+                )
+            }
+        })() {
+            warn!("Failed to set properties");
             return;
         }
         self.execute(can_gc);
     }
 }
+
+impl DebuggerGlobalScopeMethods<crate::DomTypeHolder> for DebuggerGlobalScope {
+    // check-tidy: no specs after this line
+    fn NotifyNewSource(&self, args: &NotifyNewSource) {
+        info!(
+            "NotifyNewSource: ({},{}) {} {} {}",
+            args.pipelineId.namespaceId,
+            args.pipelineId.index,
+            args.spidermonkeyId,
+            args.url,
+            args.text
+        );
+        if let Some(devtools_chan) = self.as_global_scope().devtools_chan() {
+            let pipeline_id = PipelineId {
+                namespace_id: PipelineNamespaceId(args.pipelineId.namespaceId),
+                index: Index::new(args.pipelineId.index)
+                    .expect("`pipelineId.index` must not be zero"),
+            };
+            let source_info = SourceInfo {
+                url: ServoUrl::parse(args.url.str()).expect("Failed to parse url"),
+                external: true,  // TODO
+                worker_id: None, // TODO
+                content: Some(args.text.to_string()),
+                content_type: None, // TODO
+                spidermonkey_id: args.spidermonkeyId,
+            };
+            devtools_chan
+                .send(ScriptToDevtoolsControlMsg::CreateSourceActor(
+                    pipeline_id,
+                    source_info,
+                ))
+                .expect("Failed to send to devtools server");
+        }
+    }
+}

components/script/dom/dedicatedworkerglobalscope.rs

@@ -9,7 +9,7 @@ use std::thread::{self, JoinHandle};
 use base::id::{BrowsingContextId, PipelineId, WebViewId};
 use constellation_traits::{WorkerGlobalScopeInit, WorkerScriptLoadOrigin};
 use crossbeam_channel::{Receiver, Sender, unbounded};
-use devtools_traits::{DevtoolScriptControlMsg, ScriptToDevtoolsControlMsg, SourceInfo};
+use devtools_traits::DevtoolScriptControlMsg;
 use dom_struct::dom_struct;
 use headers::{HeaderMapExt, ReferrerPolicy as ReferrerPolicyHeader};
 use ipc_channel::ipc::IpcReceiver;
@@ -513,20 +513,6 @@ impl DedicatedWorkerGlobalScope {
                 ));
                 global_scope.set_https_state(metadata.https_state);
                 let source = String::from_utf8_lossy(&bytes);
-                if let Some(chan) = global_scope.devtools_chan() {
-                    let pipeline_id = global_scope.pipeline_id();
-                    let source_info = SourceInfo {
-                        url: metadata.final_url,
-                        external: true, // Worker scripts are always external.
-                        worker_id: Some(global.upcast::<WorkerGlobalScope>().get_worker_id()),
-                        content: Some(source.to_string()),
-                        content_type: metadata.content_type.map(|c_type| c_type.0.to_string()),
-                    };
-                    let _ = chan.send(ScriptToDevtoolsControlMsg::CreateSourceActor(
-                        pipeline_id,
-                        source_info,
-                    ));
-                }
 
                 unsafe {
                     // Handle interrupt requests

components/script/dom/htmlscriptelement.rs

@@ -1091,40 +1091,6 @@ impl HTMLScriptElement {
             Ok(script) => script,
         };
 
-        if let Some(chan) = self.global().devtools_chan() {
-            let pipeline_id = self.global().pipeline_id();
-
-            let (url, content, content_type, is_external) = if script.external {
-                let content = match &script.code {
-                    SourceCode::Text(text) => text.to_string(),
-                    SourceCode::Compiled(compiled) => compiled.original_text.to_string(),
-                };
-
-                // content_type: https://html.spec.whatwg.org/multipage/#scriptingLanguages
-                (script.url.clone(), Some(content), "text/javascript", true)
-            } else {
-                // TODO: if needed, fetch the page again, in the same way as in the original request.
-                // Fetch it from cache, even if the original request was non-idempotent (e.g. POST).
-                // If we can’t fetch it from cache, we should probably give up, because with a real
-                // fetch, the server could return a different response.
-
-                // TODO: handle cases where Content-Type is not text/html.
-                (doc.url(), None, "text/html", false)
-            };
-
-            let source_info = SourceInfo {
-                url,
-                external: is_external,
-                worker_id: None,
-                content,
-                content_type: Some(content_type.to_string()),
-            };
-            let _ = chan.send(ScriptToDevtoolsControlMsg::CreateSourceActor(
-                pipeline_id,
-                source_info,
-            ));
-        }
-
         if script.type_ == ScriptType::Classic {
             unminify_js(&mut script);
             self.substitute_with_local_script(&mut script);

components/script/script_thread.rs

@@ -3430,8 +3430,9 @@ impl ScriptThread {
             incomplete.load_data.inherited_secure_context,
             incomplete.theme,
         );
+        // TODO: call this for workers too
         self.debugger_global
-            .execute_with_global(can_gc, window.upcast());
+            .execute_new_global(can_gc, window.upcast(), incomplete.pipeline_id);
 
         let _realm = enter_realm(&*window);