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

DevTools: Replace camel case variable names (#32726)

Browse source 
* refactor: rename to snake case

* refactor: more renaming

* chore: format

* chore: clean
This commit is contained in:
eri 2024-07-08 13:18:35 +02:00 • committed by GitHub
parent b243457ccc
commit 2888193cfe
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
22 changed files with 363 additions and 323 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/devtools/actors/browsing_context.rs
View file

@ -194,7 +194,7 @@ impl BrowsingContextActor {
let inspector = InspectorActor { let inspector = InspectorActor {
name: actors.new_name("inspector"), name: actors.new_name("inspector"),
walker: RefCell::new(None), walker: RefCell::new(None),
pageStyle: RefCell::new(None), page_style: RefCell::new(None),
highlighter: RefCell::new(None), highlighter: RefCell::new(None),
script_chan: script_sender.clone(), script_chan: script_sender.clone(),
browsing_context: name.clone(), browsing_context: name.clone(),

86
components/devtools/actors/console.rs
View file

@ -49,10 +49,11 @@ impl EncodableConsoleMessage for CachedConsoleMessage {
struct StartedListenersTraits; struct StartedListenersTraits;
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct StartedListenersReply { struct StartedListenersReply {
from: String, from: String,
nativeConsoleAPI: bool, native_console_api: bool,
startedListeners: Vec<String>, started_listeners: Vec<String>,
traits: StartedListenersTraits, traits: StartedListenersTraits,
} }
@ -63,46 +64,53 @@ struct GetCachedMessagesReply {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct StopListenersReply { struct StopListenersReply {
from: String, from: String,
stoppedListeners: Vec<String>, stopped_listeners: Vec<String>,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct AutocompleteReply { struct AutocompleteReply {
from: String, from: String,
matches: Vec<String>, matches: Vec<String>,
matchProp: String, match_prop: String,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct EvaluateJSReply { struct EvaluateJSReply {
from: String, from: String,
input: String, input: String,
result: Value, result: Value,
timestamp: u64, timestamp: u64,
exception: Value, exception: Value,
exceptionMessage: Value, exception_message: Value,
helperResult: Value, helper_result: Value,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct EvaluateJSEvent { struct EvaluateJSEvent {
from: String, from: String,
r#type: String, #[serde(rename = "type")]
type_: String,
input: String, input: String,
result: Value, result: Value,
timestamp: u64, timestamp: u64,
resultID: String, #[serde(rename = "resultID")]
result_id: String,
exception: Value, exception: Value,
exceptionMessage: Value, exception_message: Value,
helperResult: Value, helper_result: Value,
} }
#[derive(Serialize)] #[derive(Serialize)]
struct EvaluateJSAsyncReply { struct EvaluateJSAsyncReply {
from: String, from: String,
resultID: String, #[serde(rename = "resultID")]
result_id: String,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -162,7 +170,7 @@ impl ConsoleActor {
} }
} }
fn evaluateJS( fn evaluate_js(
&self, &self,
registry: &ActorRegistry, registry: &ActorRegistry,
msg: &Map<String, Value>, msg: &Map<String, Value>,
@ -240,8 +248,8 @@ impl ConsoleActor {
result, result,
timestamp: 0, timestamp: 0,
exception: Value::Null, exception: Value::Null,
exceptionMessage: Value::Null, exception_message: Value::Null,
helperResult: Value::Null, helper_result: Value::Null,
}; };
std::result::Result::Ok(reply) std::result::Result::Ok(reply)
} }
@ -261,7 +269,7 @@ impl ConsoleActor {
let msg = PageErrorMsg { let msg = PageErrorMsg {
from: self.name(), from: self.name(),
type_: "pageError".to_owned(), type_: "pageError".to_owned(),
pageError: page_error, page_error,
}; };
self.streams_mut(registry, |stream| { self.streams_mut(registry, |stream| {
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
@ -275,7 +283,7 @@ impl ConsoleActor {
id: UniqueId, id: UniqueId,
registry: &ActorRegistry, registry: &ActorRegistry,
) { ) {
let level = match console_message.logLevel { let level = match console_message.log_level {
LogLevel::Debug => "debug", LogLevel::Debug => "debug",
LogLevel::Info => "info", LogLevel::Info => "info",
LogLevel::Warn => "warn", LogLevel::Warn => "warn",
@ -292,9 +300,9 @@ impl ConsoleActor {
type_: "ConsoleAPI".to_owned(), type_: "ConsoleAPI".to_owned(),
level: level.clone(), level: level.clone(),
filename: console_message.filename.clone(), filename: console_message.filename.clone(),
lineNumber: console_message.lineNumber as u32, line_number: console_message.line_number as u32,
functionName: "".to_string(), //TODO function_name: "".to_string(), //TODO
timeStamp: SystemTime::now() time_stamp: SystemTime::now()
.duration_since(UNIX_EPOCH) .duration_since(UNIX_EPOCH)
.unwrap_or_default() .unwrap_or_default()
.as_nanos() as u64, .as_nanos() as u64,
@ -307,14 +315,14 @@ impl ConsoleActor {
type_: "consoleAPICall".to_owned(), type_: "consoleAPICall".to_owned(),
message: ConsoleMsg { message: ConsoleMsg {
level, level,
timeStamp: SystemTime::now() timestamp: SystemTime::now()
.duration_since(UNIX_EPOCH) .duration_since(UNIX_EPOCH)
.unwrap_or_default() .unwrap_or_default()
.as_nanos() as u64, .as_nanos() as u64,
arguments: vec![console_message.message], arguments: vec![console_message.message],
filename: console_message.filename, filename: console_message.filename,
lineNumber: console_message.lineNumber, line_number: console_message.line_number,
columnNumber: console_message.columnNumber, column_number: console_message.column_number,
}, },
}; };
self.streams_mut(registry, |stream| { self.streams_mut(registry, |stream| {
@ -404,8 +412,8 @@ impl Actor for ConsoleActor {
let listeners = msg.get("listeners").unwrap().as_array().unwrap().to_owned(); let listeners = msg.get("listeners").unwrap().as_array().unwrap().to_owned();
let msg = StartedListenersReply { let msg = StartedListenersReply {
from: self.name(), from: self.name(),
nativeConsoleAPI: true, native_console_api: true,
startedListeners: listeners started_listeners: listeners
.into_iter() .into_iter()
.map(|s| s.as_str().unwrap().to_owned()) .map(|s| s.as_str().unwrap().to_owned())
.collect(), .collect(),
@ -419,7 +427,7 @@ impl Actor for ConsoleActor {
//TODO: actually implement listener filters that support starting/stopping //TODO: actually implement listener filters that support starting/stopping
let msg = StopListenersReply { let msg = StopListenersReply {
from: self.name(), from: self.name(),
stoppedListeners: msg stopped_listeners: msg
.get("listeners") .get("listeners")
.unwrap() .unwrap()
.as_array() .as_array()
@ -438,23 +446,23 @@ impl Actor for ConsoleActor {
let msg = AutocompleteReply { let msg = AutocompleteReply {
from: self.name(), from: self.name(),
matches: vec![], matches: vec![],
matchProp: "".to_owned(), match_prop: "".to_owned(),
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed
}, },
"evaluateJS" => { "evaluateJS" => {
let msg = self.evaluateJS(registry, msg); let msg = self.evaluate_js(registry, msg);
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed
}, },
"evaluateJSAsync" => { "evaluateJSAsync" => {
let resultID = Uuid::new_v4().to_string(); let result_id = Uuid::new_v4().to_string();
let early_reply = EvaluateJSAsyncReply { let early_reply = EvaluateJSAsyncReply {
from: self.name(), from: self.name(),
resultID: resultID.clone(), result_id: result_id.clone(),
}; };
// Emit an eager reply so that the client starts listening // Emit an eager reply so that the client starts listening
// for an async event with the resultID // for an async event with the resultID
@ -468,17 +476,17 @@ impl Actor for ConsoleActor {
return Ok(ActorMessageStatus::Processed); return Ok(ActorMessageStatus::Processed);
} }
let reply = self.evaluateJS(registry, msg).unwrap(); let reply = self.evaluate_js(registry, msg).unwrap();
let msg = EvaluateJSEvent { let msg = EvaluateJSEvent {
from: self.name(), from: self.name(),
r#type: "evaluationResult".to_owned(), type_: "evaluationResult".to_owned(),
input: reply.input, input: reply.input,
result: reply.result, result: reply.result,
timestamp: reply.timestamp, timestamp: reply.timestamp,
resultID, result_id,
exception: reply.exception, exception: reply.exception,
exceptionMessage: reply.exceptionMessage, exception_message: reply.exception_message,
helperResult: reply.helperResult, helper_result: reply.helper_result,
}; };
// Send the data from evaluateJS along with a resultID // Send the data from evaluateJS along with a resultID
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
@ -508,19 +516,21 @@ struct ConsoleAPICall {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct ConsoleMsg { struct ConsoleMsg {
level: String, level: String,
timeStamp: u64, timestamp: u64,
arguments: Vec<String>, arguments: Vec<String>,
filename: String, filename: String,
lineNumber: usize, line_number: usize,
columnNumber: usize, column_number: usize,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct PageErrorMsg { struct PageErrorMsg {
from: String, from: String,
#[serde(rename = "type")] #[serde(rename = "type")]
type_: String, type_: String,
pageError: PageError, page_error: PageError,
} }

7
components/devtools/actors/device.rs
View file

@ -20,6 +20,7 @@ struct GetDescriptionReply {
// This is only a minimal subset of the properties exposed/expected by Firefox // This is only a minimal subset of the properties exposed/expected by Firefox
// (see https://searchfox.org/mozilla-central/source/devtools/shared/system.js#45) // (see https://searchfox.org/mozilla-central/source/devtools/shared/system.js#45)
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct SystemInfo { struct SystemInfo {
apptype: String, apptype: String,
// Display version // Display version
@ -30,7 +31,7 @@ struct SystemInfo {
// Firefox major.minor version number, use for compatibility checks // Firefox major.minor version number, use for compatibility checks
platformversion: String, platformversion: String,
// Display name // Display name
brandName: String, brand_name: String,
} }
include!(concat!(env!("OUT_DIR"), "/build_id.rs")); include!(concat!(env!("OUT_DIR"), "/build_id.rs"));
@ -60,7 +61,7 @@ impl Actor for DeviceActor {
version: env!("CARGO_PKG_VERSION").to_string(), version: env!("CARGO_PKG_VERSION").to_string(),
appbuildid: BUILD_ID.to_string(), appbuildid: BUILD_ID.to_string(),
platformversion: "125.0".to_string(), platformversion: "125.0".to_string(),
brandName: "Servo".to_string(), brand_name: "Servo".to_string(),
}, },
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
@ -80,7 +81,7 @@ impl DeviceActor {
pub fn description() -> ActorDescription { pub fn description() -> ActorDescription {
ActorDescription { ActorDescription {
category: "actor", category: "actor",
typeName: "device", type_name: "device",
methods: vec![Method { methods: vec![Method {
name: "getDescription", name: "getDescription",
request: Value::Null, request: Value::Null,

3
components/devtools/actors/framerate.rs
View file

@ -18,7 +18,6 @@ pub struct FramerateActor {
name: String, name: String,
pipeline: PipelineId, pipeline: PipelineId,
script_sender: IpcSender<DevtoolScriptControlMsg>, script_sender: IpcSender<DevtoolScriptControlMsg>,
is_recording: bool, is_recording: bool,
ticks: Vec<HighResolutionStamp>, ticks: Vec<HighResolutionStamp>,
} }
@ -41,7 +40,7 @@ impl Actor for FramerateActor {
} }
impl FramerateActor { impl FramerateActor {
/// return name of actor /// Return name of actor
pub fn create( pub fn create(
registry: &ActorRegistry, registry: &ActorRegistry,
pipeline_id: PipelineId, pipeline_id: PipelineId,

66
components/devtools/actors/inspector.rs
View file

@ -4,6 +4,8 @@
//! Liberally derived from the [Firefox JS implementation](http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/inspector.js). //! Liberally derived from the [Firefox JS implementation](http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/inspector.js).
#![allow(non_snake_case)] // NOTE: To be removed on the inspector specific pr
use std::cell::RefCell; use std::cell::RefCell;
use std::net::TcpStream; use std::net::TcpStream;
@ -24,7 +26,7 @@ use crate::StreamId;
pub struct InspectorActor { pub struct InspectorActor {
pub name: String, pub name: String,
pub walker: RefCell<Option<String>>, pub walker: RefCell<Option<String>>,
pub pageStyle: RefCell<Option<String>>, pub page_style: RefCell<Option<String>>,
pub highlighter: RefCell<Option<String>>, pub highlighter: RefCell<Option<String>>,
pub script_chan: IpcSender<DevtoolScriptControlMsg>, pub script_chan: IpcSender<DevtoolScriptControlMsg>,
pub browsing_context: String, pub browsing_context: String,
@ -203,32 +205,32 @@ impl NodeInfoToProtocol for NodeInfo {
script_chan: IpcSender<DevtoolScriptControlMsg>, script_chan: IpcSender<DevtoolScriptControlMsg>,
pipeline: PipelineId, pipeline: PipelineId,
) -> NodeActorMsg { ) -> NodeActorMsg {
let actor_name = if !actors.script_actor_registered(self.uniqueId.clone()) { let actor_name = if !actors.script_actor_registered(self.unique_id.clone()) {
let name = actors.new_name("node"); let name = actors.new_name("node");
let node_actor = NodeActor { let node_actor = NodeActor {
name: name.clone(), name: name.clone(),
script_chan, script_chan,
pipeline, pipeline,
}; };
actors.register_script_actor(self.uniqueId, name.clone()); actors.register_script_actor(self.unique_id, name.clone());
actors.register_later(Box::new(node_actor)); actors.register_later(Box::new(node_actor));
name name
} else { } else {
actors.script_to_actor(self.uniqueId) actors.script_to_actor(self.unique_id)
}; };
NodeActorMsg { NodeActorMsg {
actor: actor_name, actor: actor_name,
baseURI: self.baseURI, baseURI: self.base_uri,
parent: actors.script_to_actor(self.parent.clone()), parent: actors.script_to_actor(self.parent.clone()),
nodeType: self.nodeType, nodeType: self.node_type,
namespaceURI: self.namespaceURI, namespaceURI: self.namespace_uri,
nodeName: self.nodeName, nodeName: self.node_name,
numChildren: self.numChildren, numChildren: self.num_children,
name: self.name, name: self.name,
publicId: self.publicId, publicId: self.public_id,
systemId: self.systemId, systemId: self.system_id,
attrs: self attrs: self
.attrs .attrs
@ -246,10 +248,10 @@ impl NodeInfoToProtocol for NodeInfo {
hasEventListeners: false, //TODO get this data from script hasEventListeners: false, //TODO get this data from script
isDocumentElement: self.isDocumentElement, isDocumentElement: self.is_document_element,
shortValue: self.shortValue, shortValue: self.short_value,
incompleteValue: self.incompleteValue, incompleteValue: self.incomplete_value,
} }
} }
} }
@ -517,21 +519,21 @@ impl Actor for PageStyleActor {
let ComputedNodeLayout { let ComputedNodeLayout {
display, display,
position, position,
zIndex, z_index: zIndex,
boxSizing, box_sizing: boxSizing,
autoMargins, auto_margins: autoMargins,
marginTop, margin_top: marginTop,
marginRight, margin_right: marginRight,
marginBottom, margin_bottom: marginBottom,
marginLeft, margin_left: marginLeft,
borderTopWidth, border_top_width: borderTopWidth,
borderRightWidth, border_right_width: borderRightWidth,
borderBottomWidth, border_bottom_width: borderBottomWidth,
borderLeftWidth, border_left_width: borderLeftWidth,
paddingTop, padding_top: paddingTop,
paddingRight, padding_right: paddingRight,
paddingBottom, padding_bottom: paddingBottom,
paddingLeft, padding_left: paddingLeft,
width, width,
height, height,
} = rx.recv().unwrap().ok_or(())?; } = rx.recv().unwrap().ok_or(())?;
@ -639,13 +641,13 @@ impl Actor for InspectorActor {
}, },
"getPageStyle" => { "getPageStyle" => {
if self.pageStyle.borrow().is_none() { if self.page_style.borrow().is_none() {
let style = PageStyleActor { let style = PageStyleActor {
name: registry.new_name("pageStyle"), name: registry.new_name("pageStyle"),
script_chan: self.script_chan.clone(), script_chan: self.script_chan.clone(),
pipeline, pipeline,
}; };
let mut pageStyle = self.pageStyle.borrow_mut(); let mut pageStyle = self.page_style.borrow_mut();
*pageStyle = Some(style.name()); *pageStyle = Some(style.name());
registry.register_later(Box::new(style)); registry.register_later(Box::new(style));
} }
@ -653,7 +655,7 @@ impl Actor for InspectorActor {
let msg = GetPageStyleReply { let msg = GetPageStyleReply {
from: self.name(), from: self.name(),
pageStyle: PageStyleMsg { pageStyle: PageStyleMsg {
actor: self.pageStyle.borrow().clone().unwrap(), actor: self.page_style.borrow().clone().unwrap(),
}, },
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);

39
components/devtools/actors/memory.rs
View file

@ -11,16 +11,18 @@ use crate::actor::{Actor, ActorMessageStatus, ActorRegistry};
use crate::StreamId; use crate::StreamId;
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TimelineMemoryReply { pub struct TimelineMemoryReply {
jsObjectSize: u64, js_object_size: u64,
jsStringSize: u64, js_string_size: u64,
jsOtherSize: u64, js_other_size: u64,
domSize: u64, dom_size: u64,
styleSize: u64, style_size: u64,
otherSize: u64, other_size: u64,
totalSize: u64, total_size: u64,
jsMilliseconds: f64, js_milliseconds: f64,
nonJSMilliseconds: f64, #[serde(rename = "nonJSMilliseconds")]
non_js_milliseconds: f64,
} }
pub struct MemoryActor { pub struct MemoryActor {
@ -57,17 +59,16 @@ impl MemoryActor {
} }
pub fn measure(&self) -> TimelineMemoryReply { pub fn measure(&self) -> TimelineMemoryReply {
//TODO:
TimelineMemoryReply { TimelineMemoryReply {
jsObjectSize: 1, js_object_size: 1,
jsStringSize: 1, js_string_size: 1,
jsOtherSize: 1, js_other_size: 1,
domSize: 1, dom_size: 1,
styleSize: 1, style_size: 1,
otherSize: 1, other_size: 1,
totalSize: 1, total_size: 1,
jsMilliseconds: 1.1, js_milliseconds: 1.1,
nonJSMilliseconds: 1.1, non_js_milliseconds: 1.1,
} }
} }
} }

162
components/devtools/actors/network_event.rs
View file

@ -24,8 +24,8 @@ struct HttpRequest {
method: Method, method: Method,
headers: HeaderMap, headers: HeaderMap,
body: Option<Vec<u8>>, body: Option<Vec<u8>>,
startedDateTime: SystemTime, started_date_time: SystemTime,
timeStamp: i64, time_stamp: i64,
connect_time: u64, connect_time: u64,
send_time: u64, send_time: u64,
} }
@ -44,13 +44,15 @@ pub struct NetworkEventActor {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct EventActor { pub struct EventActor {
pub actor: String, pub actor: String,
pub url: String, pub url: String,
pub method: String, pub method: String,
pub startedDateTime: String, pub started_date_time: String,
pub timeStamp: i64, pub time_stamp: i64,
pub isXHR: bool, #[serde(rename = "isXHR")]
pub is_xhr: bool,
pub private: bool, pub private: bool,
} }
@ -60,28 +62,31 @@ pub struct ResponseCookiesMsg {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseStartMsg { pub struct ResponseStartMsg {
pub httpVersion: String, pub http_version: String,
pub remoteAddress: String, pub remote_address: String,
pub remotePort: u32, pub remote_port: u32,
pub status: String, pub status: String,
pub statusText: String, pub status_text: String,
pub headersSize: usize, pub headers_size: usize,
pub discardResponseBody: bool, pub discard_response_body: bool,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseContentMsg { pub struct ResponseContentMsg {
pub mimeType: String, pub mime_type: String,
pub contentSize: u32, pub content_size: u32,
pub transferredSize: u32, pub transferred_size: u32,
pub discardResponseBody: bool, pub discard_response_body: bool,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseHeadersMsg { pub struct ResponseHeadersMsg {
pub headers: usize, pub headers: usize,
pub headersSize: usize, pub headers_size: usize,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -90,17 +95,19 @@ pub struct RequestCookiesMsg {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RequestHeadersMsg { pub struct RequestHeadersMsg {
headers: usize, headers: usize,
headersSize: usize, headers_size: usize,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetRequestHeadersReply { struct GetRequestHeadersReply {
from: String, from: String,
headers: Vec<Header>, headers: Vec<Header>,
headerSize: usize, header_size: usize,
rawHeaders: String, raw_headers: String,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -110,25 +117,28 @@ struct Header {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetResponseHeadersReply { struct GetResponseHeadersReply {
from: String, from: String,
headers: Vec<Header>, headers: Vec<Header>,
headerSize: usize, header_size: usize,
rawHeaders: String, raw_headers: String,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetResponseContentReply { struct GetResponseContentReply {
from: String, from: String,
content: Option<Vec<u8>>, content: Option<Vec<u8>>,
contentDiscarded: bool, content_discarded: bool,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetRequestPostDataReply { struct GetRequestPostDataReply {
from: String, from: String,
postData: Option<Vec<u8>>, post_data: Option<Vec<u8>>,
postDataDiscarded: bool, post_data_discarded: bool,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -154,10 +164,11 @@ struct Timings {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetEventTimingsReply { struct GetEventTimingsReply {
from: String, from: String,
timings: Timings, timings: Timings,
totalTime: u64, total_time: u64,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -166,9 +177,10 @@ struct SecurityInfo {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetSecurityInfoReply { struct GetSecurityInfoReply {
from: String, from: String,
securityInfo: SecurityInfo, security_info: SecurityInfo,
} }
impl Actor for NetworkEventActor { impl Actor for NetworkEventActor {
@ -187,12 +199,12 @@ impl Actor for NetworkEventActor {
Ok(match msg_type { Ok(match msg_type {
"getRequestHeaders" => { "getRequestHeaders" => {
let mut headers = Vec::new(); let mut headers = Vec::new();
let mut rawHeadersString = "".to_owned(); let mut raw_headers_string = "".to_owned();
let mut headersSize = 0; let mut headers_size = 0;
for (name, value) in self.request.headers.iter() { for (name, value) in self.request.headers.iter() {
let value = &value.to_str().unwrap().to_string(); let value = &value.to_str().unwrap().to_string();
rawHeadersString = rawHeadersString + name.as_str() + ":" + value + "\r\n"; raw_headers_string = raw_headers_string + name.as_str() + ":" + value + "\r\n";
headersSize += name.as_str().len() + value.len(); headers_size += name.as_str().len() + value.len();
headers.push(Header { headers.push(Header {
name: name.as_str().to_owned(), name: name.as_str().to_owned(),
value: value.to_owned(), value: value.to_owned(),
@ -201,8 +213,8 @@ impl Actor for NetworkEventActor {
let msg = GetRequestHeadersReply { let msg = GetRequestHeadersReply {
from: self.name(), from: self.name(),
headers, headers,
headerSize: headersSize, header_size: headers_size,
rawHeaders: rawHeadersString, raw_headers: raw_headers_string,
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed
@ -226,8 +238,8 @@ impl Actor for NetworkEventActor {
"getRequestPostData" => { "getRequestPostData" => {
let msg = GetRequestPostDataReply { let msg = GetRequestPostDataReply {
from: self.name(), from: self.name(),
postData: self.request.body.clone(), post_data: self.request.body.clone(),
postDataDiscarded: false, post_data_discarded: false,
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed
@ -235,24 +247,24 @@ impl Actor for NetworkEventActor {
"getResponseHeaders" => { "getResponseHeaders" => {
if let Some(ref response_headers) = self.response.headers { if let Some(ref response_headers) = self.response.headers {
let mut headers = vec![]; let mut headers = vec![];
let mut rawHeadersString = "".to_owned(); let mut raw_headers_string = "".to_owned();
let mut headersSize = 0; let mut headers_size = 0;
for (name, value) in response_headers.iter() { for (name, value) in response_headers.iter() {
headers.push(Header { headers.push(Header {
name: name.as_str().to_owned(), name: name.as_str().to_owned(),
value: value.to_str().unwrap().to_owned(), value: value.to_str().unwrap().to_owned(),
}); });
headersSize += name.as_str().len() + value.len(); headers_size += name.as_str().len() + value.len();
rawHeadersString.push_str(name.as_str()); raw_headers_string.push_str(name.as_str());
rawHeadersString.push(':'); raw_headers_string.push(':');
rawHeadersString.push_str(value.to_str().unwrap()); raw_headers_string.push_str(value.to_str().unwrap());
rawHeadersString.push_str("\r\n"); raw_headers_string.push_str("\r\n");
} }
let msg = GetResponseHeadersReply { let msg = GetResponseHeadersReply {
from: self.name(), from: self.name(),
headers, headers,
headerSize: headersSize, header_size: headers_size,
rawHeaders: rawHeadersString, raw_headers: raw_headers_string,
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
} }
@ -278,14 +290,14 @@ impl Actor for NetworkEventActor {
let msg = GetResponseContentReply { let msg = GetResponseContentReply {
from: self.name(), from: self.name(),
content: self.response.body.clone(), content: self.response.body.clone(),
contentDiscarded: self.response.body.is_none(), content_discarded: self.response.body.is_none(),
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed
}, },
"getEventTimings" => { "getEventTimings" => {
// TODO: This is a fake timings msg // TODO: This is a fake timings msg
let timingsObj = Timings { let timings_obj = Timings {
blocked: 0, blocked: 0,
dns: 0, dns: 0,
connect: self.request.connect_time, connect: self.request.connect_time,
@ -293,12 +305,12 @@ impl Actor for NetworkEventActor {
wait: 0, wait: 0,
receive: 0, receive: 0,
}; };
let total = timingsObj.connect + timingsObj.send; let total = timings_obj.connect + timings_obj.send;
// TODO: Send the correct values for all these fields. // TODO: Send the correct values for all these fields.
let msg = GetEventTimingsReply { let msg = GetEventTimingsReply {
from: self.name(), from: self.name(),
timings: timingsObj, timings: timings_obj,
totalTime: total, total_time: total,
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed
@ -307,7 +319,7 @@ impl Actor for NetworkEventActor {
// TODO: Send the correct values for securityInfo. // TODO: Send the correct values for securityInfo.
let msg = GetSecurityInfoReply { let msg = GetSecurityInfoReply {
from: self.name(), from: self.name(),
securityInfo: SecurityInfo { security_info: SecurityInfo {
state: "insecure".to_owned(), state: "insecure".to_owned(),
}, },
}; };
@ -328,8 +340,8 @@ impl NetworkEventActor {
method: Method::GET, method: Method::GET,
headers: HeaderMap::new(), headers: HeaderMap::new(),
body: None, body: None,
startedDateTime: SystemTime::now(), started_date_time: SystemTime::now(),
timeStamp: SystemTime::now() time_stamp: SystemTime::now()
.duration_since(UNIX_EPOCH) .duration_since(UNIX_EPOCH)
.unwrap_or_default() .unwrap_or_default()
.as_secs() as i64, .as_secs() as i64,
@ -351,8 +363,8 @@ impl NetworkEventActor {
self.request.method = request.method.clone(); self.request.method = request.method.clone();
self.request.headers = request.headers.clone(); self.request.headers = request.headers.clone();
self.request.body = request.body; self.request.body = request.body;
self.request.startedDateTime = request.startedDateTime; self.request.started_date_time = request.started_date_time;
self.request.timeStamp = request.timeStamp; self.request.time_stamp = request.time_stamp;
self.request.connect_time = request.connect_time; self.request.connect_time = request.connect_time;
self.request.send_time = request.send_time; self.request.send_time = request.send_time;
self.is_xhr = request.is_xhr; self.is_xhr = request.is_xhr;
@ -372,31 +384,31 @@ impl NetworkEventActor {
let started_datetime_rfc3339 = match Local.timestamp_millis_opt( let started_datetime_rfc3339 = match Local.timestamp_millis_opt(
self.request self.request
.startedDateTime .started_date_time
.duration_since(UNIX_EPOCH) .duration_since(UNIX_EPOCH)
.unwrap_or_default() .unwrap_or_default()
.as_millis() as i64, .as_millis() as i64,
) { ) {
LocalResult::None => "".to_owned(), LocalResult::None => "".to_owned(),
LocalResult::Single(dateTime) => dateTime.to_rfc3339().to_string(), LocalResult::Single(date_time) => date_time.to_rfc3339().to_string(),
LocalResult::Ambiguous(dateTime, _) => dateTime.to_rfc3339().to_string(), LocalResult::Ambiguous(date_time, _) => date_time.to_rfc3339().to_string(),
}; };
EventActor { EventActor {
actor: self.name(), actor: self.name(),
url: self.request.url.clone(), url: self.request.url.clone(),
method: format!("{}", self.request.method), method: format!("{}", self.request.method),
startedDateTime: started_datetime_rfc3339, started_date_time: started_datetime_rfc3339,
timeStamp: self.request.timeStamp, time_stamp: self.request.time_stamp,
isXHR: self.is_xhr, is_xhr: self.is_xhr,
private: false, private: false,
} }
} }
pub fn response_start(&self) -> ResponseStartMsg { pub fn response_start(&self) -> ResponseStartMsg {
// TODO: Send the correct values for all these fields. // TODO: Send the correct values for all these fields.
let hSizeOption = self.response.headers.as_ref().map(|headers| headers.len()); let h_size_option = self.response.headers.as_ref().map(|headers| headers.len());
let hSize = hSizeOption.unwrap_or(0); let h_size = h_size_option.unwrap_or(0);
let (status_code, status_message) = self let (status_code, status_message) = self
.response .response
.status .status
@ -406,30 +418,30 @@ impl NetworkEventActor {
}); });
// TODO: Send the correct values for remoteAddress and remotePort and http_version. // TODO: Send the correct values for remoteAddress and remotePort and http_version.
ResponseStartMsg { ResponseStartMsg {
httpVersion: "HTTP/1.1".to_owned(), http_version: "HTTP/1.1".to_owned(),
remoteAddress: "63.245.217.43".to_owned(), remote_address: "63.245.217.43".to_owned(),
remotePort: 443, remote_port: 443,
status: status_code.to_string(), status: status_code.to_string(),
statusText: status_message, status_text: status_message,
headersSize: hSize, headers_size: h_size,
discardResponseBody: false, discard_response_body: false,
} }
} }
pub fn response_content(&self) -> ResponseContentMsg { pub fn response_content(&self) -> ResponseContentMsg {
let mut mString = "".to_owned(); let mut m_string = "".to_owned();
if let Some(ref headers) = self.response.headers { if let Some(ref headers) = self.response.headers {
mString = match headers.typed_get::<ContentType>() { m_string = match headers.typed_get::<ContentType>() {
Some(ct) => ct.to_string(), Some(ct) => ct.to_string(),
_ => "".to_owned(), _ => "".to_owned(),
}; };
} }
// TODO: Set correct values when response's body is sent to the devtools in http_loader. // TODO: Set correct values when response's body is sent to the devtools in http_loader.
ResponseContentMsg { ResponseContentMsg {
mimeType: mString, mime_type: m_string,
contentSize: 0, content_size: 0,
transferredSize: 0, transferred_size: 0,
discardResponseBody: true, discard_response_body: true,
} }
} }
@ -457,7 +469,7 @@ impl NetworkEventActor {
} }
ResponseHeadersMsg { ResponseHeadersMsg {
headers: headers_size, headers: headers_size,
headersSize: headers_byte_count, headers_size: headers_byte_count,
} }
} }
@ -467,7 +479,7 @@ impl NetworkEventActor {
}); });
RequestHeadersMsg { RequestHeadersMsg {
headers: self.request.headers.len(), headers: self.request.headers.len(),
headersSize: size, headers_size: size,
} }
} }

24
components/devtools/actors/performance.rs
View file

@ -16,12 +16,14 @@ pub struct PerformanceActor {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct PerformanceFeatures { struct PerformanceFeatures {
withMarkers: bool, with_markers: bool,
withMemory: bool, with_memory: bool,
withTicks: bool, with_ticks: bool,
withAllocations: bool, with_allocations: bool,
withJITOptimizations: bool, #[serde(rename = "withJITOptimizations")]
with_jitoptimizations: bool,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -69,11 +71,11 @@ impl Actor for PerformanceActor {
from: self.name(), from: self.name(),
traits: PerformanceTraits { traits: PerformanceTraits {
features: PerformanceFeatures { features: PerformanceFeatures {
withMarkers: true, with_markers: true,
withMemory: true, with_memory: true,
withTicks: true, with_ticks: true,
withAllocations: true, with_allocations: true,
withJITOptimizations: true, with_jitoptimizations: true,
}, },
}, },
}; };
@ -104,7 +106,7 @@ impl PerformanceActor {
pub fn description() -> ActorDescription { pub fn description() -> ActorDescription {
ActorDescription { ActorDescription {
category: "actor", category: "actor",
typeName: "performance", type_name: "performance",
methods: vec![Method { methods: vec![Method {
name: "canCurrentlyRecord", name: "canCurrentlyRecord",
request: Value::Object( request: Value::Object(

5
components/devtools/actors/stylesheets.rs
View file

@ -12,9 +12,10 @@ use crate::protocol::JsonPacketStream;
use crate::StreamId; use crate::StreamId;
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct GetStyleSheetsReply { struct GetStyleSheetsReply {
from: String, from: String,
styleSheets: Vec<u32>, // TODO: real JSON structure. style_sheets: Vec<u32>, // TODO: real JSON structure.
} }
pub struct StyleSheetsActor { pub struct StyleSheetsActor {
@ -37,7 +38,7 @@ impl Actor for StyleSheetsActor {
"getStyleSheets" => { "getStyleSheets" => {
let msg = GetStyleSheetsReply { let msg = GetStyleSheetsReply {
from: self.name(), from: self.name(),
styleSheets: vec![], style_sheets: vec![],
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed

13
components/devtools/actors/thread.rs
View file

@ -12,6 +12,7 @@ use crate::protocol::JsonPacketStream;
use crate::StreamId; use crate::StreamId;
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct ThreadAttached { struct ThreadAttached {
from: String, from: String,
#[serde(rename = "type")] #[serde(rename = "type")]
@ -19,9 +20,9 @@ struct ThreadAttached {
actor: String, actor: String,
frame: u32, frame: u32,
error: u32, error: u32,
recordingEndpoint: u32, recording_endpoint: u32,
executionPoint: u32, execution_point: u32,
poppedFrames: Vec<PoppedFrameMsg>, popped_frames: Vec<PoppedFrameMsg>,
why: WhyMsg, why: WhyMsg,
} }
@ -98,9 +99,9 @@ impl Actor for ThreadActor {
actor: registry.new_name("pause"), actor: registry.new_name("pause"),
frame: 0, frame: 0,
error: 0, error: 0,
recordingEndpoint: 0, recording_endpoint: 0,
executionPoint: 0, execution_point: 0,
poppedFrames: vec![], popped_frames: vec![],
why: WhyMsg { why: WhyMsg {
type_: "attached".to_owned(), type_: "attached".to_owned(),
}, },

18
components/devtools/actors/timeline.rs
View file

@ -63,21 +63,23 @@ struct StopReply {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct TimelineMarkerReply { struct TimelineMarkerReply {
name: String, name: String,
start: HighResolutionStamp, start: HighResolutionStamp,
end: HighResolutionStamp, end: HighResolutionStamp,
stack: Option<Vec<()>>, stack: Option<Vec<()>>,
endStack: Option<Vec<()>>, end_stack: Option<Vec<()>>,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct MarkersEmitterReply { struct MarkersEmitterReply {
#[serde(rename = "type")] #[serde(rename = "type")]
type_: String, type_: String,
markers: Vec<TimelineMarkerReply>, markers: Vec<TimelineMarkerReply>,
from: String, from: String,
endTime: HighResolutionStamp, end_time: HighResolutionStamp,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -312,7 +314,7 @@ impl Emitter {
start: HighResolutionStamp::new(self.start_stamp, payload.start_time), start: HighResolutionStamp::new(self.start_stamp, payload.start_time),
end: HighResolutionStamp::new(self.start_stamp, payload.end_time), end: HighResolutionStamp::new(self.start_stamp, payload.end_time),
stack: payload.start_stack, stack: payload.start_stack,
endStack: payload.end_stack, end_stack: payload.end_stack,
} }
} }
@ -322,7 +324,7 @@ impl Emitter {
type_: "markers".to_owned(), type_: "markers".to_owned(),
markers, markers,
from: self.from.clone(), from: self.from.clone(),
endTime: HighResolutionStamp::new(self.start_stamp, end_time), end_time: HighResolutionStamp::new(self.start_stamp, end_time),
}; };
self.stream.write_json_packet(&reply)?; self.stream.write_json_packet(&reply)?;
@ -330,25 +332,25 @@ impl Emitter {
let mut lock = self.registry.lock(); let mut lock = self.registry.lock();
let registry = lock.as_mut().unwrap(); let registry = lock.as_mut().unwrap();
let framerate_actor = registry.find_mut::<FramerateActor>(actor_name); let framerate_actor = registry.find_mut::<FramerateActor>(actor_name);
let framerateReply = FramerateEmitterReply { let framerate_reply = FramerateEmitterReply {
type_: "framerate".to_owned(), type_: "framerate".to_owned(),
from: framerate_actor.name(), from: framerate_actor.name(),
delta: HighResolutionStamp::new(self.start_stamp, end_time), delta: HighResolutionStamp::new(self.start_stamp, end_time),
timestamps: framerate_actor.take_pending_ticks(), timestamps: framerate_actor.take_pending_ticks(),
}; };
self.stream.write_json_packet(&framerateReply)?; self.stream.write_json_packet(&framerate_reply)?;
} }
if let Some(ref actor_name) = self.memory_actor { if let Some(ref actor_name) = self.memory_actor {
let registry = self.registry.lock().unwrap(); let registry = self.registry.lock().unwrap();
let memory_actor = registry.find::<MemoryActor>(actor_name); let memory_actor = registry.find::<MemoryActor>(actor_name);
let memoryReply = MemoryEmitterReply { let memory_reply = MemoryEmitterReply {
type_: "memory".to_owned(), type_: "memory".to_owned(),
from: memory_actor.name(), from: memory_actor.name(),
delta: HighResolutionStamp::new(self.start_stamp, end_time), delta: HighResolutionStamp::new(self.start_stamp, end_time),
measurement: memory_actor.measure(), measurement: memory_actor.measure(),
}; };
self.stream.write_json_packet(&memoryReply)?; self.stream.write_json_packet(&memory_reply)?;
} }
Ok(()) Ok(())

23
components/devtools/actors/worker.rs
View file

@ -41,12 +41,12 @@ impl WorkerActor {
pub(crate) fn encodable(&self) -> WorkerMsg { pub(crate) fn encodable(&self) -> WorkerMsg {
WorkerMsg { WorkerMsg {
actor: self.name.clone(), actor: self.name.clone(),
consoleActor: self.console.clone(), console_actor: self.console.clone(),
threadActor: self.thread.clone(), thread_actor: self.thread.clone(),
id: self.id.0.to_string(), id: self.id.0.to_string(),
url: self.url.to_string(), url: self.url.to_string(),
traits: WorkerTraits { traits: WorkerTraits {
isParentInterceptEnabled: false, is_parent_intercept_enabled: false,
}, },
type_: self.type_ as u32, type_: self.type_ as u32,
} }
@ -89,8 +89,8 @@ impl Actor for WorkerActor {
let msg = ConnectReply { let msg = ConnectReply {
from: self.name(), from: self.name(),
type_: "connected".to_owned(), type_: "connected".to_owned(),
threadActor: self.thread.clone(), thread_actor: self.thread.clone(),
consoleActor: self.console.clone(), console_actor: self.console.clone(),
}; };
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed ActorMessageStatus::Processed
@ -136,24 +136,27 @@ struct AttachedReply {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct ConnectReply { struct ConnectReply {
from: String, from: String,
#[serde(rename = "type")] #[serde(rename = "type")]
type_: String, type_: String,
threadActor: String, thread_actor: String,
consoleActor: String, console_actor: String,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct WorkerTraits { struct WorkerTraits {
isParentInterceptEnabled: bool, is_parent_intercept_enabled: bool,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct WorkerMsg { pub(crate) struct WorkerMsg {
actor: String, actor: String,
consoleActor: String, console_actor: String,
threadActor: String, thread_actor: String,
id: String, id: String,
url: String, url: String,
traits: WorkerTraits, traits: WorkerTraits,

39
components/devtools/lib.rs
View file

@ -9,7 +9,6 @@
#![crate_name = "devtools"] #![crate_name = "devtools"]
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![allow(non_snake_case)]
#![deny(unsafe_code)] #![deny(unsafe_code)]
use std::borrow::ToOwned; use std::borrow::ToOwned;
@ -81,24 +80,27 @@ enum UniqueId {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct NetworkEventMsg { struct NetworkEventMsg {
from: String, from: String,
#[serde(rename = "type")] #[serde(rename = "type")]
type_: String, type_: String,
eventActor: EventActor, event_actor: EventActor,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct NetworkEventUpdateMsg { struct NetworkEventUpdateMsg {
from: String, from: String,
#[serde(rename = "type")] #[serde(rename = "type")]
type_: String, type_: String,
updateType: String, update_type: String,
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct EventTimingsUpdateMsg { struct EventTimingsUpdateMsg {
totalTime: u64, total_time: u64,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -107,11 +109,12 @@ struct SecurityInfoUpdateMsg {
} }
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct ResponseStartUpdateMsg { struct ResponseStartUpdateMsg {
from: String, from: String,
#[serde(rename = "type")] #[serde(rename = "type")]
type_: String, type_: String,
updateType: String, update_type: String,
response: ResponseStartMsg, response: ResponseStartMsg,
} }
@ -463,7 +466,7 @@ fn run_server(
let msg = NetworkEventMsg { let msg = NetworkEventMsg {
from: console_actor_name, from: console_actor_name,
type_: "networkEvent".to_owned(), type_: "networkEvent".to_owned(),
eventActor: actor.event_actor(), event_actor: actor.event_actor(),
}; };
for stream in &mut connections { for stream in &mut connections {
let _ = stream.write_json_packet(&msg); let _ = stream.write_json_packet(&msg);
@ -476,7 +479,7 @@ fn run_server(
let msg = NetworkEventUpdateMsg { let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(), from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(), type_: "networkEventUpdate".to_owned(),
updateType: "requestHeaders".to_owned(), update_type: "requestHeaders".to_owned(),
}; };
for stream in &mut connections { for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &actor.request_headers()); let _ = stream.write_merged_json_packet(&msg, &actor.request_headers());
@ -485,7 +488,7 @@ fn run_server(
let msg = NetworkEventUpdateMsg { let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(), from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(), type_: "networkEventUpdate".to_owned(),
updateType: "requestCookies".to_owned(), update_type: "requestCookies".to_owned(),
}; };
for stream in &mut connections { for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &actor.request_cookies()); let _ = stream.write_merged_json_packet(&msg, &actor.request_cookies());
@ -495,7 +498,7 @@ fn run_server(
let msg = ResponseStartUpdateMsg { let msg = ResponseStartUpdateMsg {
from: netevent_actor_name.clone(), from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(), type_: "networkEventUpdate".to_owned(),
updateType: "responseStart".to_owned(), update_type: "responseStart".to_owned(),
response: actor.response_start(), response: actor.response_start(),
}; };
@ -505,10 +508,10 @@ fn run_server(
let msg = NetworkEventUpdateMsg { let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(), from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(), type_: "networkEventUpdate".to_owned(),
updateType: "eventTimings".to_owned(), update_type: "eventTimings".to_owned(),
}; };
let extra = EventTimingsUpdateMsg { let extra = EventTimingsUpdateMsg {
totalTime: actor.total_time(), total_time: actor.total_time(),
}; };
for stream in &mut connections { for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &extra); let _ = stream.write_merged_json_packet(&msg, &extra);
@ -517,7 +520,7 @@ fn run_server(
let msg = NetworkEventUpdateMsg { let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(), from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(), type_: "networkEventUpdate".to_owned(),
updateType: "securityInfo".to_owned(), update_type: "securityInfo".to_owned(),
}; };
let extra = SecurityInfoUpdateMsg { let extra = SecurityInfoUpdateMsg {
state: "insecure".to_owned(), state: "insecure".to_owned(),
@ -529,7 +532,7 @@ fn run_server(
let msg = NetworkEventUpdateMsg { let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(), from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(), type_: "networkEventUpdate".to_owned(),
updateType: "responseContent".to_owned(), update_type: "responseContent".to_owned(),
}; };
for stream in &mut connections { for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &actor.response_content()); let _ = stream.write_merged_json_packet(&msg, &actor.response_content());
@ -538,7 +541,7 @@ fn run_server(
let msg = NetworkEventUpdateMsg { let msg = NetworkEventUpdateMsg {
from: netevent_actor_name.clone(), from: netevent_actor_name.clone(),
type_: "networkEventUpdate".to_owned(), type_: "networkEventUpdate".to_owned(),
updateType: "responseCookies".to_owned(), update_type: "responseCookies".to_owned(),
}; };
for stream in &mut connections { for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &actor.response_cookies()); let _ = stream.write_merged_json_packet(&msg, &actor.response_cookies());
@ -547,7 +550,7 @@ fn run_server(
let msg = NetworkEventUpdateMsg { let msg = NetworkEventUpdateMsg {
from: netevent_actor_name, from: netevent_actor_name,
type_: "networkEventUpdate".to_owned(), type_: "networkEventUpdate".to_owned(),
updateType: "responseHeaders".to_owned(), update_type: "responseHeaders".to_owned(),
}; };
for stream in &mut connections { for stream in &mut connections {
let _ = stream.write_merged_json_packet(&msg, &actor.response_headers()); let _ = stream.write_merged_json_packet(&msg, &actor.response_headers());
@ -674,10 +677,10 @@ fn run_server(
)) => { )) => {
let console_message = ConsoleMessage { let console_message = ConsoleMessage {
message: css_error.msg, message: css_error.msg,
logLevel: LogLevel::Warn, log_level: LogLevel::Warn,
filename: css_error.filename, filename: css_error.filename,
lineNumber: css_error.line as usize, line_number: css_error.line as usize,
columnNumber: css_error.column as usize, column_number: css_error.column as usize,
}; };
handle_console_message( handle_console_message(
actors.clone(), actors.clone(),

3
components/devtools/protocol.rs
View file

@ -14,9 +14,10 @@ use serde::Serialize;
use serde_json::{self, Value}; use serde_json::{self, Value};
#[derive(Serialize)] #[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ActorDescription { pub struct ActorDescription {
pub category: &'static str, pub category: &'static str,
pub typeName: &'static str, pub type_name: &'static str,
pub methods: Vec<Method>, pub methods: Vec<Method>,
} }

4
components/net/http_loader.rs
View file

@ -364,8 +364,8 @@ fn prepare_devtools_request(
headers, headers,
body, body,
pipeline_id, pipeline_id,
startedDateTime: now, started_date_time: now,
timeStamp: now.duration_since(UNIX_EPOCH).unwrap_or_default().as_secs() as i64, time_stamp: now.duration_since(UNIX_EPOCH).unwrap_or_default().as_secs() as i64,
connect_time, connect_time,
send_time, send_time,
is_xhr, is_xhr,

4
components/net/tests/fetch.rs
View file

@ -1370,8 +1370,8 @@ fn test_fetch_with_devtools() {
headers: headers, headers: headers,
body: Some(vec![]), body: Some(vec![]),
pipeline_id: TEST_PIPELINE_ID, pipeline_id: TEST_PIPELINE_ID,
startedDateTime: devhttprequest.startedDateTime, started_date_time: devhttprequest.started_date_time,
timeStamp: devhttprequest.timeStamp, time_stamp: devhttprequest.time_stamp,
connect_time: devhttprequest.connect_time, connect_time: devhttprequest.connect_time,
send_time: devhttprequest.send_time, send_time: devhttprequest.send_time,
is_xhr: true, is_xhr: true,

4
components/net/tests/http_loader.rs
View file

@ -289,8 +289,8 @@ fn test_request_and_response_data_with_network_messages() {
headers: headers, headers: headers,
body: Some(vec![]), body: Some(vec![]),
pipeline_id: TEST_PIPELINE_ID, pipeline_id: TEST_PIPELINE_ID,
startedDateTime: devhttprequest.startedDateTime, started_date_time: devhttprequest.started_date_time,
timeStamp: devhttprequest.timeStamp, time_stamp: devhttprequest.time_stamp,
connect_time: devhttprequest.connect_time, connect_time: devhttprequest.connect_time,
send_time: devhttprequest.send_time, send_time: devhttprequest.send_time,
is_xhr: false, is_xhr: false,

36
components/script/devtools.rs
View file

@ -160,21 +160,21 @@ pub fn handle_get_layout(
.send(Some(ComputedNodeLayout { .send(Some(ComputedNodeLayout {
display: String::from(computed_style.Display()), display: String::from(computed_style.Display()),
position: String::from(computed_style.Position()), position: String::from(computed_style.Position()),
zIndex: String::from(computed_style.ZIndex()), z_index: String::from(computed_style.ZIndex()),
boxSizing: String::from(computed_style.BoxSizing()), box_sizing: String::from(computed_style.BoxSizing()),
autoMargins: determine_auto_margins(&node), auto_margins: determine_auto_margins(&node),
marginTop: String::from(computed_style.MarginTop()), margin_top: String::from(computed_style.MarginTop()),
marginRight: String::from(computed_style.MarginRight()), margin_right: String::from(computed_style.MarginRight()),
marginBottom: String::from(computed_style.MarginBottom()), margin_bottom: String::from(computed_style.MarginBottom()),
marginLeft: String::from(computed_style.MarginLeft()), margin_left: String::from(computed_style.MarginLeft()),
borderTopWidth: String::from(computed_style.BorderTopWidth()), border_top_width: String::from(computed_style.BorderTopWidth()),
borderRightWidth: String::from(computed_style.BorderRightWidth()), border_right_width: String::from(computed_style.BorderRightWidth()),
borderBottomWidth: String::from(computed_style.BorderBottomWidth()), border_bottom_width: String::from(computed_style.BorderBottomWidth()),
borderLeftWidth: String::from(computed_style.BorderLeftWidth()), border_left_width: String::from(computed_style.BorderLeftWidth()),
paddingTop: String::from(computed_style.PaddingTop()), padding_top: String::from(computed_style.PaddingTop()),
paddingRight: String::from(computed_style.PaddingRight()), padding_right: String::from(computed_style.PaddingRight()),
paddingBottom: String::from(computed_style.PaddingBottom()), padding_bottom: String::from(computed_style.PaddingBottom()),
paddingLeft: String::from(computed_style.PaddingLeft()), padding_left: String::from(computed_style.PaddingLeft()),
width, width,
height, height,
})) }))
@ -213,14 +213,14 @@ pub fn handle_modify_attribute(
.expect("should be getting layout of element"); .expect("should be getting layout of element");
for modification in modifications { for modification in modifications {
match modification.newValue { match modification.new_value {
Some(string) => { Some(string) => {
let _ = elem.SetAttribute( let _ = elem.SetAttribute(
DOMString::from(modification.attributeName), DOMString::from(modification.attribute_name),
DOMString::from(string), DOMString::from(string),
); );
}, },
None => elem.RemoveAttribute(DOMString::from(modification.attributeName)), None => elem.RemoveAttribute(DOMString::from(modification.attribute_name)),
} }
} }
} }

6
components/script/dom/console.rs
View file

@ -37,10 +37,10 @@ impl Console {
unsafe { describe_scripted_caller(*GlobalScope::get_cx()) }.unwrap_or_default(); unsafe { describe_scripted_caller(*GlobalScope::get_cx()) }.unwrap_or_default();
let console_message = ConsoleMessage { let console_message = ConsoleMessage {
message, message,
logLevel: level, log_level: level,
filename: caller.filename, filename: caller.filename,
lineNumber: caller.line as usize, line_number: caller.line as usize,
columnNumber: caller.col as usize, column_number: caller.col as usize,
}; };
let worker_id = global let worker_id = global
.downcast::<WorkerGlobalScope>() .downcast::<WorkerGlobalScope>()

24
components/script/dom/globalscope.rs
View file

@ -2299,13 +2299,13 @@ impl GlobalScope {
self.pipeline_id, self.pipeline_id,
PageError { PageError {
type_: "PageError".to_string(), type_: "PageError".to_string(),
errorMessage: warning.to_string(), error_message: warning.to_string(),
sourceName: self.get_url().to_string(), source_name: self.get_url().to_string(),
lineText: "".to_string(), line_text: "".to_string(),
lineNumber: 0, line_number: 0,
columnNumber: 0, column_number: 0,
category: "script".to_string(), category: "script".to_string(),
timeStamp: 0, //TODO time_stamp: 0, //TODO
error: false, error: false,
warning: true, warning: true,
exception: true, exception: true,
@ -2487,13 +2487,13 @@ impl GlobalScope {
self.pipeline_id, self.pipeline_id,
PageError { PageError {
type_: "PageError".to_string(), type_: "PageError".to_string(),
errorMessage: error_info.message.clone(), error_message: error_info.message.clone(),
sourceName: error_info.filename.clone(), source_name: error_info.filename.clone(),
lineText: "".to_string(), //TODO line_text: "".to_string(), //TODO
lineNumber: error_info.lineno, line_number: error_info.lineno,
columnNumber: error_info.column, column_number: error_info.column,
category: "script".to_string(), category: "script".to_string(),
timeStamp: 0, //TODO time_stamp: 0, //TODO
error: true, error: true,
warning: false, warning: false,
exception: true, exception: true,

22
components/script/dom/node.rs
View file

@ -1114,29 +1114,29 @@ impl Node {
pub fn summarize(&self) -> NodeInfo { pub fn summarize(&self) -> NodeInfo {
let USVString(base_uri) = self.BaseURI(); let USVString(base_uri) = self.BaseURI();
NodeInfo { NodeInfo {
uniqueId: self.unique_id(), unique_id: self.unique_id(),
baseURI: base_uri, base_uri,
parent: self parent: self
.GetParentNode() .GetParentNode()
.map_or("".to_owned(), |node| node.unique_id()), .map_or("".to_owned(), |node| node.unique_id()),
nodeType: self.NodeType(), node_type: self.NodeType(),
namespaceURI: String::new(), //FIXME namespace_uri: String::new(), //FIXME
nodeName: String::from(self.NodeName()), node_name: String::from(self.NodeName()),
numChildren: self.ChildNodes().Length() as usize, num_children: self.ChildNodes().Length() as usize,
//FIXME doctype nodes only //FIXME doctype nodes only
name: String::new(), name: String::new(),
publicId: String::new(), public_id: String::new(),
systemId: String::new(), system_id: String::new(),
attrs: self.downcast().map(Element::summarize).unwrap_or(vec![]), attrs: self.downcast().map(Element::summarize).unwrap_or(vec![]),
isDocumentElement: self is_document_element: self
.owner_doc() .owner_doc()
.GetDocumentElement() .GetDocumentElement()
.map_or(false, |elem| elem.upcast::<Node>() == self), .map_or(false, |elem| elem.upcast::<Node>() == self),
shortValue: self.GetNodeValue().map(String::from).unwrap_or_default(), //FIXME: truncate short_value: self.GetNodeValue().map(String::from).unwrap_or_default(), //FIXME: truncate
incompleteValue: false, //FIXME: reflect truncation incomplete_value: false, //FIXME: reflect truncation
} }
} }

96
components/shared/devtools/lib.rs
View file

@ -8,7 +8,6 @@
#![crate_name = "devtools_traits"] #![crate_name = "devtools_traits"]
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![allow(non_snake_case)]
#![deny(unsafe_code)] #![deny(unsafe_code)]
use std::net::TcpStream; use std::net::TcpStream;
@ -118,25 +117,24 @@ pub struct AttrInfo {
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeInfo { pub struct NodeInfo {
pub uniqueId: String, pub unique_id: String,
pub baseURI: String, #[serde(rename = "baseURI")]
pub base_uri: String,
pub parent: String, pub parent: String,
pub nodeType: u16, pub node_type: u16,
pub namespaceURI: String, #[serde(rename = "namespaceURI")]
pub nodeName: String, pub namespace_uri: String,
pub numChildren: usize, pub node_name: String,
pub num_children: usize,
pub name: String, pub name: String,
pub publicId: String, pub public_id: String,
pub systemId: String, pub system_id: String,
pub attrs: Vec<AttrInfo>, pub attrs: Vec<AttrInfo>,
pub is_document_element: bool,
pub isDocumentElement: bool, pub short_value: String,
pub incomplete_value: bool,
pub shortValue: String,
pub incompleteValue: bool,
} }
pub struct StartedTimelineMarker { pub struct StartedTimelineMarker {
@ -162,27 +160,28 @@ pub enum TimelineMarkerType {
/// The properties of a DOM node as computed by layout. /// The properties of a DOM node as computed by layout.
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComputedNodeLayout { pub struct ComputedNodeLayout {
pub display: String, pub display: String,
pub position: String, pub position: String,
pub zIndex: String, pub z_index: String,
pub boxSizing: String, pub box_sizing: String,
pub autoMargins: AutoMargins, pub auto_margins: AutoMargins,
pub marginTop: String, pub margin_top: String,
pub marginRight: String, pub margin_right: String,
pub marginBottom: String, pub margin_bottom: String,
pub marginLeft: String, pub margin_left: String,
pub borderTopWidth: String, pub border_top_width: String,
pub borderRightWidth: String, pub border_right_width: String,
pub borderBottomWidth: String, pub border_bottom_width: String,
pub borderLeftWidth: String, pub border_left_width: String,
pub paddingTop: String, pub padding_top: String,
pub paddingRight: String, pub padding_right: String,
pub paddingBottom: String, pub padding_bottom: String,
pub paddingLeft: String, pub padding_left: String,
pub width: f32, pub width: f32,
pub height: f32, pub height: f32,
@ -230,9 +229,10 @@ pub enum DevtoolScriptControlMsg {
} }
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Modification { pub struct Modification {
pub attributeName: String, pub attribute_name: String,
pub newValue: Option<String>, pub new_value: Option<String>,
} }
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
@ -246,12 +246,13 @@ pub enum LogLevel {
} }
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConsoleMessage { pub struct ConsoleMessage {
pub message: String, pub message: String,
pub logLevel: LogLevel, pub log_level: LogLevel,
pub filename: String, pub filename: String,
pub lineNumber: usize, pub line_number: usize,
pub columnNumber: usize, pub column_number: usize,
} }
bitflags! { bitflags! {
@ -263,16 +264,17 @@ bitflags! {
} }
#[derive(Clone, Debug, Deserialize, Serialize)] #[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PageError { pub struct PageError {
#[serde(rename = "_type")] #[serde(rename = "_type")]
pub type_: String, pub type_: String,
pub errorMessage: String, pub error_message: String,
pub sourceName: String, pub source_name: String,
pub lineText: String, pub line_text: String,
pub lineNumber: u32, pub line_number: u32,
pub columnNumber: u32, pub column_number: u32,
pub category: String, pub category: String,
pub timeStamp: u64, pub time_stamp: u64,
pub error: bool, pub error: bool,
pub warning: bool, pub warning: bool,
pub exception: bool, pub exception: bool,
@ -286,9 +288,9 @@ pub struct ConsoleAPI {
pub type_: String, pub type_: String,
pub level: String, pub level: String,
pub filename: String, pub filename: String,
pub lineNumber: u32, pub line_number: u32,
pub functionName: String, pub function_name: String,
pub timeStamp: u64, pub time_stamp: u64,
pub private: bool, pub private: bool,
pub arguments: Vec<String>, pub arguments: Vec<String>,
} }
@ -306,8 +308,8 @@ pub struct HttpRequest {
pub headers: HeaderMap, pub headers: HeaderMap,
pub body: Option<Vec<u8>>, pub body: Option<Vec<u8>>,
pub pipeline_id: PipelineId, pub pipeline_id: PipelineId,
pub startedDateTime: SystemTime, pub started_date_time: SystemTime,
pub timeStamp: i64, pub time_stamp: i64,
pub connect_time: u64, pub connect_time: u64,
pub send_time: u64, pub send_time: u64,
pub is_xhr: bool, pub is_xhr: bool,