/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use dom::bindings::cell::DOMRefCell; use dom::bindings::codegen::Bindings::PerformanceBinding; use dom::bindings::codegen::Bindings::PerformanceBinding::{DOMHighResTimeStamp, PerformanceMethods}; use dom::bindings::codegen::Bindings::PerformanceBinding::PerformanceEntryList as DOMPerformanceEntryList; use dom::bindings::js::{JS, Root}; use dom::bindings::num::Finite; use dom::bindings::refcounted::Trusted; use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object}; use dom::bindings::str::DOMString; use dom::performanceentry::PerformanceEntry; use dom::performanceobserver::PerformanceObserver as DOMPerformanceObserver; use dom::performancetiming::PerformanceTiming; use dom::window::Window; use dom_struct::dom_struct; use script_thread::{Runnable, ScriptThread}; use std::cell::Cell; use std::cmp::Ordering; use time; /// Implementation of a list of PerformanceEntry items shared by the /// Performance and PerformanceObserverEntryList interfaces implementations. #[derive(HeapSizeOf, JSTraceable)] pub struct PerformanceEntryList { entries: DOMPerformanceEntryList, } impl PerformanceEntryList { pub fn new(entries: DOMPerformanceEntryList) -> Self { PerformanceEntryList { entries, } } pub fn get_entries_by_name_and_type(&self, name: Option, entry_type: Option) -> Vec> { let mut res = self.entries.iter().filter(|e| name.as_ref().map_or(true, |name_| *e.name() == *name_) && entry_type.as_ref().map_or(true, |type_| *e.entry_type() == *type_) ).map(|e| e.clone()).collect::>>(); res.sort_by(|a, b| a.start_time().partial_cmp(&b.start_time()).unwrap_or(Ordering::Equal)); res } } impl IntoIterator for PerformanceEntryList { type Item = Root; type IntoIter = ::std::vec::IntoIter>; fn into_iter(self) -> Self::IntoIter { self.entries.into_iter() } } #[derive(HeapSizeOf, JSTraceable)] struct PerformanceObserver { observer: Root, entry_types: Vec, } #[dom_struct] pub struct Performance { reflector_: Reflector, timing: JS, entries: DOMRefCell, observers: DOMRefCell>, pending_notification_observers_task: Cell, } impl Performance { fn new_inherited(window: &Window, navigation_start: u64, navigation_start_precise: f64) -> Performance { Performance { reflector_: Reflector::new(), timing: JS::from_ref(&*PerformanceTiming::new(window, navigation_start, navigation_start_precise)), entries: DOMRefCell::new(PerformanceEntryList::new(Vec::new())), observers: DOMRefCell::new(Vec::new()), pending_notification_observers_task: Cell::new(false), } } pub fn new(window: &Window, navigation_start: u64, navigation_start_precise: f64) -> Root { reflect_dom_object(box Performance::new_inherited(window, navigation_start, navigation_start_precise), window, PerformanceBinding::Wrap) } /// Add a PerformanceObserver to the list of observers with a set of /// observed entry types. pub fn add_observer(&self, observer: &DOMPerformanceObserver, entry_types: Vec, buffered: bool) { if buffered { let entries = self.entries.borrow(); let mut new_entries = entry_types.iter() .flat_map(|e| entries.get_entries_by_name_and_type(None, Some(e.clone()))) .collect::(); let mut obs_entries = observer.entries(); obs_entries.append(&mut new_entries); observer.set_entries(obs_entries); } let mut observers = self.observers.borrow_mut(); match observers.iter().position(|o| &(*o.observer) == observer) { // If the observer is already in the list, we only update the observed // entry types. Some(p) => observers[p].entry_types = entry_types, // Otherwise, we create and insert the new PerformanceObserver. None => observers.push(PerformanceObserver { observer: Root::from_ref(observer), entry_types }) }; } /// Remove a PerformanceObserver from the list of observers. pub fn remove_observer(&self, observer: &DOMPerformanceObserver) { let mut observers = self.observers.borrow_mut(); let index = match observers.iter().position(|o| &(*o.observer) == observer) { Some(p) => p, None => return, }; observers.remove(index); } /// Queue a notification for each performance observer interested in /// this type of performance entry and queue a low priority task to /// notify the observers if no other notification task is already queued. /// /// Algorithm spec: /// https://w3c.github.io/performance-timeline/#queue-a-performanceentry /// /// XXX This should be called at some point by the User Timing, Resource /// Timing, Server Timing and Paint Timing APIs. pub fn queue_entry(&self, entry: &PerformanceEntry, add_to_performance_entries_buffer: bool) { // Steps 1-3. // Add the performance entry to the list of performance entries that have not // been notified to each performance observer owner, filtering the ones it's // interested in. for o in self.observers.borrow().iter().filter(|o| o.entry_types.contains(entry.entry_type())) { o.observer.queue_entry(entry); } // Step 4. // If the "add to performance entry buffer flag" is set, add the // new entry to the buffer. if add_to_performance_entries_buffer { self.entries.borrow_mut().entries.push(Root::from_ref(entry)); } // Step 5. // If there is already a queued notification task, we just bail out. if self.pending_notification_observers_task.get() { return; } // Step 6. // Queue a new notification task. self.pending_notification_observers_task.set(true); let global = self.global(); let window = global.as_window(); let task_source = window.performance_timeline_task_source(); task_source.queue_notification(self, window); } /// Observers notifications task. /// /// Algorithm spec (step 7): /// https://w3c.github.io/performance-timeline/#queue-a-performanceentry fn notify_observers(&self) { // Step 7.1. self.pending_notification_observers_task.set(false); // Step 7.2. // We have to operate over a copy of the performance observers to avoid // the risk of an observer's callback modifying the list of registered // observers. let observers: Vec> = self.observers.borrow().iter() .map(|o| DOMPerformanceObserver::new(&self.global(), o.observer.callback(), o.observer.entries())) .collect(); // Step 7.3. for o in observers.iter() { o.notify(); } } } pub struct NotifyPerformanceObserverRunnable { owner: Trusted, } impl NotifyPerformanceObserverRunnable { pub fn new(owner: Trusted) -> Self { NotifyPerformanceObserverRunnable { owner, } } } impl Runnable for NotifyPerformanceObserverRunnable { fn name(&self) -> &'static str { "NotifyPerformanceObserverRunnable" } fn main_thread_handler(self: Box, _: &ScriptThread) { self.owner.root().notify_observers(); } } impl PerformanceMethods for Performance { // https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/NavigationTiming/Overview.html#performance-timing-attribute fn Timing(&self) -> Root { Root::from_ref(&*self.timing) } // https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/HighResolutionTime/Overview.html#dom-performance-now fn Now(&self) -> DOMHighResTimeStamp { let nav_start = self.timing.navigation_start_precise(); let now = (time::precise_time_ns() as f64 - nav_start) / 1000000 as f64; Finite::wrap(now) } // https://www.w3.org/TR/performance-timeline-2/#dom-performance-getentries fn GetEntries(&self) -> Vec> { self.entries.borrow().get_entries_by_name_and_type(None, None) } // https://www.w3.org/TR/performance-timeline-2/#dom-performance-getentriesbytype fn GetEntriesByType(&self, entry_type: DOMString) -> Vec> { self.entries.borrow().get_entries_by_name_and_type(None, Some(entry_type)) } // https://www.w3.org/TR/performance-timeline-2/#dom-performance-getentriesbyname fn GetEntriesByName(&self, name: DOMString, entry_type: Option) -> Vec> { self.entries.borrow().get_entries_by_name_and_type(Some(name), entry_type) } }