PerformanceResourceTiming: responseEnd

[avadacatavra]

On getting, the responseEnd attribute MUST return as follows:

1. The time immediately after the user agent receives the last byte of the response or immediately before the transport connection is closed, whichever comes first. The resource here can be received either from relevant application caches, local resources, or from the server.
2. The time immediately before the user agent aborts the fetch due to a network error.

Spec: https://w3c.github.io/resource-timing/#dom-performanceresourcetiming-responseend

[jdm]

servo/components/net/http_loader.rs

Lines 1284 to 1302 in 481662d

	.and_then(move |res_body| {
	let mut body = res_body.lock().unwrap();
	let completed_body = match *body {
	ResponseBody::Receiving(ref mut body) => mem::replace(body, vec![]),
	_ => vec![],
	};
	*body = ResponseBody::Done(completed_body);
	let _ = done_sender2.send(Data::Done);
	future::ok(())
	})
	.map_err(move |_| {
	let mut body = res_body2.lock().unwrap();
	let completed_body = match *body {
	ResponseBody::Receiving(ref mut body) => mem::replace(body, vec![]),
	_ => vec![],
	};
	*body = ResponseBody::Done(completed_body);
	let _ = done_sender3.send(Data::Done);
	}),

are two blocks of code that would need to set this attribute in the ResourceFetchTiming structure.

[vn-ki]

@jdm Which file(s) should I be looking at for this issue?

I would assume the above linked files have to be changed, but I docs.servo.org/servo is crashing on me and I can't find ResourceFetchTiming structure.

Is there any other way to access the docs?

[CYBAI]

Is there any other way to access the docs?

https://doc.servo.org/servo/index.html

[jdm]

You could try running cargo doc --open and see if that makes a difference.

[jdm]

Other files necessary:

• https://github.com/servo/servo/blob/master/components/net_traits/lib.rs#L444
• https://github.com/servo/servo/blob/master/components/script/dom/performanceresourcetiming.rs
• https://github.com/servo/servo/blob/master/components/script/dom/webidls/PerformanceResourceTiming.webidl

[jiachengpizza]

Hi @jdm ,
I'm learning Rust and servo code starting from this issue. I think the responseEnd timing value should be set after Line 1290 and Line 1300, after ResponseBody::Done(). Is that right?
Thanks.

[jdm]

Sorry for the delay; I was on vacation. Yes, that sounds right to me.

[tdelacour]

@highfive assign me

[highfive]

Hey @tdelacour! Thanks for your interest in working on this issue. It's now assigned to you!

[tdelacour]

Hi @jdm (or whoever can help!) I've added a couple of statements inside the spawn() closure in http_loader.rs and it now looks like this:

HANDLE.lock().unwrap().spawn(
        res.into_body()
            .map_err(|_| ())
            .fold(res_body, move |res_body, chunk| {
                if cancellation_listener.lock().unwrap().cancelled() {
                    *res_body.lock().unwrap() = ResponseBody::Done(vec![]);
                    let _ = done_sender.send(Data::Cancelled);
                    return future::failed(());
                }
                if let ResponseBody::Receiving(ref mut body) = *res_body.lock().unwrap() {
                    let bytes = chunk.into_bytes();
                    body.extend_from_slice(&*bytes);
                    let _ = done_sender.send(Data::Payload(bytes.to_vec()));
                }
                future::ok(res_body)
            })
            .and_then(move |res_body| {
                let mut body = res_body.lock().unwrap();
                let completed_body = match *body {
                    ResponseBody::Receiving(ref mut body) => mem::replace(body, vec![]),
                    _ => vec![],
                };
                *body = ResponseBody::Done(completed_body);
                context // <-------------- ADDED
                    .timing
                    .lock()
                    .unwrap()
                    .set_attribute(ResourceAttribute::ResponseEnd);
                let _ = done_sender2.send(Data::Done);
                future::ok(())
            })
            .map_err(move |_| {
                let mut body = res_body2.lock().unwrap();
                let completed_body = match *body {
                    ResponseBody::Receiving(ref mut body) => mem::replace(body, vec![]),
                    _ => vec![],
                };
                *body = ResponseBody::Done(completed_body);
                context // <-------------- ADDED
                    .timing
                    .lock()
                    .unwrap()
                    .set_attribute(ResourceAttribute::ResponseEnd);
                let _ = done_sender3.send(Data::Done);
            }),
    );

But this causes a compiler error:

error[E0277]: `(dyn embedder_traits::EventLoopWaker + 'static)` cannot be shared between threads safely
    --> components/net/http_loader.rs:1278:28
     |
1278 |     HANDLE.lock().unwrap().spawn(
     |                            ^^^^^ `(dyn embedder_traits::EventLoopWaker + 'static)` cannot be shared between threads safely
     |

I think I understand, broadly, what the issue is: I'm referencing context within a new thread, but context is not threadsafe. I was able to get past the compiler by making mutable clones of the ResourceFetchTiming struct inside context and using those inside the closure, but that doesn't seem like it would accomplish... anything (the updated timing structs wouldn't be accessible anywhere outside of the closure in the spawned thread, right?)

As you can probably tell, I'm very new to Rust. I'm reading up on closures, moves, concurrency, send / sync, etc in the Rust book, but I could definitely use some more targeted help 😬

[jdm]

If you make a clone of context.timing outside of the closure and refer to that clone inside of it, you should be able to achieve your goal. That avoids sharing the whole context, and the timing information is already stored in an Arc wrapper (I believe), so cloning it does not actually duplicate it.

[tdelacour]

amazing, thank you!