Start using on_refresh_driver_tick #5681

Final

components/devtools/actors/framerate.rs

@@ -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;
     }
 

components/devtools/actors/timeline.rs

@@ -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(),