Add timeline markers for HTTP requests, JS evaluation, and HTML parsing.

components/net/Cargo.toml

@@ -27,6 +27,7 @@ net_traits = {path = "../net_traits"}
 openssl = "0.7.6"
 openssl-verify = "0.1"
 plugins = {path = "../plugins"}
+profile_traits = {path = "../profile_traits"}
 rustc-serialize = "0.3"
 threadpool = "1.0"
 time = "0.1.17"

components/net/http_loader.rs

@@ -31,6 +31,8 @@ use net_traits::response::HttpsState;
 use net_traits::{CookieSource, IncludeSubdomains, LoadConsumer, LoadContext, LoadData};
 use net_traits::{Metadata, NetworkError};
 use openssl::ssl::error::{SslError, OpensslError};
+use profile_traits::time::{ProfilerCategory, profile, ProfilerChan, TimerMetadata};
+use profile_traits::time::{TimerMetadataReflowType, TimerMetadataFrameType};
 use resource_thread::{CancellationListener, send_error, start_sending_sniffed_opt, AuthCache, AuthCacheEntry};
 use std::borrow::ToOwned;
 use std::boxed::FnBox;
@@ -52,6 +54,7 @@ use uuid;
 pub fn factory(user_agent: String,
                http_state: HttpState,
                devtools_chan: Option<Sender<DevtoolsControlMsg>>,
+               profiler_chan: ProfilerChan,
                connector: Arc<Pool<Connector>>)
                -> Box<FnBox(LoadData,
                             LoadConsumer,
@@ -59,14 +62,21 @@ pub fn factory(user_agent: String,
                             CancellationListener) + Send> {
     box move |load_data: LoadData, senders, classifier, cancel_listener| {
         spawn_named(format!("http_loader for {}", load_data.url), move || {
-            load_for_consumer(load_data,
-                              senders,
-                              classifier,
-                              connector,
-                              http_state,
-                              devtools_chan,
-                              cancel_listener,
-                              user_agent)
+            let metadata = TimerMetadata {
+                url: load_data.url.as_str().into(),
+                iframe: TimerMetadataFrameType::RootWindow,
+                incremental: TimerMetadataReflowType::FirstReflow,
+            };
+            profile(ProfilerCategory::NetHTTPRequestResponse, Some(metadata), profiler_chan, || {
+                load_for_consumer(load_data,
+                                  senders,
+                                  classifier,
+                                  connector,
+                                  http_state,
+                                  devtools_chan,
+                                  cancel_listener,
+                                  user_agent)
+            })
         })
     }
 }

components/net/lib.rs

@@ -31,6 +31,7 @@ extern crate msg;
 extern crate net_traits;
 extern crate openssl;
 extern crate openssl_verify;
+extern crate profile_traits;
 extern crate rustc_serialize;
 extern crate threadpool;
 extern crate time;

components/net/resource_thread.rs

@@ -23,6 +23,7 @@ use net_traits::ProgressMsg::Done;
 use net_traits::{AsyncResponseTarget, Metadata, ProgressMsg, ResourceThread, ResponseAction};
 use net_traits::{ControlMsg, CookieSource, LoadConsumer, LoadData, LoadResponse, ResourceId};
 use net_traits::{NetworkError, WebSocketCommunicate, WebSocketConnectData};
+use profile_traits::time::ProfilerChan;
 use rustc_serialize::json;
 use rustc_serialize::{Decodable, Encodable};
 use std::borrow::ToOwned;
@@ -150,13 +151,14 @@ fn start_sending_opt(start_chan: LoadConsumer, metadata: Metadata,
 
 /// Create a ResourceThread
 pub fn new_resource_thread(user_agent: String,
-                           devtools_chan: Option<Sender<DevtoolsControlMsg>>) -> ResourceThread {
+                           devtools_chan: Option<Sender<DevtoolsControlMsg>>,
+                           profiler_chan: ProfilerChan) -> ResourceThread {
     let hsts_preload = HstsList::from_servo_preload();
     let (setup_chan, setup_port) = ipc::channel().unwrap();
     let setup_chan_clone = setup_chan.clone();
     spawn_named("ResourceManager".to_owned(), move || {
         let resource_manager = ResourceManager::new(
-            user_agent, hsts_preload, devtools_chan
+            user_agent, hsts_preload, devtools_chan, profiler_chan
         );
 
         let mut channel_manager = ResourceChannelManager {
@@ -364,6 +366,7 @@ pub struct ResourceManager {
     auth_cache: Arc<RwLock<AuthCache>>,
     mime_classifier: Arc<MIMEClassifier>,
     devtools_chan: Option<Sender<DevtoolsControlMsg>>,
+    profiler_chan: ProfilerChan,
     hsts_list: Arc<RwLock<HstsList>>,
     connector: Arc<Pool<Connector>>,
     cancel_load_map: HashMap<ResourceId, Sender<()>>,
@@ -373,7 +376,8 @@ pub struct ResourceManager {
 impl ResourceManager {
     pub fn new(user_agent: String,
                mut hsts_list: HstsList,
-               devtools_channel: Option<Sender<DevtoolsControlMsg>>) -> ResourceManager {
+               devtools_channel: Option<Sender<DevtoolsControlMsg>>,
+               profiler_chan: ProfilerChan) -> ResourceManager {
         let mut auth_cache = AuthCache::new();
         let mut cookie_jar = CookieStorage::new();
         if let Some(ref profile_dir) = opts::get().profile_dir {
@@ -387,6 +391,7 @@ impl ResourceManager {
             auth_cache: Arc::new(RwLock::new(auth_cache)),
             mime_classifier: Arc::new(MIMEClassifier::new()),
             devtools_chan: devtools_channel,
+            profiler_chan: profiler_chan,
             hsts_list: Arc::new(RwLock::new(hsts_list)),
             connector: create_http_connector(),
             cancel_load_map: HashMap::new(),
@@ -445,6 +450,7 @@ impl ResourceManager {
                 http_loader::factory(self.user_agent.clone(),
                                      http_state,
                                      self.devtools_chan.clone(),
+                                     self.profiler_chan.clone(),
                                      self.connector.clone())
             },
             "data" => from_factory(data_loader::factory),