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

Start using on_refresh_driver_tick #5681

Browse source 
Final
This commit is contained in:
Guro Bokum 2015-04-20 22:01:56 +07:00
parent 6d2f70a4fd
commit be2cb665de
19 changed files with 315 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -5,15 +5,23 @@
use rustc_serialize::json;
use std::mem;
use std::net::TcpStream;
use std::sync::{Arc, Mutex};
use std::sync::mpsc::Sender;
use time::precise_time_ns;
use msg::constellation_msg::PipelineId;
use actor::{Actor, ActorRegistry};
use actors::timeline::HighResolutionStamp;
use devtools_traits::{DevtoolsControlMsg, DevtoolScriptControlMsg};
pub struct FramerateActor {
name: String,
pipeline: PipelineId,
script_sender: Sender<DevtoolScriptControlMsg>,
devtools_sender: Sender<DevtoolsControlMsg>,
start_time: Option<u64>,
is_recording: bool,
ticks: Vec<u64>,
is_recording: Arc<Mutex<bool>>,
ticks: Arc<Mutex<Vec<HighResolutionStamp>>>,
}
impl Actor for FramerateActor {
@ -33,13 +41,19 @@ impl Actor for FramerateActor {
impl FramerateActor {
/// return name of actor
pub fn create(registry: &ActorRegistry) -> String {
pub fn create(registry: &ActorRegistry,
pipeline_id: PipelineId,
script_sender: Sender<DevtoolScriptControlMsg>,
devtools_sender: Sender<DevtoolsControlMsg>) -> String {
let actor_name = registry.new_name("framerate");
let mut actor = FramerateActor {
name: actor_name.clone(),
pipeline: pipeline_id,
script_sender: script_sender,
devtools_sender: devtools_sender,
start_time: None,
is_recording: false,
ticks: Vec::new(),
is_recording: Arc::new(Mutex::new(false)),
ticks: Arc::new(Mutex::new(Vec::new())),
};
actor.start_recording();
@ -47,36 +61,71 @@ impl FramerateActor {
actor_name
}
// callback on request animation frame
#[allow(dead_code)]
pub fn on_refresh_driver_tick(&mut self) {
if !self.is_recording {
return;
}
// TODO: Need implement requesting animation frame
// http://hg.mozilla.org/mozilla-central/file/0a46652bd992/dom/base/nsGlobalWindow.cpp#l5314
let start_time = self.start_time.as_ref().unwrap();
self.ticks.push(*start_time - precise_time_ns());
pub fn add_tick(&self, tick: f64) {
let mut lock = self.ticks.lock();
let mut ticks = lock.as_mut().unwrap();
ticks.push(HighResolutionStamp::wrap(tick));
}
pub fn take_pending_ticks(&mut self) -> Vec<u64> {
mem::replace(&mut self.ticks, Vec::new())
pub fn take_pending_ticks(&self) -> Vec<HighResolutionStamp> {
let mut lock = self.ticks.lock();
let mut ticks = lock.as_mut().unwrap();
mem::replace(ticks, Vec::new())
}
fn start_recording(&mut self) {
self.is_recording = true;
self.start_time = Some(precise_time_ns());
let mut lock = self.is_recording.lock();
if **lock.as_ref().unwrap() {
return;
}
// TODO(#5681): Need implement requesting animation frame
// http://hg.mozilla.org/mozilla-central/file/0a46652bd992/dom/base/nsGlobalWindow.cpp#l5314
self.start_time = Some(precise_time_ns());
let is_recording = lock.as_mut();
**is_recording.unwrap() = true;
fn get_closure(is_recording: Arc<Mutex<bool>>,
name: String,
pipeline: PipelineId,
script_sender: Sender<DevtoolScriptControlMsg>,
devtools_sender: Sender<DevtoolsControlMsg>)
-> Box<Fn(f64, ) + Send> {
let closure = move |now: f64| {
let msg = DevtoolsControlMsg::FramerateTick(name.clone(), now);
devtools_sender.send(msg).unwrap();
if !*is_recording.lock().unwrap() {
return;
}
let closure = get_closure(is_recording.clone(),
name.clone(),
pipeline.clone(),
script_sender.clone(),
devtools_sender.clone());
let msg = DevtoolScriptControlMsg::RequestAnimationFrame(pipeline, closure);
script_sender.send(msg).unwrap();
};
Box::new(closure)
};
let closure = get_closure(self.is_recording.clone(),
self.name(),
self.pipeline.clone(),
self.script_sender.clone(),
self.devtools_sender.clone());
let msg = DevtoolScriptControlMsg::RequestAnimationFrame(self.pipeline, closure);
self.script_sender.send(msg).unwrap();
}
fn stop_recording(&mut self) {
if !self.is_recording {
let mut lock = self.is_recording.lock();
if !**lock.as_ref().unwrap() {
return;
}
self.is_recording = false;
let is_recording = lock.as_mut();
**is_recording.unwrap() = false;
self.start_time = None;
}

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

@ -16,7 +16,7 @@ use time::PreciseTime;
use actor::{Actor, ActorRegistry};
use actors::memory::{MemoryActor, TimelineMemoryReply};
use actors::framerate::FramerateActor;
use devtools_traits::DevtoolScriptControlMsg;
use devtools_traits::{DevtoolsControlMsg, DevtoolScriptControlMsg};
use devtools_traits::DevtoolScriptControlMsg::{SetTimelineMarkers, DropTimelineMarkers};
use devtools_traits::{TimelineMarker, TracingMetadata, TimelineMarkerType};
use protocol::JsonPacketStream;
@ -25,6 +25,7 @@ use util::task;
pub struct TimelineActor {
name: String,
script_sender: Sender<DevtoolScriptControlMsg>,
devtools_sender: Sender<DevtoolsControlMsg>,
marker_types: Vec<TimelineMarkerType>,
pipeline: PipelineId,
is_recording: Arc<Mutex<bool>>,
@ -93,21 +94,25 @@ struct FramerateEmitterReply {
__type__: String,
from: String,
delta: HighResolutionStamp,
timestamps: Vec<u64>,
timestamps: Vec<HighResolutionStamp>,
}
/// HighResolutionStamp is struct that contains duration in milliseconds
/// with accuracy to microsecond that shows how much time has passed since
/// actor registry inited
/// analog https://w3c.github.io/hr-time/#sec-DOMHighResTimeStamp
struct HighResolutionStamp(f64);
pub struct HighResolutionStamp(f64);
impl HighResolutionStamp {
fn new(start_stamp: PreciseTime, time: PreciseTime) -> HighResolutionStamp {
pub fn new(start_stamp: PreciseTime, time: PreciseTime) -> HighResolutionStamp {
let duration = start_stamp.to(time).num_microseconds()
.expect("Too big duration in microseconds");
HighResolutionStamp(duration as f64 / 1000 as f64)
}
pub fn wrap(time: f64) -> HighResolutionStamp {
HighResolutionStamp(time)
}
}
impl Encodable for HighResolutionStamp {
@ -121,7 +126,8 @@ static DEFAULT_TIMELINE_DATA_PULL_TIMEOUT: u32 = 200; //ms
impl TimelineActor {
pub fn new(name: String,
pipeline: PipelineId,
script_sender: Sender<DevtoolScriptControlMsg>) -> TimelineActor {
script_sender: Sender<DevtoolScriptControlMsg>,
devtools_sender: Sender<DevtoolsControlMsg>) -> TimelineActor {
let marker_types = vec!(TimelineMarkerType::Reflow,
TimelineMarkerType::DOMEvent);
@ -131,6 +137,7 @@ impl TimelineActor {
pipeline: pipeline,
marker_types: marker_types,
script_sender: script_sender,
devtools_sender: devtools_sender,
is_recording: Arc::new(Mutex::new(false)),
stream: RefCell::new(None),
@ -248,7 +255,11 @@ impl Actor for TimelineActor {
// init framerate actor
if let Some(with_ticks) = msg.get("withTicks") {
if let Some(true) = with_ticks.as_boolean() {
*self.framerate_actor.borrow_mut() = Some(FramerateActor::create(registry));
let framerate_actor = Some(FramerateActor::create(registry,
self.pipeline.clone(),
self.script_sender.clone(),
self.devtools_sender.clone()));
*self.framerate_actor.borrow_mut() = framerate_actor;
}
}
@ -352,7 +363,7 @@ impl Emitter {
if let Some(ref actor_name) = self.framerate_actor {
let mut lock = self.registry.lock();
let registry = lock.as_mut().unwrap();
let mut framerate_actor = registry.find_mut::<FramerateActor>(actor_name);
let framerate_actor = registry.find_mut::<FramerateActor>(actor_name);
let framerateReply = FramerateEmitterReply {
__type__: "framerate".to_string(),
from: framerate_actor.name(),

32
components/devtools/lib.rs
View file

@ -31,11 +31,12 @@ extern crate url;
use actor::{Actor, ActorRegistry};
use actors::console::ConsoleActor;
use actors::network_event::{NetworkEventActor, EventActor, ResponseStartMsg};
use actors::worker::WorkerActor;
use actors::framerate::FramerateActor;
use actors::inspector::InspectorActor;
use actors::root::RootActor;
use actors::tab::TabActor;
use actors::timeline::TimelineActor;
use actors::worker::WorkerActor;
use protocol::JsonPacketStream;
use devtools_traits::{ConsoleMessage, DevtoolsControlMsg, NetworkEvent};
@ -170,12 +171,19 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
}
}
fn handle_framerate_tick(actors: Arc<Mutex<ActorRegistry>>, actor_name: String, tick: f64) {
let actors = actors.lock().unwrap();
let framerate_actor = actors.find::<FramerateActor>(&actor_name);
framerate_actor.add_tick(tick);
}
// We need separate actor representations for each script global that exists;
// clients can theoretically connect to multiple globals simultaneously.
// TODO: move this into the root or tab modules?
fn handle_new_global(actors: Arc<Mutex<ActorRegistry>>,
ids: (PipelineId, Option<WorkerId>),
scriptSender: Sender<DevtoolScriptControlMsg>,
script_sender: Sender<DevtoolScriptControlMsg>,
devtools_sender: Sender<DevtoolsControlMsg>,
actor_pipelines: &mut HashMap<PipelineId, String>,
actor_workers: &mut HashMap<(PipelineId, WorkerId), String>,
page_info: DevtoolsPageInfo) {
@ -187,7 +195,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
let (tab, console, inspector, timeline) = {
let console = ConsoleActor {
name: actors.new_name("console"),
script_chan: scriptSender.clone(),
script_chan: script_sender.clone(),
pipeline: pipeline,
streams: RefCell::new(Vec::new()),
};
@ -196,13 +204,14 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
walker: RefCell::new(None),
pageStyle: RefCell::new(None),
highlighter: RefCell::new(None),
script_chan: scriptSender.clone(),
script_chan: script_sender.clone(),
pipeline: pipeline,
};
let timeline = TimelineActor::new(actors.new_name("timeline"),
pipeline,
scriptSender);
script_sender,
devtools_sender);
let DevtoolsPageInfo { title, url } = page_info;
let tab = TabActor {
@ -343,11 +352,12 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
}
}
let sender_clone = sender.clone();
spawn_named("DevtoolsClientAcceptor".to_owned(), move || {
// accept connections and process them, spawning a new task for each one
for stream in listener.incoming() {
// connection succeeded
sender.send(DevtoolsControlMsg::AddClient(stream.unwrap())).unwrap();
sender_clone.send(DevtoolsControlMsg::AddClient(stream.unwrap())).unwrap();
}
});
@ -360,9 +370,10 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
handle_client(actors, stream.try_clone().unwrap())
})
}
Ok(DevtoolsControlMsg::ServerExitMsg) | Err(RecvError) => break,
Ok(DevtoolsControlMsg::NewGlobal(ids, scriptSender, pageinfo)) =>
handle_new_global(actors.clone(), ids, scriptSender, &mut actor_pipelines,
Ok(DevtoolsControlMsg::FramerateTick(actor_name, tick)) =>
handle_framerate_tick(actors.clone(), actor_name, tick),
Ok(DevtoolsControlMsg::NewGlobal(ids, script_sender, pageinfo)) =>
handle_new_global(actors.clone(), ids, script_sender, sender.clone(), &mut actor_pipelines,
&mut actor_workers, pageinfo),
Ok(DevtoolsControlMsg::SendConsoleMessage(id, console_message)) =>
handle_console_message(actors.clone(), id, console_message,
@ -377,7 +388,8 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
// For now, the id of the first pipeline is passed
handle_network_event(actors.clone(), connections, &actor_pipelines, &mut actor_requests,
PipelineId(0), request_id, network_event);
}
},
Ok(DevtoolsControlMsg::ServerExitMsg) | Err(RecvError) => break
}
}
for connection in accepted_connections.iter_mut() {