Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Implementing the builder pattern for RequestInit

Browse source
This commit is contained in:
Lucas Fantacuci 2018-12-21 17:38:22 -02:00 • committed by Lucas Sanches Fantacuci
parent dd2deeabca
commit 6b2be9b31d
27 changed files with 578 additions and 546 deletions
Download patch file Download diff file Expand all files Collapse all files

6
components/constellation/constellation.rs
View file

@ -130,7 +130,7 @@ use msg::constellation_msg::{
};
use msg::constellation_msg::{PipelineNamespace, PipelineNamespaceId, TraversalDirection};
use net_traits::pub_domains::reg_host;
use net_traits::request::RequestInit;
use net_traits::request::RequestBuilder;
use net_traits::storage_thread::{StorageThreadMsg, StorageType};
use net_traits::{self, FetchResponseMsg, IpcSend, ResourceThreads};
use profile_traits::mem;
@ -1934,11 +1934,11 @@ where
fn handle_navigate_request(
&self,
id: PipelineId,
req_init: RequestInit,
request_builder: RequestBuilder,
cancel_chan: IpcReceiver<()>,
) {
let listener = NetworkListener::new(
req_init,
request_builder,
id,
self.public_resource_threads.clone(),
self.network_listener_sender.clone(),

32
components/constellation/network_listener.rs
View file

@ -12,14 +12,14 @@ use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use msg::constellation_msg::PipelineId;
use net::http_loader::{set_default_accept, set_default_accept_language};
use net_traits::request::{Destination, RequestInit};
use net_traits::request::{Destination, RequestBuilder};
use net_traits::response::ResponseInit;
use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseMsg};
use net_traits::{IpcSend, NetworkError, ResourceThreads};
pub struct NetworkListener {
res_init: Option<ResponseInit>,
req_init: RequestInit,
request_builder: RequestBuilder,
pipeline_id: PipelineId,
resource_threads: ResourceThreads,
sender: Sender<(PipelineId, FetchResponseMsg)>,
@ -28,14 +28,14 @@ pub struct NetworkListener {
impl NetworkListener {
pub fn new(
req_init: RequestInit,
request_builder: RequestBuilder,
pipeline_id: PipelineId,
resource_threads: ResourceThreads,
sender: Sender<(PipelineId, FetchResponseMsg)>,
) -> NetworkListener {
NetworkListener {
res_init: None,
req_init,
request_builder,
pipeline_id,
resource_threads,
sender,
@ -48,7 +48,7 @@ impl NetworkListener {
let mut listener = NetworkListener {
res_init: self.res_init.clone(),
req_init: self.req_init.clone(),
request_builder: self.request_builder.clone(),
resource_threads: self.resource_threads.clone(),
sender: self.sender.clone(),
pipeline_id: self.pipeline_id.clone(),
@ -57,17 +57,17 @@ impl NetworkListener {
let msg = match self.res_init {
Some(ref res_init_) => CoreResourceMsg::FetchRedirect(
self.req_init.clone(),
self.request_builder.clone(),
res_init_.clone(),
ipc_sender,
None,
),
None => {
set_default_accept(Destination::Document, &mut listener.req_init.headers);
set_default_accept_language(&mut listener.req_init.headers);
set_default_accept(Destination::Document, &mut listener.request_builder.headers);
set_default_accept_language(&mut listener.request_builder.headers);
CoreResourceMsg::Fetch(
listener.req_init.clone(),
listener.request_builder.clone(),
FetchChannels::ResponseMsg(ipc_sender, cancel_chan),
)
},
@ -100,13 +100,17 @@ impl NetworkListener {
match metadata.headers {
Some(ref headers) if headers.contains_key(LOCATION) => {
if self.req_init.url_list.is_empty() {
self.req_init.url_list.push(self.req_init.url.clone());
if self.request_builder.url_list.is_empty() {
self.request_builder
.url_list
.push(self.request_builder.url.clone());
}
self.req_init.url_list.push(metadata.final_url.clone());
self.request_builder
.url_list
.push(metadata.final_url.clone());
self.req_init.referrer_url = metadata.referrer.clone();
self.req_init.referrer_policy = metadata.referrer_policy;
self.request_builder.referrer_url = metadata.referrer.clone();
self.request_builder.referrer_policy = metadata.referrer_policy;
self.res_init = Some(ResponseInit {
url: metadata.final_url.clone(),

10
components/gfx/font_cache_thread.rs
View file

@ -13,7 +13,7 @@ use crate::platform::font_list::SANS_SERIF_FONT_FAMILY;
use crate::platform::font_template::FontTemplateData;
use app_units::Au;
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use net_traits::request::{Destination, RequestInit};
use net_traits::request::{Destination, RequestBuilder};
use net_traits::{fetch_async, CoreResourceThread, FetchResponseMsg};
use servo_atoms::Atom;
use servo_url::ServoUrl;
@ -238,13 +238,7 @@ impl FontCache {
None => return,
};
let request = RequestInit {
url: url.clone(),
destination: Destination::Font,
// TODO: Add a proper origin - Can't import GlobalScope from gfx
// We can leave origin to be set by default
..RequestInit::default()
};
let request = RequestBuilder::new(url.clone()).destination(Destination::Font);
let channel_to_self = self.channel_to_self.clone();
let bytes = Mutex::new(Vec::new());

12
components/net/resource_thread.rs
View file

@ -22,7 +22,7 @@ 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::{Destination, Request, RequestInit};
use net_traits::request::{Destination, RequestBuilder};
use net_traits::response::{Response, ResponseInit};
use net_traits::storage_thread::StorageThreadMsg;
use net_traits::WebSocketNetworkEvent;
@ -430,7 +430,7 @@ impl CoreResourceManager {
fn fetch(
&self,
req_init: RequestInit,
request_builder: RequestBuilder,
res_init_: Option<ResponseInit>,
mut sender: IpcSender<FetchResponseMsg>,
http_state: &Arc<HttpState>,
@ -441,15 +441,15 @@ impl CoreResourceManager {
let dc = self.devtools_chan.clone();
let filemanager = self.filemanager.clone();
let timing_type = match req_init.destination {
let timing_type = match request_builder.destination {
Destination::Document => ResourceTimingType::Navigation,
_ => ResourceTimingType::Resource,
};
thread::Builder::new()
.name(format!("fetch thread for {}", req_init.url))
.name(format!("fetch thread for {}", request_builder.url))
.spawn(move || {
let mut request = Request::from_init(req_init);
let mut request = request_builder.build();
// XXXManishearth: Check origin against pipeline id (also ensure that the mode is allowed)
// todo load context / mimesniff in fetch
// todo referrer policy?
@ -486,7 +486,7 @@ impl CoreResourceManager {
fn websocket_connect(
&self,
request: RequestInit,
request: RequestBuilder,
event_sender: IpcSender<WebSocketNetworkEvent>,
action_receiver: IpcReceiver<WebSocketDomAction>,
http_state: &Arc<HttpState>,

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

@ -29,7 +29,7 @@ use net::cookie::Cookie;
use net::cookie_storage::CookieStorage;
use net::resource_thread::AuthCacheEntry;
use net::test::replace_host_table;
use net_traits::request::{CredentialsMode, Destination, Request, RequestInit, RequestMode};
use net_traits::request::{CredentialsMode, Destination, RequestBuilder, RequestMode};
use net_traits::response::ResponseBody;
use net_traits::{CookieSource, NetworkError};
use servo_url::{ImmutableOrigin, ServoUrl};
@ -135,14 +135,13 @@ fn test_check_default_headers_loaded_in_every_request() {
*expected_headers.lock().unwrap() = Some(headers.clone());
// Testing for method.GET
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
destination: Destination::Document,
origin: url.clone().origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(url.clone().origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
assert!(response
.internal_response
@ -163,14 +162,13 @@ fn test_check_default_headers_loaded_in_every_request() {
HeaderValue::from_str(&url_str[..url_str.len() - 1]).unwrap(),
);
*expected_headers.lock().unwrap() = Some(post_headers);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::POST,
destination: Destination::Document,
origin: url.clone().origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::POST)
.destination(Destination::Document)
.origin(url.clone().origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
assert!(response
.internal_response
@ -194,15 +192,14 @@ fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::POST,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::POST)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
assert!(response
.internal_response
@ -227,16 +224,15 @@ fn test_request_and_response_data_with_network_messages() {
let mut request_headers = HeaderMap::new();
request_headers.typed_insert(Host::from("bar.foo".parse::<Authority>().unwrap()));
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
headers: request_headers,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.headers(request_headers)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let (devtools_chan, devtools_port) = unbounded();
let response = fetch(&mut request, Some(devtools_chan));
assert!(response
@ -328,14 +324,13 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() {
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: None,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(None)
.build();
let (devtools_chan, devtools_port) = unbounded();
let response = fetch(&mut request, Some(devtools_chan));
assert!(response
@ -371,13 +366,12 @@ fn test_redirected_request_to_devtools() {
};
let (pre_server, pre_url) = make_server(pre_handler);
let mut request = Request::from_init(RequestInit {
url: pre_url.clone(),
method: Method::POST,
destination: Destination::Document,
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(pre_url.clone())
.method(Method::POST)
.destination(Destination::Document)
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let (devtools_chan, devtools_port) = unbounded();
fetch(&mut request, Some(devtools_chan));
@ -421,14 +415,13 @@ fn test_load_when_redirecting_from_a_post_should_rewrite_next_request_as_get() {
};
let (pre_server, pre_url) = make_server(pre_handler);
let mut request = Request::from_init(RequestInit {
url: pre_url.clone(),
method: Method::POST,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(pre_url.clone())
.method(Method::POST)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = pre_server.close();
@ -452,15 +445,14 @@ fn test_load_should_decode_the_response_as_deflate_when_response_headers_have_co
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server.close();
@ -486,15 +478,14 @@ fn test_load_should_decode_the_response_as_gzip_when_response_headers_have_conte
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server.close();
@ -539,15 +530,14 @@ fn test_load_doesnt_send_request_body_on_any_redirect() {
};
let (pre_server, pre_url) = make_server(pre_handler);
let mut request = Request::from_init(RequestInit {
url: pre_url.clone(),
body: Some(b"Body on POST!".to_vec()),
method: Method::POST,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(pre_url.clone())
.body(Some(b"Body on POST!".to_vec()))
.method(Method::POST)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = pre_server.close();
@ -568,15 +558,14 @@ fn test_load_doesnt_add_host_to_sts_list_when_url_is_http_even_if_sts_headers_ar
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let mut context = new_fetch_context(None, None);
let response = fetch_with_context(&mut request, &mut context);
@ -615,16 +604,15 @@ fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_
assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -668,16 +656,15 @@ fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_re
cookie_jar.push(cookie, &url, CookieSource::HTTP);
}
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -715,16 +702,15 @@ fn test_load_sends_cookie_if_nonhttp() {
cookie_jar.push(cookie, &url, CookieSource::HTTP);
}
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -753,16 +739,15 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl(
assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -801,16 +786,15 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() {
assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -839,15 +823,14 @@ fn test_load_sets_content_length_to_length_of_request_body() {
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::POST,
body: Some(content.to_vec()),
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::POST)
.body(Some(content.to_vec()))
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server.close();
@ -879,15 +862,14 @@ fn test_load_uses_explicit_accept_from_headers_in_load_data() {
let mut accept_headers = HeaderMap::new();
accept_headers.insert(header::ACCEPT, HeaderValue::from_static("text/html"));
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
headers: accept_headers,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.headers(accept_headers)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server.close();
@ -917,14 +899,13 @@ fn test_load_sets_default_accept_to_html_xhtml_xml_and_then_anything_else() {
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server.close();
@ -956,15 +937,14 @@ fn test_load_uses_explicit_accept_encoding_from_load_data_headers() {
let mut accept_encoding_headers = HeaderMap::new();
accept_encoding_headers.insert(header::ACCEPT_ENCODING, HeaderValue::from_static("chunked"));
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
headers: accept_encoding_headers,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.headers(accept_encoding_headers)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server.close();
@ -994,14 +974,13 @@ fn test_load_sets_default_accept_encoding_to_gzip_and_deflate() {
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server.close();
@ -1048,14 +1027,13 @@ fn test_load_errors_when_there_a_redirect_loop() {
*url_b_for_a.lock().unwrap() = Some(url_b.clone());
let mut request = Request::from_init(RequestInit {
url: url_a.clone(),
method: Method::GET,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url_a.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server_a.close();
@ -1105,14 +1083,13 @@ fn test_load_succeeds_with_a_redirect_loop() {
*url_b_for_a.lock().unwrap() = Some(url_b.clone());
let mut request = Request::from_init(RequestInit {
url: url_a.clone(),
method: Method::GET,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url_a.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = server_a.close();
@ -1145,14 +1122,13 @@ fn test_load_follows_a_redirect() {
};
let (pre_server, pre_url) = make_server(pre_handler);
let mut request = Request::from_init(RequestInit {
url: pre_url.clone(),
method: Method::GET,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
..RequestInit::default()
});
let mut request = RequestBuilder::new(pre_url.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.build();
let response = fetch(&mut request, None);
let _ = pre_server.close();
@ -1229,15 +1205,14 @@ fn test_redirect_from_x_to_y_provides_y_cookies_from_y() {
cookie_jar.push(cookie_y, &url_y, CookieSource::HTTP);
}
let mut request = Request::from_init(RequestInit {
url: url_x.clone(),
method: Method::GET,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url_x.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let response = fetch_with_context(&mut request, &mut context);
let _ = server.close();
@ -1279,15 +1254,14 @@ fn test_redirect_from_x_to_x_provides_x_with_cookie_from_first_response() {
let url = url.join("/initial/").unwrap();
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let response = fetch(&mut request, None);
let _ = server.close();
@ -1311,16 +1285,15 @@ fn test_if_auth_creds_not_in_url_but_in_cache_it_sets_it() {
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let mut context = new_fetch_context(None, None);
let auth_entry = AuthCacheEntry {
@ -1356,16 +1329,14 @@ fn test_auth_ui_needs_www_auth() {
};
let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
body: None,
destination: Destination::Document,
origin: mock_origin(),
pipeline_id: Some(TEST_PIPELINE_ID),
credentials_mode: CredentialsMode::Include,
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.body(None)
.destination(Destination::Document)
.origin(mock_origin())
.pipeline_id(Some(TEST_PIPELINE_ID))
.credentials_mode(CredentialsMode::Include)
.build();
let response = fetch(&mut request, None);
@ -1395,13 +1366,12 @@ fn test_origin_set() {
let mut origin =
Origin::try_from_parts(url.scheme(), url.host_str().unwrap(), url.port()).unwrap();
*origin_header_clone.lock().unwrap() = Some(origin.clone());
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::POST,
body: None,
origin: url.clone().origin(),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::POST)
.body(None)
.origin(url.clone().origin())
.build();
let response = fetch(&mut request, None);
assert!(response
.internal_response
@ -1415,14 +1385,12 @@ fn test_origin_set() {
origin =
Origin::try_from_parts(origin_url.scheme(), origin_url.host_str().unwrap(), None).unwrap();
// Test Origin header is set on Get request with CORS mode
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::GET,
mode: RequestMode::CorsMode,
body: None,
origin: origin_url.clone().origin(),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::GET)
.mode(RequestMode::CorsMode)
.body(None)
.origin(origin_url.clone().origin())
.build();
*origin_header_clone.lock().unwrap() = Some(origin.clone());
let response = fetch(&mut request, None);
@ -1435,13 +1403,11 @@ fn test_origin_set() {
.is_success());
// Test Origin header is not set on method Head
let mut request = Request::from_init(RequestInit {
url: url.clone(),
method: Method::HEAD,
body: None,
origin: url.clone().origin(),
..RequestInit::default()
});
let mut request = RequestBuilder::new(url.clone())
.method(Method::HEAD)
.body(None)
.origin(url.clone().origin())
.build();
*origin_header_clone.lock().unwrap() = None;
let response = fetch(&mut request, None);

28
components/net/websocket_loader.rs
View file

@ -12,7 +12,7 @@ use headers_ext::Host;
use http::header::{self, HeaderMap, HeaderName, HeaderValue};
use http::uri::Authority;
use ipc_channel::ipc::{IpcReceiver, IpcSender};
use net_traits::request::{RequestInit, RequestMode};
use net_traits::request::{RequestBuilder, RequestMode};
use net_traits::{CookieSource, MessageData};
use net_traits::{WebSocketDomAction, WebSocketNetworkEvent};
use openssl::ssl::SslStream;
@ -174,21 +174,23 @@ impl<'a> Handler for Client<'a> {
}
pub fn init(
req_init: RequestInit,
req_builder: RequestBuilder,
resource_event_sender: IpcSender<WebSocketNetworkEvent>,
dom_action_receiver: IpcReceiver<WebSocketDomAction>,
http_state: Arc<HttpState>,
) {
thread::Builder::new()
.name(format!("WebSocket connection to {}", req_init.url))
.name(format!("WebSocket connection to {}", req_builder.url))
.spawn(move || {
let protocols = match req_init.mode {
let protocols = match req_builder.mode {
RequestMode::WebSocket { protocols } => protocols,
_ => panic!("Received a RequestInit with a non-websocket mode in websocket_loader"),
_ => panic!(
"Received a RequestBuilder with a non-websocket mode in websocket_loader"
),
};
let scheme = req_init.url.scheme();
let mut req_url = req_init.url.clone();
let scheme = req_builder.url.scheme();
let mut req_url = req_builder.url.clone();
if scheme == "ws" {
req_url.as_mut_url().set_scheme("http").unwrap();
} else if scheme == "wss" {
@ -201,15 +203,15 @@ pub fn init(
return;
}
let host = replace_host(req_init.url.host_str().unwrap());
let mut net_url = req_init.url.clone().into_url();
let host = replace_host(req_builder.url.host_str().unwrap());
let mut net_url = req_builder.url.clone().into_url();
net_url.set_host(Some(&host)).unwrap();
let host = Host::from(
format!(
"{}{}",
req_init.url.host_str().unwrap(),
req_init
req_builder.url.host_str().unwrap(),
req_builder
.url
.port_or_known_default()
.map(|v| format!(":{}", v))
@ -220,11 +222,11 @@ pub fn init(
);
let client = Client {
origin: &req_init.origin.ascii_serialization(),
origin: &req_builder.origin.ascii_serialization(),
host: &host,
protocols: &protocols,
http_state: &http_state,
resource_url: &req_init.url,
resource_url: &req_builder.url,
event_sender: &resource_event_sender,
protocol_in_use: None,
};

10
components/net_traits/lib.rs
View file

@ -18,7 +18,7 @@ extern crate serde;
extern crate url;
use crate::filemanager_thread::FileManagerThreadMsg;
use crate::request::{Request, RequestInit};
use crate::request::{Request, RequestBuilder};
use crate::response::{HttpsState, Response, ResponseInit};
use crate::storage_thread::StorageThreadMsg;
use cookie::Cookie;
@ -377,10 +377,10 @@ pub enum FetchChannels {
#[derive(Debug, Deserialize, Serialize)]
pub enum CoreResourceMsg {
Fetch(RequestInit, FetchChannels),
Fetch(RequestBuilder, FetchChannels),
/// Initiate a fetch in response to processing a redirection
FetchRedirect(
RequestInit,
RequestBuilder,
ResponseInit,
IpcSender<FetchResponseMsg>,
/* cancel_chan */ Option<IpcReceiver<()>>,
@ -415,7 +415,7 @@ pub enum CoreResourceMsg {
}
/// Instruct the resource thread to make a new request.
pub fn fetch_async<F>(request: RequestInit, core_resource_thread: &CoreResourceThread, f: F)
pub fn fetch_async<F>(request: RequestBuilder, core_resource_thread: &CoreResourceThread, f: F)
where
F: Fn(FetchResponseMsg) + Send + 'static,
{
@ -595,7 +595,7 @@ pub enum CookieSource {
/// Convenience function for synchronously loading a whole resource.
pub fn load_whole_resource(
request: RequestInit,
request: RequestBuilder,
core_resource_thread: &CoreResourceThread,
) -> Result<(Metadata, Vec<u8>), NetworkError> {
let (action_sender, action_receiver) = ipc::channel().unwrap();

179
components/net_traits/request.rs
View file

@ -8,7 +8,6 @@ use http::HeaderMap;
use hyper::Method;
use msg::constellation_msg::PipelineId;
use servo_url::{ImmutableOrigin, ServoUrl};
use std::default::Default;
/// An [initiator](https://fetch.spec.whatwg.org/#concept-request-initiator)
#[derive(Clone, Copy, MallocSizeOf, PartialEq)]
@ -136,7 +135,7 @@ pub enum CorsSettings {
}
#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
pub struct RequestInit {
pub struct RequestBuilder {
#[serde(
deserialize_with = "::hyper_serde::deserialize",
serialize_with = "::hyper_serde::serialize"
@ -172,11 +171,11 @@ pub struct RequestInit {
pub url_list: Vec<ServoUrl>,
}
impl Default for RequestInit {
fn default() -> RequestInit {
RequestInit {
impl RequestBuilder {
pub fn new(url: ServoUrl) -> RequestBuilder {
RequestBuilder {
method: Method::GET,
url: ServoUrl::parse("about:blank").unwrap(),
url: url,
headers: HeaderMap::new(),
unsafe_request: false,
body: None,
@ -197,6 +196,139 @@ impl Default for RequestInit {
url_list: vec![],
}
}
pub fn method(mut self, method: Method) -> RequestBuilder {
self.method = method;
self
}
pub fn headers(mut self, headers: HeaderMap) -> RequestBuilder {
self.headers = headers;
self
}
pub fn unsafe_request(mut self, unsafe_request: bool) -> RequestBuilder {
self.unsafe_request = unsafe_request;
self
}
pub fn body(mut self, body: Option<Vec<u8>>) -> RequestBuilder {
self.body = body;
self
}
pub fn service_workers_mode(
mut self,
service_workers_mode: ServiceWorkersMode,
) -> RequestBuilder {
self.service_workers_mode = service_workers_mode;
self
}
pub fn destination(mut self, destination: Destination) -> RequestBuilder {
self.destination = destination;
self
}
pub fn synchronous(mut self, synchronous: bool) -> RequestBuilder {
self.synchronous = synchronous;
self
}
pub fn mode(mut self, mode: RequestMode) -> RequestBuilder {
self.mode = mode;
self
}
pub fn cache_mode(mut self, cache_mode: CacheMode) -> RequestBuilder {
self.cache_mode = cache_mode;
self
}
pub fn use_cors_preflight(mut self, use_cors_preflight: bool) -> RequestBuilder {
self.use_cors_preflight = use_cors_preflight;
self
}
pub fn credentials_mode(mut self, credentials_mode: CredentialsMode) -> RequestBuilder {
self.credentials_mode = credentials_mode;
self
}
pub fn use_url_credentials(mut self, use_url_credentials: bool) -> RequestBuilder {
self.use_url_credentials = use_url_credentials;
self
}
pub fn origin(mut self, origin: ImmutableOrigin) -> RequestBuilder {
self.origin = origin;
self
}
pub fn referrer_url(mut self, referrer_url: Option<ServoUrl>) -> RequestBuilder {
self.referrer_url = referrer_url;
self
}
pub fn referrer_policy(mut self, referrer_policy: Option<ReferrerPolicy>) -> RequestBuilder {
self.referrer_policy = referrer_policy;
self
}
pub fn pipeline_id(mut self, pipeline_id: Option<PipelineId>) -> RequestBuilder {
self.pipeline_id = pipeline_id;
self
}
pub fn redirect_mode(mut self, redirect_mode: RedirectMode) -> RequestBuilder {
self.redirect_mode = redirect_mode;
self
}
pub fn integrity_metadata(mut self, integrity_metadata: String) -> RequestBuilder {
self.integrity_metadata = integrity_metadata;
self
}
pub fn url_list(mut self, url_list: Vec<ServoUrl>) -> RequestBuilder {
self.url_list = url_list;
self
}
pub fn build(self) -> Request {
let mut request = Request::new(
self.url.clone(),
Some(Origin::Origin(self.origin)),
self.pipeline_id,
);
request.method = self.method;
request.headers = self.headers;
request.unsafe_request = self.unsafe_request;
request.body = self.body;
request.service_workers_mode = self.service_workers_mode;
request.destination = self.destination;
request.synchronous = self.synchronous;
request.mode = self.mode;
request.use_cors_preflight = self.use_cors_preflight;
request.credentials_mode = self.credentials_mode;
request.use_url_credentials = self.use_url_credentials;
request.cache_mode = self.cache_mode;
request.referrer = if let Some(url) = self.referrer_url {
Referrer::ReferrerUrl(url)
} else {
Referrer::NoReferrer
};
request.referrer_policy = self.referrer_policy;
request.redirect_mode = self.redirect_mode;
let mut url_list = self.url_list;
if url_list.is_empty() {
url_list.push(self.url);
}
request.redirect_count = url_list.len() as u32 - 1;
request.url_list = url_list;
request.integrity_metadata = self.integrity_metadata;
request
}
}
/// A [Request](https://fetch.spec.whatwg.org/#concept-request) as defined by
@ -294,41 +426,6 @@ impl Request {
}
}
pub fn from_init(init: RequestInit) -> Request {
let mut req = Request::new(
init.url.clone(),
Some(Origin::Origin(init.origin)),
init.pipeline_id,
);
req.method = init.method;
req.headers = init.headers;
req.unsafe_request = init.unsafe_request;
req.body = init.body;
req.service_workers_mode = init.service_workers_mode;
req.destination = init.destination;
req.synchronous = init.synchronous;
req.mode = init.mode;
req.use_cors_preflight = init.use_cors_preflight;
req.credentials_mode = init.credentials_mode;
req.use_url_credentials = init.use_url_credentials;
req.cache_mode = init.cache_mode;
req.referrer = if let Some(url) = init.referrer_url {
Referrer::ReferrerUrl(url)
} else {
Referrer::NoReferrer
};
req.referrer_policy = init.referrer_policy;
req.redirect_mode = init.redirect_mode;
let mut url_list = init.url_list;
if url_list.is_empty() {
url_list.push(init.url);
}
req.redirect_count = url_list.len() as u32 - 1;
req.url_list = url_list;
req.integrity_metadata = init.integrity_metadata;
req
}
/// <https://fetch.spec.whatwg.org/#concept-request-url>
pub fn url(&self) -> ServoUrl {
self.url_list.first().unwrap().clone()

6
components/script/document_loader.rs
View file

@ -10,7 +10,7 @@ use crate::dom::bindings::root::Dom;
use crate::dom::document::Document;
use crate::fetch::FetchCanceller;
use ipc_channel::ipc::IpcSender;
use net_traits::request::RequestInit;
use net_traits::request::RequestBuilder;
use net_traits::{CoreResourceMsg, FetchChannels, FetchResponseMsg};
use net_traits::{IpcSend, ResourceThreads};
use servo_url::ServoUrl;
@ -131,7 +131,7 @@ impl DocumentLoader {
pub fn fetch_async(
&mut self,
load: LoadType,
request: RequestInit,
request: RequestBuilder,
fetch_target: IpcSender<FetchResponseMsg>,
) {
self.add_blocking_load(load);
@ -141,7 +141,7 @@ impl DocumentLoader {
/// Initiate a new fetch that does not block the document load event.
pub fn fetch_async_background(
&mut self,
request: RequestInit,
request: RequestBuilder,
fetch_target: IpcSender<FetchResponseMsg>,
) {
let mut canceller = FetchCanceller::new();

4
components/script/dom/bindings/trace.rs
View file

@ -81,7 +81,7 @@ use msg::constellation_msg::{
use net_traits::filemanager_thread::RelativePos;
use net_traits::image::base::{Image, ImageMetadata};
use net_traits::image_cache::{ImageCache, PendingImageId};
use net_traits::request::{Request, RequestInit};
use net_traits::request::{Request, RequestBuilder};
use net_traits::response::HttpsState;
use net_traits::response::{Response, ResponseBody};
use net_traits::storage_thread::StorageType;
@ -446,7 +446,7 @@ unsafe_no_jsmanaged_fields!(PendingRestyle);
unsafe_no_jsmanaged_fields!(Stylesheet);
unsafe_no_jsmanaged_fields!(HttpsState);
unsafe_no_jsmanaged_fields!(Request);
unsafe_no_jsmanaged_fields!(RequestInit);
unsafe_no_jsmanaged_fields!(RequestBuilder);
unsafe_no_jsmanaged_fields!(StyleSharedRwLock);
unsafe_no_jsmanaged_fields!(USVString);
unsafe_no_jsmanaged_fields!(ReferrerPolicy);

21
components/script/dom/dedicatedworkerglobalscope.rs
View file

@ -36,7 +36,7 @@ use js::jsapi::{JSAutoCompartment, JSContext};
use js::jsval::UndefinedValue;
use js::rust::HandleValue;
use msg::constellation_msg::{PipelineId, TopLevelBrowsingContextId};
use net_traits::request::{CredentialsMode, Destination, RequestInit};
use net_traits::request::{CredentialsMode, Destination, RequestBuilder};
use net_traits::{load_whole_resource, IpcSend};
use script_traits::{TimerEvent, TimerSource, WorkerGlobalScopeInit, WorkerScriptLoadOrigin};
use servo_rand::random;
@ -305,17 +305,14 @@ impl DedicatedWorkerGlobalScope {
pipeline_id,
} = worker_load_origin;
let request = RequestInit {
url: worker_url.clone(),
destination: Destination::Worker,
credentials_mode: CredentialsMode::Include,
use_url_credentials: true,
pipeline_id: pipeline_id,
referrer_url: referrer_url,
referrer_policy: referrer_policy,
origin,
..RequestInit::default()
};
let request = RequestBuilder::new(worker_url.clone())
.destination(Destination::Worker)
.credentials_mode(CredentialsMode::Include)
.use_url_credentials(true)
.pipeline_id(pipeline_id)
.referrer_url(referrer_url)
.referrer_policy(referrer_policy)
.origin(origin);
let (metadata, bytes) =
match load_whole_resource(request, &init.resource_threads.sender()) {

4
components/script/dom/document.rs
View file

@ -123,7 +123,7 @@ use metrics::{
use mime::{self, Mime};
use msg::constellation_msg::BrowsingContextId;
use net_traits::pub_domains::is_pub_domain;
use net_traits::request::RequestInit;
use net_traits::request::RequestBuilder;
use net_traits::response::HttpsState;
use net_traits::CookieSource::NonHTTP;
use net_traits::CoreResourceMsg::{GetCookiesForUrl, SetCookiesForUrl};
@ -1712,7 +1712,7 @@ impl Document {
pub fn fetch_async(
&self,
load: LoadType,
request: RequestInit,
request: RequestBuilder,
fetch_target: IpcSender<FetchResponseMsg>,
) {
let mut loader = self.loader.borrow_mut();

24
components/script/dom/eventsource.rs
View file

@ -32,7 +32,7 @@ use js::jsapi::JSAutoCompartment;
use js::jsval::UndefinedValue;
use mime::{self, Mime};
use net_traits::request::{CacheMode, CorsSettings, CredentialsMode};
use net_traits::request::{RequestInit, RequestMode};
use net_traits::request::{RequestBuilder, RequestMode};
use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata};
use net_traits::{FetchResponseListener, FetchResponseMsg, NetworkError};
use net_traits::{ResourceFetchTiming, ResourceTimingType};
@ -61,7 +61,7 @@ enum ReadyState {
pub struct EventSource {
eventtarget: EventTarget,
url: ServoUrl,
request: DomRefCell<Option<RequestInit>>,
request: DomRefCell<Option<RequestBuilder>>,
last_event_id: DomRefCell<DOMString>,
reconnection_time: Cell<u64>,
generation_id: Cell<GenerationId>,
@ -482,7 +482,7 @@ impl EventSource {
);
}
pub fn request(&self) -> RequestInit {
pub fn request(&self) -> RequestBuilder {
self.request.borrow().clone().unwrap()
}
@ -519,20 +519,18 @@ impl EventSource {
};
// Step 8
// TODO: Step 9 set request's client settings
let mut request = RequestInit {
url: url_record,
origin: global.origin().immutable().clone(),
pipeline_id: Some(global.pipeline_id()),
let mut request = RequestBuilder::new(url_record)
.origin(global.origin().immutable().clone())
.pipeline_id(Some(global.pipeline_id()))
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
use_url_credentials: true,
mode: RequestMode::CorsMode,
credentials_mode: if cors_attribute_state == CorsSettings::Anonymous {
.use_url_credentials(true)
.mode(RequestMode::CorsMode)
.credentials_mode(if cors_attribute_state == CorsSettings::Anonymous {
CredentialsMode::CredentialsSameOrigin
} else {
CredentialsMode::Include
},
..RequestInit::default()
};
});
// Step 10
// TODO(eijebong): Replace once typed headers allow it
request.headers.insert(

11
components/script/dom/htmlimageelement.rs
View file

@ -55,7 +55,7 @@ use net_traits::image::base::{Image, ImageMetadata};
use net_traits::image_cache::UsePlaceholder;
use net_traits::image_cache::{CanRequestImages, ImageCache, ImageOrMetadataAvailable};
use net_traits::image_cache::{ImageResponder, ImageResponse, ImageState, PendingImageId};
use net_traits::request::RequestInit;
use net_traits::request::RequestBuilder;
use net_traits::{FetchMetadata, FetchResponseListener, FetchResponseMsg, NetworkError};
use net_traits::{ResourceFetchTiming, ResourceTimingType};
use num_traits::ToPrimitive;
@ -324,12 +324,9 @@ impl HTMLImageElement {
}),
);
let request = RequestInit {
url: img_url.clone(),
origin: document.origin().immutable().clone(),
pipeline_id: Some(document.global().pipeline_id()),
..RequestInit::default()
};
let request = RequestBuilder::new(img_url.clone())
.origin(document.origin().immutable().clone())
.pipeline_id(Some(document.global().pipeline_id()));
// This is a background load because the load blocker already fulfills the
// purpose of delaying the document's load event.

24
components/script/dom/htmlmediaelement.rs
View file

@ -64,7 +64,7 @@ use ipc_channel::router::ROUTER;
use mime::{self, Mime};
use net_traits::image::base::Image;
use net_traits::image_cache::ImageResponse;
use net_traits::request::{CredentialsMode, Destination, RequestInit};
use net_traits::request::{CredentialsMode, Destination, RequestBuilder};
use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseListener, Metadata};
use net_traits::{NetworkError, ResourceFetchTiming, ResourceTimingType};
use script_layout_interface::HTMLMediaData;
@ -710,18 +710,16 @@ impl HTMLMediaElement {
Some(url) => url.clone(),
None => self.blob_url.borrow().as_ref().unwrap().clone(),
};
let request = RequestInit {
url: url.clone(),
headers,
destination,
credentials_mode: CredentialsMode::Include,
use_url_credentials: true,
origin: document.origin().immutable().clone(),
pipeline_id: Some(self.global().pipeline_id()),
referrer_url: Some(document.url()),
referrer_policy: document.get_referrer_policy(),
..RequestInit::default()
};
let request = RequestBuilder::new(url.clone())
.headers(headers)
.destination(destination)
.credentials_mode(CredentialsMode::Include)
.use_url_credentials(true)
.origin(document.origin().immutable().clone())
.pipeline_id(Some(self.global().pipeline_id()))
.referrer_url(Some(document.url()))
.referrer_policy(document.get_referrer_policy());
let mut current_fetch_context = self.current_fetch_context.borrow_mut();
if let Some(ref mut current_fetch_context) = *current_fetch_context {

29
components/script/dom/htmlscriptelement.rs
View file

@ -32,7 +32,9 @@ use html5ever::{LocalName, Prefix};
use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use js::jsval::UndefinedValue;
use net_traits::request::{CorsSettings, CredentialsMode, Destination, RequestInit, RequestMode};
use net_traits::request::{
CorsSettings, CredentialsMode, Destination, RequestBuilder, RequestMode,
};
use net_traits::{FetchMetadata, FetchResponseListener, Metadata, NetworkError};
use net_traits::{ResourceFetchTiming, ResourceTimingType};
use servo_atoms::Atom;
@ -290,28 +292,25 @@ fn fetch_a_classic_script(
let doc = document_from_node(script);
// Step 1, 2.
let request = RequestInit {
url: url.clone(),
destination: Destination::Script,
let request = RequestBuilder::new(url.clone())
.destination(Destination::Script)
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
// Step 1
mode: match cors_setting {
.mode(match cors_setting {
Some(_) => RequestMode::CorsMode,
None => RequestMode::NoCors,
},
})
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
// Step 3-4
credentials_mode: match cors_setting {
.credentials_mode(match cors_setting {
Some(CorsSettings::Anonymous) => CredentialsMode::CredentialsSameOrigin,
_ => CredentialsMode::Include,
},
origin: doc.origin().immutable().clone(),
pipeline_id: Some(script.global().pipeline_id()),
referrer_url: Some(doc.url()),
referrer_policy: doc.get_referrer_policy(),
integrity_metadata: integrity_metadata,
..RequestInit::default()
};
})
.origin(doc.origin().immutable().clone())
.pipeline_id(Some(script.global().pipeline_id()))
.referrer_url(Some(doc.url()))
.referrer_policy(doc.get_referrer_policy())
.integrity_metadata(integrity_metadata);
// TODO: Step 3, Add custom steps to perform fetch

17
components/script/dom/htmlvideoelement.rs
View file

@ -29,7 +29,7 @@ use ipc_channel::router::ROUTER;
use net_traits::image_cache::UsePlaceholder;
use net_traits::image_cache::{CanRequestImages, ImageCache, ImageOrMetadataAvailable};
use net_traits::image_cache::{ImageResponse, ImageState, PendingImageId};
use net_traits::request::{CredentialsMode, Destination, RequestInit};
use net_traits::request::{CredentialsMode, Destination, RequestBuilder};
use net_traits::{
CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseListener, FetchResponseMsg,
};
@ -162,15 +162,12 @@ impl HTMLVideoElement {
) {
// Continuation of step 4.
let document = document_from_node(self);
let request = RequestInit {
url: poster_url.clone(),
destination: Destination::Image,
credentials_mode: CredentialsMode::Include,
use_url_credentials: true,
origin: document.origin().immutable().clone(),
pipeline_id: Some(document.global().pipeline_id()),
..RequestInit::default()
};
let request = RequestBuilder::new(poster_url.clone())
.destination(Destination::Image)
.credentials_mode(CredentialsMode::Include)
.use_url_credentials(true)
.origin(document.origin().immutable().clone())
.pipeline_id(Some(document.global().pipeline_id()));
// Step 5.
// This delay must be independent from the ones created by HTMLMediaElement during

21
components/script/dom/serviceworkerglobalscope.rs
View file

@ -30,7 +30,7 @@ use ipc_channel::router::ROUTER;
use js::jsapi::{JSAutoCompartment, JSContext, JS_AddInterruptCallback};
use js::jsval::UndefinedValue;
use msg::constellation_msg::PipelineId;
use net_traits::request::{CredentialsMode, Destination, RequestInit};
use net_traits::request::{CredentialsMode, Destination, RequestBuilder};
use net_traits::{load_whole_resource, CustomResponseMediator, IpcSend};
use script_traits::{
ScopeThings, ServiceWorkerMsg, TimerEvent, WorkerGlobalScopeInit, WorkerScriptLoadOrigin,
@ -281,17 +281,14 @@ impl ServiceWorkerGlobalScope {
pipeline_id,
} = worker_load_origin;
let request = RequestInit {
url: script_url.clone(),
destination: Destination::ServiceWorker,
credentials_mode: CredentialsMode::Include,
use_url_credentials: true,
pipeline_id: pipeline_id,
referrer_url: referrer_url,
referrer_policy: referrer_policy,
origin,
..RequestInit::default()
};
let request = RequestBuilder::new(script_url.clone())
.destination(Destination::ServiceWorker)
.credentials_mode(CredentialsMode::Include)
.use_url_credentials(true)
.pipeline_id(pipeline_id)
.referrer_url(referrer_url)
.referrer_policy(referrer_policy)
.origin(origin);
let (url, source) =
match load_whole_resource(request, &init.resource_threads.sender()) {

12
components/script/dom/websocket.rs
View file

@ -31,7 +31,7 @@ use js::jsapi::{JSAutoCompartment, JSObject};
use js::jsval::UndefinedValue;
use js::rust::CustomAutoRooterGuard;
use js::typedarray::{ArrayBuffer, ArrayBufferView, CreateWith};
use net_traits::request::{RequestInit, RequestMode};
use net_traits::request::{RequestBuilder, RequestMode};
use net_traits::MessageData;
use net_traits::{CoreResourceMsg, FetchChannels};
use net_traits::{WebSocketDomAction, WebSocketNetworkEvent};
@ -201,12 +201,10 @@ impl WebSocket {
let address = Trusted::new(&*ws);
// Step 8.
let request = RequestInit {
url: url_record,
origin: global.origin().immutable().clone(),
mode: RequestMode::WebSocket { protocols },
..RequestInit::default()
};
let request = RequestBuilder::new(url_record)
.origin(global.origin().immutable().clone())
.mode(RequestMode::WebSocket { protocols });
let channels = FetchChannels::WebSocket {
event_sender: resource_event_sender,
action_receiver: resource_action_receiver,

22
components/script/dom/workerglobalscope.rs
View file

@ -41,7 +41,7 @@ use js::jsval::UndefinedValue;
use js::panic::maybe_resume_unwind;
use js::rust::{HandleValue, ParentRuntime};
use msg::constellation_msg::PipelineId;
use net_traits::request::{CredentialsMode, Destination, RequestInit as NetRequestInit};
use net_traits::request::{CredentialsMode, Destination, RequestBuilder as NetRequestInit};
use net_traits::{load_whole_resource, IpcSend};
use script_traits::WorkerGlobalScopeInit;
use script_traits::{TimerEvent, TimerEventId};
@ -207,17 +207,15 @@ impl WorkerGlobalScopeMethods for WorkerGlobalScope {
rooted!(in(self.runtime.cx()) let mut rval = UndefinedValue());
for url in urls {
let global_scope = self.upcast::<GlobalScope>();
let request = NetRequestInit {
url: url.clone(),
destination: Destination::Script,
credentials_mode: CredentialsMode::Include,
use_url_credentials: true,
origin: global_scope.origin().immutable().clone(),
pipeline_id: Some(self.upcast::<GlobalScope>().pipeline_id()),
referrer_url: None,
referrer_policy: None,
..NetRequestInit::default()
};
let request = NetRequestInit::new(url.clone())
.destination(Destination::Script)
.credentials_mode(CredentialsMode::Include)
.use_url_credentials(true)
.origin(global_scope.origin().immutable().clone())
.pipeline_id(Some(self.upcast::<GlobalScope>().pipeline_id()))
.referrer_url(None)
.referrer_policy(None);
;
let (url, source) =
match load_whole_resource(request, &global_scope.resource_threads().sender()) {
Err(_) => return Err(Error::Network),

16
components/script/dom/worklet.rs
View file

@ -48,7 +48,7 @@ use js::jsapi::JS_GC;
use msg::constellation_msg::PipelineId;
use net_traits::load_whole_resource;
use net_traits::request::Destination;
use net_traits::request::RequestInit;
use net_traits::request::RequestBuilder;
use net_traits::request::RequestMode;
use net_traits::IpcSend;
use servo_url::ImmutableOrigin;
@ -620,14 +620,12 @@ impl WorkletThread {
// TODO: Fetch the script asynchronously?
// TODO: Caching.
let resource_fetcher = self.global_init.resource_threads.sender();
let request = RequestInit {
url: script_url,
destination: Destination::Script,
mode: RequestMode::CorsMode,
credentials_mode: credentials.into(),
origin,
..RequestInit::default()
};
let request = RequestBuilder::new(script_url)
.destination(Destination::Script)
.mode(RequestMode::CorsMode)
.credentials_mode(credentials.into())
.origin(origin);
let script = load_whole_resource(request, &resource_fetcher)
.ok()
.and_then(|(_, bytes)| String::from_utf8(bytes).ok());

39
components/script/dom/xmlhttprequest.rs
View file

@ -59,7 +59,7 @@ use js::jsval::{JSVal, NullValue, UndefinedValue};
use js::rust::wrappers::JS_ParseJSON;
use js::typedarray::{ArrayBuffer, CreateWith};
use mime::{self, Mime, Name};
use net_traits::request::{CredentialsMode, Destination, RequestInit, RequestMode};
use net_traits::request::{CredentialsMode, Destination, RequestBuilder, RequestMode};
use net_traits::trim_http_whitespace;
use net_traits::CoreResourceMsg::Fetch;
use net_traits::{FetchChannels, FetchMetadata, FilteredMetadata};
@ -233,7 +233,7 @@ impl XMLHttpRequest {
context: Arc<Mutex<XHRContext>>,
task_source: NetworkingTaskSource,
global: &GlobalScope,
init: RequestInit,
init: RequestBuilder,
cancellation_chan: ipc::IpcReceiver<()>,
) {
impl FetchResponseListener for XHRContext {
@ -638,27 +638,24 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
unreachable!()
};
let mut request = RequestInit {
method: self.request_method.borrow().clone(),
url: self.request_url.borrow().clone().unwrap(),
headers: (*self.request_headers.borrow()).clone(),
unsafe_request: true,
let mut request = RequestBuilder::new(self.request_url.borrow().clone().unwrap())
.method(self.request_method.borrow().clone())
.headers((*self.request_headers.borrow()).clone())
.unsafe_request(true)
// XXXManishearth figure out how to avoid this clone
body: extracted_or_serialized.as_ref().map(|e| e.0.clone()),
.body(extracted_or_serialized.as_ref().map(|e| e.0.clone()))
// XXXManishearth actually "subresource", but it doesn't exist
// https://github.com/whatwg/xhr/issues/71
destination: Destination::None,
synchronous: self.sync.get(),
mode: RequestMode::CorsMode,
use_cors_preflight: has_handlers,
credentials_mode: credentials_mode,
use_url_credentials: use_url_credentials,
origin: self.global().origin().immutable().clone(),
referrer_url: self.referrer_url.clone(),
referrer_policy: self.referrer_policy.clone(),
pipeline_id: Some(self.global().pipeline_id()),
..RequestInit::default()
};
.destination(Destination::None)
.synchronous(self.sync.get())
.mode(RequestMode::CorsMode)
.use_cors_preflight(has_handlers)
.credentials_mode(credentials_mode)
.use_url_credentials(use_url_credentials)
.origin(self.global().origin().immutable().clone())
.referrer_url(self.referrer_url.clone())
.referrer_policy(self.referrer_policy.clone())
.pipeline_id(Some(self.global().pipeline_id()));
// step 4 (second half)
match extracted_or_serialized {
@ -1458,7 +1455,7 @@ impl XMLHttpRequest {
self.response_status.set(Err(()));
}
fn fetch(&self, init: RequestInit, global: &GlobalScope) -> ErrorResult {
fn fetch(&self, init: RequestBuilder, global: &GlobalScope) -> ErrorResult {
let xhr = Trusted::new(self);
let context = Arc::new(Mutex::new(XHRContext {

12
components/script/fetch.rs
View file

@ -24,7 +24,7 @@ use crate::task_source::TaskSourceName;
use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use js::jsapi::JSAutoCompartment;
use net_traits::request::RequestInit as NetTraitsRequestInit;
use net_traits::request::RequestBuilder;
use net_traits::request::{Request as NetTraitsRequest, ServiceWorkersMode};
use net_traits::CoreResourceMsg::Fetch as NetTraitsFetch;
use net_traits::{FetchChannels, FetchResponseListener, NetworkError};
@ -98,16 +98,18 @@ fn from_referrer_to_referrer_url(request: &NetTraitsRequest) -> Option<ServoUrl>
request.referrer.to_url().map(|url| url.clone())
}
fn request_init_from_request(request: NetTraitsRequest) -> NetTraitsRequestInit {
NetTraitsRequestInit {
fn request_init_from_request(request: NetTraitsRequest) -> RequestBuilder {
RequestBuilder {
method: request.method.clone(),
url: request.url(),
headers: request.headers.clone(),
unsafe_request: request.unsafe_request,
body: request.body.clone(),
service_workers_mode: ServiceWorkersMode::All,
destination: request.destination,
synchronous: request.synchronous,
mode: request.mode.clone(),
cache_mode: request.cache_mode,
use_cors_preflight: request.use_cors_preflight,
credentials_mode: request.credentials_mode,
use_url_credentials: request.use_url_credentials,
@ -120,8 +122,8 @@ fn request_init_from_request(request: NetTraitsRequest) -> NetTraitsRequestInit
referrer_policy: request.referrer_policy,
pipeline_id: request.pipeline_id,
redirect_mode: request.redirect_mode,
cache_mode: request.cache_mode,
..NetTraitsRequestInit::default()
integrity_metadata: "".to_owned(),
url_list: vec![],
}
}

13
components/script/layout_image.rs
View file

@ -18,7 +18,7 @@ use crate::network_listener::{self, NetworkListener, PreInvoke, ResourceTimingLi
use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use net_traits::image_cache::{ImageCache, PendingImageId};
use net_traits::request::{Destination, RequestInit as FetchRequestInit};
use net_traits::request::{Destination, RequestBuilder as FetchRequestInit};
use net_traits::{FetchMetadata, FetchResponseListener, FetchResponseMsg, NetworkError};
use net_traits::{ResourceFetchTiming, ResourceTimingType};
use servo_url::ServoUrl;
@ -110,13 +110,10 @@ pub fn fetch_image_for_layout(
}),
);
let request = FetchRequestInit {
url: url,
origin: document.origin().immutable().clone(),
destination: Destination::Image,
pipeline_id: Some(document.global().pipeline_id()),
..FetchRequestInit::default()
};
let request = FetchRequestInit::new(url)
.origin(document.origin().immutable().clone())
.destination(Destination::Image)
.pipeline_id(Some(document.global().pipeline_id()));
// Layout image loads do not delay the document load event.
document

29
components/script/script_thread.rs
View file

@ -110,7 +110,7 @@ use msg::constellation_msg::{BrowsingContextId, HistoryStateId, PipelineId};
use msg::constellation_msg::{HangAnnotation, MonitoredComponentId, MonitoredComponentType};
use msg::constellation_msg::{PipelineNamespace, TopLevelBrowsingContextId};
use net_traits::image_cache::{ImageCache, PendingImageResponse};
use net_traits::request::{CredentialsMode, Destination, RedirectMode, RequestInit};
use net_traits::request::{CredentialsMode, Destination, RedirectMode, RequestBuilder};
use net_traits::storage_thread::StorageType;
use net_traits::{FetchMetadata, FetchResponseListener, FetchResponseMsg};
use net_traits::{
@ -3327,21 +3327,18 @@ impl ScriptThread {
/// argument until a notification is received that the fetch is complete.
fn pre_page_load(&self, mut incomplete: InProgressLoad, load_data: LoadData) {
let id = incomplete.pipeline_id.clone();
let req_init = RequestInit {
url: load_data.url.clone(),
method: load_data.method,
destination: Destination::Document,
credentials_mode: CredentialsMode::Include,
use_url_credentials: true,
pipeline_id: Some(id),
referrer_url: load_data.referrer_url,
referrer_policy: load_data.referrer_policy,
headers: load_data.headers,
body: load_data.data,
redirect_mode: RedirectMode::Manual,
origin: incomplete.origin.immutable().clone(),
..RequestInit::default()
};
let req_init = RequestBuilder::new(load_data.url.clone())
.method(load_data.method)
.destination(Destination::Document)
.credentials_mode(CredentialsMode::Include)
.use_url_credentials(true)
.pipeline_id(Some(id))
.referrer_url(load_data.referrer_url)
.referrer_policy(load_data.referrer_policy)
.headers(load_data.headers)
.body(load_data.data)
.redirect_mode(RedirectMode::Manual)
.origin(incomplete.origin.immutable().clone());
let context = ParserContext::new(id, load_data.url);
self.incomplete_parser_contexts

29
components/script/stylesheet_loader.rs
View file

@ -21,7 +21,9 @@ use encoding_rs::UTF_8;
use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use mime::{self, Mime};
use net_traits::request::{CorsSettings, CredentialsMode, Destination, RequestInit, RequestMode};
use net_traits::request::{
CorsSettings, CredentialsMode, Destination, RequestBuilder, RequestMode,
};
use net_traits::{
FetchMetadata, FetchResponseListener, FilteredMetadata, Metadata, NetworkError, ReferrerPolicy,
};
@ -308,28 +310,25 @@ impl<'a> StylesheetLoader<'a> {
document.increment_script_blocking_stylesheet_count();
}
let request = RequestInit {
url: url.clone(),
destination: Destination::Style,
let request = RequestBuilder::new(url.clone())
.destination(Destination::Style)
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
// Step 1
mode: match cors_setting {
.mode(match cors_setting {
Some(_) => RequestMode::CorsMode,
None => RequestMode::NoCors,
},
})
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
// Step 3-4
credentials_mode: match cors_setting {
.credentials_mode(match cors_setting {
Some(CorsSettings::Anonymous) => CredentialsMode::CredentialsSameOrigin,
_ => CredentialsMode::Include,
},
origin: document.origin().immutable().clone(),
pipeline_id: Some(self.elem.global().pipeline_id()),
referrer_url: Some(document.url()),
referrer_policy: referrer_policy,
integrity_metadata: integrity_metadata,
..RequestInit::default()
};
})
.origin(document.origin().immutable().clone())
.pipeline_id(Some(self.elem.global().pipeline_id()))
.referrer_url(Some(document.url()))
.referrer_policy(referrer_policy)
.integrity_metadata(integrity_metadata);
document.fetch_async(LoadType::Stylesheet(url), request, action_sender);
}

4
components/script_traits/script_msg.rs
View file

@ -20,7 +20,7 @@ use gfx_traits::Epoch;
use ipc_channel::ipc::{IpcReceiver, IpcSender};
use msg::constellation_msg::{BrowsingContextId, PipelineId, TopLevelBrowsingContextId};
use msg::constellation_msg::{HistoryStateId, TraversalDirection};
use net_traits::request::RequestInit;
use net_traits::request::RequestBuilder;
use net_traits::storage_thread::StorageType;
use net_traits::CoreResourceMsg;
use servo_url::ImmutableOrigin;
@ -107,7 +107,7 @@ pub enum ScriptMsg {
ForwardToEmbedder(EmbedderMsg),
/// Requests are sent to constellation and fetches are checked manually
/// for cross-origin loads
InitiateNavigateRequest(RequestInit, /* cancellation_chan */ IpcReceiver<()>),
InitiateNavigateRequest(RequestBuilder, /* cancellation_chan */ IpcReceiver<()>),
/// Broadcast a storage event to every same-origin pipeline.
/// The strings are key, old value and new value.
BroadcastStorageEvent(