Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-10 07:55:33 +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 {
name: actors.new_name("inspector"),
walker: RefCell::new(None),
pageStyle: RefCell::new(None),
page_style: RefCell::new(None),
highlighter: RefCell::new(None),
script_chan: script_sender.clone(),
browsing_context: name.clone(),

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

@ -49,10 +49,11 @@ impl EncodableConsoleMessage for CachedConsoleMessage {
struct StartedListenersTraits;
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct StartedListenersReply {
from: String,
nativeConsoleAPI: bool,
startedListeners: Vec<String>,
native_console_api: bool,
started_listeners: Vec<String>,
traits: StartedListenersTraits,
}
@ -63,46 +64,53 @@ struct GetCachedMessagesReply {
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct StopListenersReply {
from: String,
stoppedListeners: Vec<String>,
stopped_listeners: Vec<String>,
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct AutocompleteReply {
from: String,
matches: Vec<String>,
matchProp: String,
match_prop: String,
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct EvaluateJSReply {
from: String,
input: String,
result: Value,
timestamp: u64,
exception: Value,
exceptionMessage: Value,
helperResult: Value,
exception_message: Value,
helper_result: Value,
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct EvaluateJSEvent {
from: String,
r#type: String,
#[serde(rename = "type")]
type_: String,
input: String,
result: Value,
timestamp: u64,
resultID: String,
#[serde(rename = "resultID")]
result_id: String,
exception: Value,
exceptionMessage: Value,
helperResult: Value,
exception_message: Value,
helper_result: Value,
}
#[derive(Serialize)]
struct EvaluateJSAsyncReply {
from: String,
resultID: String,
#[serde(rename = "resultID")]
result_id: String,
}
#[derive(Serialize)]
@ -162,7 +170,7 @@ impl ConsoleActor {
}
}
fn evaluateJS(
fn evaluate_js(
&self,
registry: &ActorRegistry,
msg: &Map<String, Value>,
@ -240,8 +248,8 @@ impl ConsoleActor {
result,
timestamp: 0,
exception: Value::Null,
exceptionMessage: Value::Null,
helperResult: Value::Null,
exception_message: Value::Null,
helper_result: Value::Null,
};
std::result::Result::Ok(reply)
}
@ -261,7 +269,7 @@ impl ConsoleActor {
let msg = PageErrorMsg {
from: self.name(),
type_: "pageError".to_owned(),
pageError: page_error,
page_error,
};
self.streams_mut(registry, |stream| {
let _ = stream.write_json_packet(&msg);
@ -275,7 +283,7 @@ impl ConsoleActor {
id: UniqueId,
registry: &ActorRegistry,
) {
let level = match console_message.logLevel {
let level = match console_message.log_level {
LogLevel::Debug => "debug",
LogLevel::Info => "info",
LogLevel::Warn => "warn",
@ -292,9 +300,9 @@ impl ConsoleActor {
type_: "ConsoleAPI".to_owned(),
level: level.clone(),
filename: console_message.filename.clone(),
lineNumber: console_message.lineNumber as u32,
functionName: "".to_string(), //TODO
timeStamp: SystemTime::now()
line_number: console_message.line_number as u32,
function_name: "".to_string(), //TODO
time_stamp: SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_nanos() as u64,
@ -307,14 +315,14 @@ impl ConsoleActor {
type_: "consoleAPICall".to_owned(),
message: ConsoleMsg {
level,
timeStamp: SystemTime::now()
timestamp: SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_nanos() as u64,
arguments: vec![console_message.message],
filename: console_message.filename,
lineNumber: console_message.lineNumber,
columnNumber: console_message.columnNumber,
line_number: console_message.line_number,
column_number: console_message.column_number,
},
};
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 msg = StartedListenersReply {
from: self.name(),
nativeConsoleAPI: true,
startedListeners: listeners
native_console_api: true,
started_listeners: listeners
.into_iter()
.map(|s| s.as_str().unwrap().to_owned())
.collect(),
@ -419,7 +427,7 @@ impl Actor for ConsoleActor {
//TODO: actually implement listener filters that support starting/stopping
let msg = StopListenersReply {
from: self.name(),
stoppedListeners: msg
stopped_listeners: msg
.get("listeners")
.unwrap()
.as_array()
@ -438,23 +446,23 @@ impl Actor for ConsoleActor {
let msg = AutocompleteReply {
from: self.name(),
matches: vec![],
matchProp: "".to_owned(),
match_prop: "".to_owned(),
};
let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed
},
"evaluateJS" => {
let msg = self.evaluateJS(registry, msg);
let msg = self.evaluate_js(registry, msg);
let _ = stream.write_json_packet(&msg);
ActorMessageStatus::Processed
},
"evaluateJSAsync" => {
let resultID = Uuid::new_v4().to_string();
let result_id = Uuid::new_v4().to_string();
let early_reply = EvaluateJSAsyncReply {
from: self.name(),
resultID: resultID.clone(),
result_id: result_id.clone(),
};
// Emit an eager reply so that the client starts listening
// for an async event with the resultID
@ -468,17 +476,17 @@ impl Actor for ConsoleActor {
return Ok(ActorMessageStatus::Processed);
}
let reply = self.evaluateJS(registry, msg).unwrap();
let reply = self.evaluate_js(registry, msg).unwrap();
let msg = EvaluateJSEvent {
from: self.name(),
r#type: "evaluationResult".to_owned(),
type_: "evaluationResult".to_owned(),
input: reply.input,
result: reply.result,
timestamp: reply.timestamp,
resultID,
result_id,
exception: reply.exception,
exceptionMessage: reply.exceptionMessage,
helperResult: reply.helperResult,
exception_message: reply.exception_message,
helper_result: reply.helper_result,
};
// Send the data from evaluateJS along with a resultID
let _ = stream.write_json_packet(&msg);
@ -508,19 +516,21 @@ struct ConsoleAPICall {
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct ConsoleMsg {
level: String,
timeStamp: u64,
timestamp: u64,
arguments: Vec<String>,
filename: String,
lineNumber: usize,
columnNumber: usize,
line_number: usize,
column_number: usize,
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct PageErrorMsg {
from: String,
#[serde(rename = "type")]
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
// (see https://searchfox.org/mozilla-central/source/devtools/shared/system.js#45)
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct SystemInfo {
apptype: String,
// Display version
@ -30,7 +31,7 @@ struct SystemInfo {
// Firefox major.minor version number, use for compatibility checks
platformversion: String,
// Display name
brandName: String,
brand_name: String,
}
include!(concat!(env!("OUT_DIR"), "/build_id.rs"));
@ -60,7 +61,7 @@ impl Actor for DeviceActor {
version: env!("CARGO_PKG_VERSION").to_string(),
appbuildid: BUILD_ID.to_string(),
platformversion: "125.0".to_string(),
brandName: "Servo".to_string(),
brand_name: "Servo".to_string(),
},
};
let _ = stream.write_json_packet(&msg);
@ -80,7 +81,7 @@ impl DeviceActor {
pub fn description() -> ActorDescription {
ActorDescription {
category: "actor",
typeName: "device",
type_name: "device",
methods: vec![Method {
name: "getDescription",
request: Value::Null,

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

@ -18,7 +18,6 @@ pub struct FramerateActor {
name: String,
pipeline: PipelineId,
script_sender: IpcSender<DevtoolScriptControlMsg>,
is_recording: bool,
ticks: Vec<HighResolutionStamp>,
}
@ -41,7 +40,7 @@ impl Actor for FramerateActor {
}
impl FramerateActor {
/// return name of actor
/// Return name of actor
pub fn create(
registry: &ActorRegistry,
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).
#![allow(non_snake_case)] // NOTE: To be removed on the inspector specific pr
use std::cell::RefCell;
use std::net::TcpStream;
@ -24,7 +26,7 @@ use crate::StreamId;
pub struct InspectorActor {
pub name: String,
pub walker: RefCell<Option<String>>,
pub pageStyle: RefCell<Option<String>>,
pub page_style: RefCell<Option<String>>,
pub highlighter: RefCell<Option<String>>,
pub script_chan: IpcSender<DevtoolScriptControlMsg>,
pub browsing_context: String,
@ -203,32 +205,32 @@ impl NodeInfoToProtocol for NodeInfo {
script_chan: IpcSender<DevtoolScriptControlMsg>,
pipeline: PipelineId,
) -> 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 node_actor = NodeActor {
name: name.clone(),
script_chan,
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));
name
} else {
actors.script_to_actor(self.uniqueId)
actors.script_to_actor(self.unique_id)
};
NodeActorMsg {
actor: actor_name,
baseURI: self.baseURI,
baseURI: self.base_uri,
parent: actors.script_to_actor(self.parent.clone()),
nodeType: self.nodeType,
namespaceURI: self.namespaceURI,
nodeName: self.nodeName,
numChildren: self.numChildren,
nodeType: self.node_type,
namespaceURI: self.namespace_uri,
nodeName: self.node_name,
numChildren: self.num_children,
name: self.name,
publicId: self.publicId,
systemId: self.systemId,
publicId: self.public_id,
systemId: self.system_id,
attrs: self
.attrs
@ -246,10 +248,10 @@ impl NodeInfoToProtocol for NodeInfo {
hasEventListeners: false, //TODO get this data from script
isDocumentElement: self.isDocumentElement,
isDocumentElement: self.is_document_element,
shortValue: self.shortValue,
incompleteValue: self.incompleteValue,
shortValue: self.short_value,
incompleteValue: self.incomplete_value,
}
}
}
@ -517,21 +519,21 @@ impl Actor for PageStyleActor {
let ComputedNodeLayout {
display,
position,
zIndex,
boxSizing,
autoMargins,
marginTop,
marginRight,
marginBottom,
marginLeft,
borderTopWidth,
borderRightWidth,
borderBottomWidth,
borderLeftWidth,
paddingTop,
paddingRight,
paddingBottom,
paddingLeft,
z_index: zIndex,
box_sizing: boxSizing,
auto_margins: autoMargins,
margin_top: marginTop,
margin_right: marginRight,
margin_bottom: marginBottom,
margin_left: marginLeft,
border_top_width: borderTopWidth,
border_right_width: borderRightWidth,
border_bottom_width: borderBottomWidth,
border_left_width: borderLeftWidth,
padding_top: paddingTop,
padding_right: paddingRight,
padding_bottom: paddingBottom,
padding_left: paddingLeft,
width,
height,
} = rx.recv().unwrap().ok_or(())?;
@ -639,13 +641,13 @@ impl Actor for InspectorActor {
},
"getPageStyle" => {
if self.pageStyle.borrow().is_none() {
if self.page_style.borrow().is_none() {
let style = PageStyleActor {
name: registry.new_name("pageStyle"),
script_chan: self.script_chan.clone(),
pipeline,
};
let mut pageStyle = self.pageStyle.borrow_mut();
let mut pageStyle = self.page_style.borrow_mut();
*pageStyle = Some(style.name());
registry.register_later(Box::new(style));
}
@ -653,7 +655,7 @@ impl Actor for InspectorActor {
let msg = GetPageStyleReply {
from: self.name(),
pageStyle: PageStyleMsg {
actor: self.pageStyle.borrow().clone().unwrap(),
actor: self.page_style.borrow().clone().unwrap(),
},
};
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;
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TimelineMemoryReply {
jsObjectSize: u64,
jsStringSize: u64,
jsOtherSize: u64,
domSize: u64,
styleSize: u64,
otherSize: u64,
totalSize: u64,
jsMilliseconds: f64,
nonJSMilliseconds: f64,
js_object_size: u64,
js_string_size: u64,
js_other_size: u64,
dom_size: u64,
style_size: u64,
other_size: u64,
total_size: u64,
js_milliseconds: f64,
#[serde(rename = "nonJSMilliseconds")]
non_js_milliseconds: f64,
}
pub struct MemoryActor {
@ -57,17 +59,16 @@ impl MemoryActor {
}
pub fn measure(&self) -> TimelineMemoryReply {
//TODO:
TimelineMemoryReply {
jsObjectSize: 1,
jsStringSize: 1,
jsOtherSize: 1,
domSize: 1,
styleSize: 1,
otherSize: 1,
totalSize: 1,
jsMilliseconds: 1.1,
nonJSMilliseconds: 1.1,
js_object_size: 1,
js_string_size: 1,
js_other_size: 1,
dom_size: 1,
style_size: 1,
other_size: 1,
total_size: 1,
js_milliseconds: 1.1,
non_js_milliseconds: 1.1,
}
}
}

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

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

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

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

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

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

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

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

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

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