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

refactored performance timing to align with updated spec

Browse source 
refactoring with ResourceFetchMetadata

implemented deprecated window.timing functionality

created ResourceTimingListener trait

fixed w3c links in navigation timing

updated include.ini to run resource timing tests on ci
This commit is contained in:
ddh 2018-03-12 22:24:41 +00:00
parent 3fe83f1d06
commit 26007fddd3
103 changed files with 1881 additions and 322 deletions
Download patch file Download diff file Expand all files Collapse all files

14
components/net/fetch/methods.rs
View file

@ -22,7 +22,7 @@ use mime_guess::guess_mime_type;
use net_traits::request::{CredentialsMode, Destination, Referrer, Request, RequestMode};
use net_traits::request::{Origin, ResponseTainting, Window};
use net_traits::response::{Response, ResponseBody, ResponseType};
use net_traits::{FetchTaskTarget, NetworkError, ReferrerPolicy};
use net_traits::{FetchTaskTarget, NetworkError, ReferrerPolicy, ResourceFetchTiming};
use servo_url::ServoUrl;
use std::borrow::Cow;
use std::fs::File;
@ -55,6 +55,7 @@ pub struct FetchContext {
pub devtools_chan: Option<Sender<DevtoolsControlMsg>>,
pub filemanager: FileManager,
pub cancellation_listener: Arc<Mutex<CancellationListener>>,
pub timing: Arc<Mutex<ResourceFetchTiming>>,
}
pub struct CancellationListener {
@ -503,7 +504,7 @@ fn scheme_fetch(
match url.scheme() {
"about" if url.path() == "blank" => {
let mut response = Response::new(url);
let mut response = Response::new(url, ResourceFetchTiming::new(request.timing_type()));
response
.headers
.typed_insert(ContentType::from(mime::TEXT_HTML_UTF_8));
@ -517,7 +518,8 @@ fn scheme_fetch(
"data" => match decode(&url) {
Ok((mime, bytes)) => {
let mut response = Response::new(url);
let mut response =
Response::new(url, ResourceFetchTiming::new(request.timing_type()));
*response.body.lock().unwrap() = ResponseBody::Done(bytes);
response.headers.typed_insert(ContentType::from(mime));
response
@ -537,7 +539,8 @@ fn scheme_fetch(
if let Ok(file) = File::open(file_path.clone()) {
let mime = guess_mime_type(file_path);
let mut response = Response::new(url);
let mut response =
Response::new(url, ResourceFetchTiming::new(request.timing_type()));
response.headers.typed_insert(ContentType::from(mime));
let (done_sender, done_receiver) = unbounded();
@ -656,7 +659,8 @@ fn scheme_fetch(
match load_blob_sync(url.clone(), context.filemanager.clone()) {
Ok((headers, bytes)) => {
let mut response = Response::new(url);
let mut response =
Response::new(url, ResourceFetchTiming::new(request.timing_type()));
response.headers = headers;
*response.body.lock().unwrap() = ResponseBody::Done(bytes);
response

15
components/net/http_cache.rs
View file

@ -20,7 +20,7 @@ use malloc_size_of::{
};
use net_traits::request::Request;
use net_traits::response::{HttpsState, Response, ResponseBody};
use net_traits::{FetchMetadata, Metadata};
use net_traits::{FetchMetadata, Metadata, ResourceFetchTiming};
use servo_arc::Arc;
use servo_config::prefs::PREFS;
use servo_url::ServoUrl;
@ -302,7 +302,11 @@ fn create_cached_response(
cached_headers: &HeaderMap,
done_chan: &mut DoneChannel,
) -> CachedResponse {
let mut response = Response::new(cached_resource.data.metadata.data.final_url.clone());
let resource_timing = ResourceFetchTiming::new(request.timing_type());
let mut response = Response::new(
cached_resource.data.metadata.data.final_url.clone(),
resource_timing,
);
response.headers = cached_headers.clone();
response.body = cached_resource.body.clone();
if let ResponseBody::Receiving(_) = *cached_resource.body.lock().unwrap() {
@ -687,8 +691,11 @@ impl HttpCache {
// Received a response with 304 status code, in response to a request that matches a cached resource.
// 1. update the headers of the cached resource.
// 2. return a response, constructed from the cached resource.
let mut constructed_response =
Response::new(cached_resource.data.metadata.data.final_url.clone());
let resource_timing = ResourceFetchTiming::new(request.timing_type());
let mut constructed_response = Response::new(
cached_resource.data.metadata.data.final_url.clone(),
resource_timing,
);
constructed_response.body = cached_resource.body.clone();
constructed_response.status = cached_resource.data.status.clone();
constructed_response.https_state = cached_resource.data.https_state.clone();

47
components/net/http_loader.rs
View file

@ -43,6 +43,7 @@ use net_traits::request::{CacheMode, CredentialsMode, Destination, Origin};
use net_traits::request::{RedirectMode, Referrer, Request, RequestMode};
use net_traits::request::{ResponseTainting, ServiceWorkersMode};
use net_traits::response::{HttpsState, Response, ResponseBody, ResponseType};
use net_traits::ResourceAttribute;
use net_traits::{CookieSource, FetchMetadata, NetworkError, ReferrerPolicy};
use openssl::ssl::SslConnectorBuilder;
use servo_url::{ImmutableOrigin, ServoUrl};
@ -408,14 +409,8 @@ fn obtain_response(
},
}
if log_enabled!(log::Level::Info) {
info!("{} {}", method, url);
for header in headers.iter() {
info!(" - {:?}", header);
}
info!("{:?}", data);
}
// TODO(#21261) connect_start: set if a persistent connection is *not* used and the last non-redirected
// fetch passes the timing allow check
let connect_start = precise_time_ms();
// https://url.spec.whatwg.org/#percent-encoded-bytes
let request = HyperRequest::builder()
@ -435,6 +430,8 @@ fn obtain_response(
Err(e) => return Box::new(future::result(Err(NetworkError::from_http_error(&e)))),
};
*request.headers_mut() = headers.clone();
//TODO(#21262) connect_end
let connect_end = precise_time_ms();
let request_id = request_id.map(|v| v.to_owned());
@ -449,6 +446,8 @@ fn obtain_response(
.and_then(move |res| {
let send_end = precise_time_ms();
// TODO(#21271) response_start: immediately after receiving first byte of response
let msg = if let Some(request_id) = request_id {
if let Some(pipeline_id) = pipeline_id {
Some(prepare_devtools_request(
@ -483,6 +482,7 @@ fn obtain_response(
})
.map_err(move |e| NetworkError::from_hyper_error(&e)),
)
// TODO(#21263) response_end (also needs to be set above if fetch is aborted due to an error)
}
/// [HTTP fetch](https://fetch.spec.whatwg.org#http-fetch)
@ -571,6 +571,19 @@ pub fn http_fetch(
}
// Substep 3
// TODO(#21258) maybe set fetch_start (if this is the last resource)
// Generally, we use a persistent connection, so we will also set other PerformanceResourceTiming
// attributes to this as well (domain_lookup_start, domain_lookup_end, connect_start, connect_end,
// secure_connection_start)
// TODO(#21256) maybe set redirect_start if this resource initiates the redirect
// TODO(#21254) also set startTime equal to either fetch_start or redirect_start
// (https://w3c.github.io/resource-timing/#dfn-starttime)
context
.timing
.lock()
.unwrap()
.set_attribute(ResourceAttribute::RequestStart);
let mut fetch_result = http_network_or_cache_fetch(
request,
authentication_fetch_flag,
@ -640,8 +653,22 @@ pub fn http_fetch(
},
};
}
// TODO redirect_end: last byte of response of last redirect
// set back to default
response.return_internal = true;
context
.timing
.lock()
.unwrap()
.set_attribute(ResourceAttribute::RedirectCount(
request.redirect_count as u16,
));
let timing = &*context.timing.lock().unwrap();
response.resource_timing = timing.clone();
// Step 6
response
}
@ -1199,7 +1226,8 @@ fn http_network_fetch(
}
}
let mut response = Response::new(url.clone());
let timing = &*context.timing.lock().unwrap();
let mut response = Response::new(url.clone(), timing.clone());
response.status = Some((
res.status(),
res.status().canonical_reason().unwrap_or("").into(),
@ -1224,6 +1252,7 @@ fn http_network_fetch(
FetchMetadata::Unfiltered(m) => m,
FetchMetadata::Filtered { unsafe_, .. } => unsafe_,
};
let devtools_sender = context.devtools_chan.clone();
let meta_status = meta.status.clone();
let meta_headers = meta.headers.clone();

4
components/net/image_cache.rs
View file

@ -503,11 +503,11 @@ impl ImageCache for ImageCacheImpl {
(FetchResponseMsg::ProcessResponseEOF(result), key) => {
debug!("Received EOF for {:?}", key);
match result {
Ok(()) => {
Ok(_) => {
let bytes = {
let mut store = self.store.lock().unwrap();
let pending_load = store.pending_loads.get_by_key_mut(&id).unwrap();
pending_load.result = Some(result);
pending_load.result = Some(Ok(()));
debug!("Async decoding {} ({:?})", pending_load.url, key);
pending_load.bytes.mark_complete()
};

15
components/net/resource_thread.rs
View file

@ -22,13 +22,14 @@ use embedder_traits::EmbedderProxy;
use hyper_serde::Serde;
use ipc_channel::ipc::{self, IpcReceiver, IpcReceiverSet, IpcSender};
use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
use net_traits::request::{Request, RequestInit};
use net_traits::request::{Destination, Request, RequestInit};
use net_traits::response::{Response, ResponseInit};
use net_traits::storage_thread::StorageThreadMsg;
use net_traits::WebSocketNetworkEvent;
use net_traits::{CookieSource, CoreResourceThread};
use net_traits::{CoreResourceMsg, CustomResponseMediator, FetchChannels};
use net_traits::{CookieSource, CoreResourceMsg, CoreResourceThread};
use net_traits::{CustomResponseMediator, FetchChannels};
use net_traits::{FetchResponseMsg, ResourceThreads, WebSocketDomAction};
use net_traits::{ResourceFetchTiming, ResourceTimingType};
use profile_traits::mem::ProfilerChan as MemProfilerChan;
use profile_traits::mem::{Report, ReportKind, ReportsChan};
use profile_traits::time::ProfilerChan;
@ -440,6 +441,11 @@ impl CoreResourceManager {
let dc = self.devtools_chan.clone();
let filemanager = self.filemanager.clone();
let timing_type = match req_init.destination {
Destination::Document => ResourceTimingType::Navigation,
_ => ResourceTimingType::Resource,
};
thread::Builder::new()
.name(format!("fetch thread for {}", req_init.url))
.spawn(move || {
@ -456,11 +462,12 @@ impl CoreResourceManager {
cancellation_listener: Arc::new(Mutex::new(CancellationListener::new(
cancel_chan,
))),
timing: Arc::new(Mutex::new(ResourceFetchTiming::new(request.timing_type()))),
};
match res_init_ {
Some(res_init) => {
let response = Response::from_init(res_init);
let response = Response::from_init(res_init, timing_type);
http_redirect_fetch(
&mut request,
&mut CorsCache::new(),

17
components/net/tests/fetch.rs
View file

@ -35,9 +35,9 @@ use net::hsts::HstsEntry;
use net::test::HttpState;
use net_traits::request::{Destination, Origin, RedirectMode, Referrer, Request, RequestMode};
use net_traits::response::{CacheState, Response, ResponseBody, ResponseType};
use net_traits::IncludeSubdomains;
use net_traits::NetworkError;
use net_traits::ReferrerPolicy;
use net_traits::{
IncludeSubdomains, NetworkError, ReferrerPolicy, ResourceFetchTiming, ResourceTimingType,
};
use servo_url::{ImmutableOrigin, ServoUrl};
use std::fs::File;
use std::io::Read;
@ -127,7 +127,7 @@ fn test_fetch_blob() {
use ipc_channel::ipc;
use net_traits::blob_url_store::BlobBuf;
let context = new_fetch_context(None, None);
let mut context = new_fetch_context(None, None);
let bytes = b"content";
let blob_buf = BlobBuf {
@ -147,7 +147,7 @@ fn test_fetch_blob() {
let url = ServoUrl::parse(&format!("blob:{}{}", origin.as_str(), id.to_simple())).unwrap();
let mut request = Request::new(url, Some(Origin::Origin(origin.origin())), None);
let fetch_response = fetch_with_context(&mut request, &context);
let fetch_response = fetch_with_context(&mut request, &mut context);
assert!(!fetch_response.is_network_error());
@ -649,12 +649,15 @@ fn test_fetch_with_hsts() {
.unwrap();
let ssl_client = create_ssl_connector_builder(&ca_content);
let context = FetchContext {
let mut context = FetchContext {
state: Arc::new(HttpState::new(ssl_client)),
user_agent: DEFAULT_USER_AGENT.into(),
devtools_chan: None,
filemanager: FileManager::new(create_embedder_proxy()),
cancellation_listener: Arc::new(Mutex::new(CancellationListener::new(None))),
timing: Arc::new(Mutex::new(ResourceFetchTiming::new(
ResourceTimingType::Navigation,
))),
};
{
@ -668,7 +671,7 @@ fn test_fetch_with_hsts() {
request.referrer = Referrer::NoReferrer;
// Set the flag.
request.local_urls_only = false;
let response = fetch_with_context(&mut request, &context);
let response = fetch_with_context(&mut request, &mut context);
server.close();
assert_eq!(
response.internal_response.unwrap().url().unwrap().scheme(),

32
components/net/tests/http_loader.rs
View file

@ -587,8 +587,8 @@ fn test_load_doesnt_add_host_to_sts_list_when_url_is_http_even_if_sts_headers_ar
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let context = new_fetch_context(None, None);
let response = fetch_with_context(&mut request, &context);
let mut context = new_fetch_context(None, None);
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -623,7 +623,7 @@ fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_
};
let (server, url) = make_server(handler);
let context = new_fetch_context(None, None);
let mut context = new_fetch_context(None, None);
assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
@ -637,7 +637,7 @@ fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &context);
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -669,7 +669,7 @@ fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_re
};
let (server, url) = make_server(handler);
let context = new_fetch_context(None, None);
let mut context = new_fetch_context(None, None);
{
let mut cookie_jar = context.state.cookie_jar.write().unwrap();
@ -692,7 +692,7 @@ fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_re
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &context);
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -718,7 +718,7 @@ fn test_load_sends_cookie_if_nonhttp() {
};
let (server, url) = make_server(handler);
let context = new_fetch_context(None, None);
let mut context = new_fetch_context(None, None);
{
let mut cookie_jar = context.state.cookie_jar.write().unwrap();
@ -741,7 +741,7 @@ fn test_load_sends_cookie_if_nonhttp() {
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &context);
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -767,7 +767,7 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl(
};
let (server, url) = make_server(handler);
let context = new_fetch_context(None, None);
let mut context = new_fetch_context(None, None);
assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
@ -781,7 +781,7 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl(
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &context);
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -819,7 +819,7 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() {
};
let (server, url) = make_server(handler);
let context = new_fetch_context(None, None);
let mut context = new_fetch_context(None, None);
assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
@ -833,7 +833,7 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() {
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &context);
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -1242,7 +1242,7 @@ fn test_redirect_from_x_to_y_provides_y_cookies_from_y() {
let url_y = ServoUrl::parse(&format!("http://mozilla.org:{}/org/", port)).unwrap();
*shared_url_y_clone.lock().unwrap() = Some(url_y.clone());
let context = new_fetch_context(None, None);
let mut context = new_fetch_context(None, None);
{
let mut cookie_jar = context.state.cookie_jar.write().unwrap();
let cookie_x = Cookie::new_wrapped(
@ -1272,7 +1272,7 @@ fn test_redirect_from_x_to_y_provides_y_cookies_from_y() {
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &context);
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -1355,7 +1355,7 @@ fn test_if_auth_creds_not_in_url_but_in_cache_it_sets_it() {
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let context = new_fetch_context(None, None);
let mut context = new_fetch_context(None, None);
let auth_entry = AuthCacheEntry {
user_name: "username".to_owned(),
@ -1370,7 +1370,7 @@ fn test_if_auth_creds_not_in_url_but_in_cache_it_sets_it() {
.entries
.insert(url.origin().clone().ascii_serialization(), auth_entry);
let response = fetch_with_context(&mut request, &context);
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();

18
components/net/tests/main.rs
View file

@ -35,7 +35,7 @@ use net::filemanager_thread::FileManager;
use net::test::HttpState;
use net_traits::request::Request;
use net_traits::response::Response;
use net_traits::FetchTaskTarget;
use net_traits::{FetchTaskTarget, ResourceFetchTiming, ResourceTimingType};
use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
use servo_url::ServoUrl;
use std::net::TcpListener as StdTcpListener;
@ -93,6 +93,9 @@ fn new_fetch_context(
devtools_chan: dc,
filemanager: FileManager::new(sender),
cancellation_listener: Arc::new(Mutex::new(CancellationListener::new(None))),
timing: Arc::new(Mutex::new(ResourceFetchTiming::new(
ResourceTimingType::Navigation,
))),
}
}
impl FetchTaskTarget for FetchResponseCollector {
@ -107,14 +110,14 @@ impl FetchTaskTarget for FetchResponseCollector {
}
fn fetch(request: &mut Request, dc: Option<Sender<DevtoolsControlMsg>>) -> Response {
fetch_with_context(request, &new_fetch_context(dc, None))
fetch_with_context(request, &mut new_fetch_context(dc, None))
}
fn fetch_with_context(request: &mut Request, context: &FetchContext) -> Response {
fn fetch_with_context(request: &mut Request, mut context: &mut FetchContext) -> Response {
let (sender, receiver) = unbounded();
let mut target = FetchResponseCollector { sender: sender };
methods::fetch(request, &mut target, context);
methods::fetch(request, &mut target, &mut context);
receiver.recv().unwrap()
}
@ -123,7 +126,12 @@ fn fetch_with_cors_cache(request: &mut Request, cache: &mut CorsCache) -> Respon
let (sender, receiver) = unbounded();
let mut target = FetchResponseCollector { sender: sender };
methods::fetch_with_cors_cache(request, cache, &mut target, &new_fetch_context(None, None));
methods::fetch_with_cors_cache(
request,
cache,
&mut target,
&mut new_fetch_context(None, None),
);
receiver.recv().unwrap()
}

11
components/net/tests/subresource_integrity.rs
View file

@ -5,6 +5,7 @@
use net::subresource_integrity::{get_prioritized_hash_function, get_strongest_metadata, SriEntry};
use net::subresource_integrity::{is_response_integrity_valid, parsed_metadata};
use net_traits::response::{Response, ResponseBody};
use net_traits::{ResourceFetchTiming, ResourceTimingType};
use servo_url::ServoUrl;
#[test]
@ -70,7 +71,10 @@ fn test_get_strongest_metadata_different_algorithm() {
#[test]
fn test_response_integrity_valid() {
let url: ServoUrl = ServoUrl::parse("http://servo.org").unwrap();
let response: Response = Response::new(url);
let response: Response = Response::new(
url,
ResourceFetchTiming::new(ResourceTimingType::Navigation),
);
let integrity_metadata =
"sha384-H8BRh8j48O9oYatfu5AZzq6A9RINhZO5H16dQZngK7T62em8MUt1FLm52t+eX6xO";
@ -83,7 +87,10 @@ fn test_response_integrity_valid() {
#[test]
fn test_response_integrity_invalid() {
let url: ServoUrl = ServoUrl::parse("http://servo.org").unwrap();
let response: Response = Response::new(url);
let response: Response = Response::new(
url,
ResourceFetchTiming::new(ResourceTimingType::Navigation),
);
let integrity_metadata =
"sha256-H8BRh8j48O9oYatfu5AZzq6A9RINhZO5H16dQZngK7T62em8MUt1FLm52t+eX6xO";