Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Replace NetworkEventUpdateMsg with ResourcesUpdatedArray (#37384)

Browse source 
*Replaces NetworkEventUpdateMsg with ResourcesUpdatedArray in
HttpResponse case of handle_network_event *
- Adds ResourcesUpdatedArray and UpdateEntry structs in
`devtools/network_handler.rs` to hold an array of updates
(requestHeaders, responseCookies). Updates handle_network_event to use
BrowsingContextActor::resource_available for sending
"resources-updated-array").
- Adds browsing_context_actor_name parameter to handle_network_event to
resolve borrow checker issues and enable BrowsingContextActor lookup.
- Ensures borrow safety by scoping mutable actor access.

Testing: *Does not require test*
Fixes: part of https://github.com/servo/servo/issues/33556

---------

Signed-off-by: Uthman Yahaya Baba <uthmanyahayababa@gmail.com>
This commit is contained in:
Usman Yahaya Baba 2025-06-11 23:07:57 +01:00 • committed by GitHub
parent ea5a20ab8d
commit 8e1cf31db3
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 64 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

157
components/devtools/network_handler.rs
View file

@ -10,27 +10,19 @@ use serde::Serialize;
use crate::actor::ActorRegistry; use crate::actor::ActorRegistry;
use crate::actors::browsing_context::BrowsingContextActor; use crate::actors::browsing_context::BrowsingContextActor;
use crate::actors::network_event::{NetworkEventActor, ResponseStartMsg}; use crate::actors::network_event::NetworkEventActor;
use crate::protocol::JsonPacketStream;
use crate::resource::ResourceAvailable; use crate::resource::ResourceAvailable;
#[derive(Serialize)] #[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase")] struct ResourcesUpdatedArray {
struct NetworkEventUpdateMsg { updates: Vec<UpdateEntry>,
from: String,
#[serde(rename = "type")]
type_: String,
update_type: String,
} }
#[derive(Serialize)] #[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase")] struct UpdateEntry {
struct ResponseStartUpdateMsg { #[serde(rename = "updateType")]
from: String,
#[serde(rename = "type")]
type_: String,
update_type: String, update_type: String,
response: ResponseStartMsg, data: serde_json::Value,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -79,88 +71,63 @@ pub(crate) fn handle_network_event(
} }
}, },
NetworkEvent::HttpResponse(httpresponse) => { NetworkEvent::HttpResponse(httpresponse) => {
// Store the response information in the actor // Scope mutable borrow
let actor = actors.find_mut::<NetworkEventActor>(&netevent_actor_name); let resource = {
actor.add_response(httpresponse); let actor = actors.find_mut::<NetworkEventActor>(&netevent_actor_name);
// Store the response information in the actor
let msg = NetworkEventUpdateMsg { actor.add_response(httpresponse);
from: netevent_actor_name.clone(), ResourcesUpdatedArray {
type_: "networkEventUpdate".to_owned(), updates: vec![
update_type: "requestHeaders".to_owned(), UpdateEntry {
}; update_type: "requestHeaders".to_owned(),
for stream in &mut connections { data: serde_json::to_value(actor.request_headers()).unwrap(),
let _ = stream.write_merged_json_packet(&msg, &actor.request_headers()); },
} UpdateEntry {
update_type: "requestCookies".to_owned(),
let msg = NetworkEventUpdateMsg { data: serde_json::to_value(actor.request_cookies()).unwrap(),
from: netevent_actor_name.clone(), },
type_: "networkEventUpdate".to_owned(), UpdateEntry {
update_type: "requestCookies".to_owned(), update_type: "responseStart".to_owned(),
}; data: serde_json::to_value(actor.response_start()).unwrap(),
for stream in &mut connections { },
let _ = stream.write_merged_json_packet(&msg, &actor.request_cookies()); UpdateEntry {
} update_type: "eventTimings".to_owned(),
data: serde_json::to_value(EventTimingsUpdateMsg {
// Send a networkEventUpdate (responseStart) to the client total_time: actor.total_time().as_millis() as u64,
let msg = ResponseStartUpdateMsg { })
from: netevent_actor_name.clone(), .unwrap(),
type_: "networkEventUpdate".to_owned(), },
update_type: "responseStart".to_owned(), UpdateEntry {
response: actor.response_start(), update_type: "securityInfo".to_owned(),
data: serde_json::to_value(SecurityInfoUpdateMsg {
state: "insecure".to_owned(),
})
.unwrap(),
},
UpdateEntry {
update_type: "responseContent".to_owned(),
data: serde_json::to_value(actor.response_content()).unwrap(),
},
UpdateEntry {
update_type: "responseCookies".to_owned(),
data: serde_json::to_value(actor.response_cookies()).unwrap(),
},
UpdateEntry {
update_type: "responseHeaders".to_owned(),
data: serde_json::to_value(actor.response_headers()).unwrap(),
},
],
}
}; };
let browsing_context_actor =
actors.find::<BrowsingContextActor>(&browsing_context_actor_name);
for stream in &mut connections { for stream in &mut connections {
let _ = stream.write_json_packet(&msg); browsing_context_actor.resource_available(
} resource.clone(),
let msg = NetworkEventUpdateMsg { "resources-updated".to_string(),
from: netevent_actor_name.clone(), stream,
type_: "networkEventUpdate".to_owned(), );
update_type: "eventTimings".to_owned(),
};
let extra = EventTimingsUpdateMsg {
total_time: actor.total_time().as_millis() as u64,
};
for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &extra);
}
let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(),
update_type: "securityInfo".to_owned(),
};
let extra = SecurityInfoUpdateMsg {
state: "insecure".to_owned(),
};
for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &extra);
}
let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(),
update_type: "responseContent".to_owned(),
};
for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &actor.response_content());
}
let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(),
update_type: "responseCookies".to_owned(),
};
for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &actor.response_cookies());
}
let msg = NetworkEventUpdateMsg {
from: netevent_actor_name,
type_: "networkEventUpdate".to_owned(),
update_type: "responseHeaders".to_owned(),
};
for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &actor.response_headers());
} }
}, },
} }

2
components/devtools/protocol.rs
View file

@ -30,6 +30,8 @@ pub struct Method {
pub trait JsonPacketStream { pub trait JsonPacketStream {
fn write_json_packet<T: Serialize>(&mut self, obj: &T) -> Result<(), Box<dyn Error>>; fn write_json_packet<T: Serialize>(&mut self, obj: &T) -> Result<(), Box<dyn Error>>;
#[allow(dead_code)]
fn write_merged_json_packet<T: Serialize, U: Serialize>( fn write_merged_json_packet<T: Serialize, U: Serialize>(
&mut self, &mut self,
base: &T, base: &T,