Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-22 23:03:42 +01: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 msg::constellation_msg::{PipelineNamespace, PipelineNamespaceId, TraversalDirection};
use net_traits::pub_domains::reg_host; 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::storage_thread::{StorageThreadMsg, StorageType};
use net_traits::{self, FetchResponseMsg, IpcSend, ResourceThreads}; use net_traits::{self, FetchResponseMsg, IpcSend, ResourceThreads};
use profile_traits::mem; use profile_traits::mem;
@ -1934,11 +1934,11 @@ where
fn handle_navigate_request( fn handle_navigate_request(
&self, &self,
id: PipelineId, id: PipelineId,
req_init: RequestInit, request_builder: RequestBuilder,
cancel_chan: IpcReceiver<()>, cancel_chan: IpcReceiver<()>,
) { ) {
let listener = NetworkListener::new( let listener = NetworkListener::new(
req_init, request_builder,
id, id,
self.public_resource_threads.clone(), self.public_resource_threads.clone(),
self.network_listener_sender.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 ipc_channel::router::ROUTER;
use msg::constellation_msg::PipelineId; use msg::constellation_msg::PipelineId;
use net::http_loader::{set_default_accept, set_default_accept_language}; 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::response::ResponseInit;
use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseMsg}; use net_traits::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseMsg};
use net_traits::{IpcSend, NetworkError, ResourceThreads}; use net_traits::{IpcSend, NetworkError, ResourceThreads};
pub struct NetworkListener { pub struct NetworkListener {
res_init: Option<ResponseInit>, res_init: Option<ResponseInit>,
req_init: RequestInit, request_builder: RequestBuilder,
pipeline_id: PipelineId, pipeline_id: PipelineId,
resource_threads: ResourceThreads, resource_threads: ResourceThreads,
sender: Sender<(PipelineId, FetchResponseMsg)>, sender: Sender<(PipelineId, FetchResponseMsg)>,
@ -28,14 +28,14 @@ pub struct NetworkListener {
impl NetworkListener { impl NetworkListener {
pub fn new( pub fn new(
req_init: RequestInit, request_builder: RequestBuilder,
pipeline_id: PipelineId, pipeline_id: PipelineId,
resource_threads: ResourceThreads, resource_threads: ResourceThreads,
sender: Sender<(PipelineId, FetchResponseMsg)>, sender: Sender<(PipelineId, FetchResponseMsg)>,
) -> NetworkListener { ) -> NetworkListener {
NetworkListener { NetworkListener {
res_init: None, res_init: None,
req_init, request_builder,
pipeline_id, pipeline_id,
resource_threads, resource_threads,
sender, sender,
@ -48,7 +48,7 @@ impl NetworkListener {
let mut listener = NetworkListener { let mut listener = NetworkListener {
res_init: self.res_init.clone(), res_init: self.res_init.clone(),
req_init: self.req_init.clone(), request_builder: self.request_builder.clone(),
resource_threads: self.resource_threads.clone(), resource_threads: self.resource_threads.clone(),
sender: self.sender.clone(), sender: self.sender.clone(),
pipeline_id: self.pipeline_id.clone(), pipeline_id: self.pipeline_id.clone(),
@ -57,17 +57,17 @@ impl NetworkListener {
let msg = match self.res_init { let msg = match self.res_init {
Some(ref res_init_) => CoreResourceMsg::FetchRedirect( Some(ref res_init_) => CoreResourceMsg::FetchRedirect(
self.req_init.clone(), self.request_builder.clone(),
res_init_.clone(), res_init_.clone(),
ipc_sender, ipc_sender,
None, None,
), ),
None => { None => {
set_default_accept(Destination::Document, &mut listener.req_init.headers); set_default_accept(Destination::Document, &mut listener.request_builder.headers);
set_default_accept_language(&mut listener.req_init.headers); set_default_accept_language(&mut listener.request_builder.headers);
CoreResourceMsg::Fetch( CoreResourceMsg::Fetch(
listener.req_init.clone(), listener.request_builder.clone(),
FetchChannels::ResponseMsg(ipc_sender, cancel_chan), FetchChannels::ResponseMsg(ipc_sender, cancel_chan),
) )
}, },
@ -100,13 +100,17 @@ impl NetworkListener {
match metadata.headers { match metadata.headers {
Some(ref headers) if headers.contains_key(LOCATION) => { Some(ref headers) if headers.contains_key(LOCATION) => {
if self.req_init.url_list.is_empty() { if self.request_builder.url_list.is_empty() {
self.req_init.url_list.push(self.req_init.url.clone()); 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.request_builder.referrer_url = metadata.referrer.clone();
self.req_init.referrer_policy = metadata.referrer_policy; self.request_builder.referrer_policy = metadata.referrer_policy;
self.res_init = Some(ResponseInit { self.res_init = Some(ResponseInit {
url: metadata.final_url.clone(), 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 crate::platform::font_template::FontTemplateData;
use app_units::Au; use app_units::Au;
use ipc_channel::ipc::{self, IpcReceiver, IpcSender}; 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 net_traits::{fetch_async, CoreResourceThread, FetchResponseMsg};
use servo_atoms::Atom; use servo_atoms::Atom;
use servo_url::ServoUrl; use servo_url::ServoUrl;
@ -238,13 +238,7 @@ impl FontCache {
None => return, None => return,
}; };
let request = RequestInit { let request = RequestBuilder::new(url.clone()).destination(Destination::Font);
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 channel_to_self = self.channel_to_self.clone(); let channel_to_self = self.channel_to_self.clone();
let bytes = Mutex::new(Vec::new()); 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 hyper_serde::Serde;
use ipc_channel::ipc::{self, IpcReceiver, IpcReceiverSet, IpcSender}; use ipc_channel::ipc::{self, IpcReceiver, IpcReceiverSet, IpcSender};
use malloc_size_of::{MallocSizeOf, MallocSizeOfOps}; 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::response::{Response, ResponseInit};
use net_traits::storage_thread::StorageThreadMsg; use net_traits::storage_thread::StorageThreadMsg;
use net_traits::WebSocketNetworkEvent; use net_traits::WebSocketNetworkEvent;
@ -430,7 +430,7 @@ impl CoreResourceManager {
fn fetch( fn fetch(
&self, &self,
req_init: RequestInit, request_builder: RequestBuilder,
res_init_: Option<ResponseInit>, res_init_: Option<ResponseInit>,
mut sender: IpcSender<FetchResponseMsg>, mut sender: IpcSender<FetchResponseMsg>,
http_state: &Arc<HttpState>, http_state: &Arc<HttpState>,
@ -441,15 +441,15 @@ impl CoreResourceManager {
let dc = self.devtools_chan.clone(); let dc = self.devtools_chan.clone();
let filemanager = self.filemanager.clone(); let filemanager = self.filemanager.clone();
let timing_type = match req_init.destination { let timing_type = match request_builder.destination {
Destination::Document => ResourceTimingType::Navigation, Destination::Document => ResourceTimingType::Navigation,
_ => ResourceTimingType::Resource, _ => ResourceTimingType::Resource,
}; };
thread::Builder::new() thread::Builder::new()
.name(format!("fetch thread for {}", req_init.url)) .name(format!("fetch thread for {}", request_builder.url))
.spawn(move || { .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) // XXXManishearth: Check origin against pipeline id (also ensure that the mode is allowed)
// todo load context / mimesniff in fetch // todo load context / mimesniff in fetch
// todo referrer policy? // todo referrer policy?
@ -486,7 +486,7 @@ impl CoreResourceManager {
fn websocket_connect( fn websocket_connect(
&self, &self,
request: RequestInit, request: RequestBuilder,
event_sender: IpcSender<WebSocketNetworkEvent>, event_sender: IpcSender<WebSocketNetworkEvent>,
action_receiver: IpcReceiver<WebSocketDomAction>, action_receiver: IpcReceiver<WebSocketDomAction>,
http_state: &Arc<HttpState>, 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::cookie_storage::CookieStorage;
use net::resource_thread::AuthCacheEntry; use net::resource_thread::AuthCacheEntry;
use net::test::replace_host_table; 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::response::ResponseBody;
use net_traits::{CookieSource, NetworkError}; use net_traits::{CookieSource, NetworkError};
use servo_url::{ImmutableOrigin, ServoUrl}; 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()); *expected_headers.lock().unwrap() = Some(headers.clone());
// Testing for method.GET // Testing for method.GET
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(url.clone().origin())
origin: url.clone().origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(response
.internal_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(), HeaderValue::from_str(&url_str[..url_str.len() - 1]).unwrap(),
); );
*expected_headers.lock().unwrap() = Some(post_headers); *expected_headers.lock().unwrap() = Some(post_headers);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::POST)
method: Method::POST, .destination(Destination::Document)
destination: Destination::Document, .origin(url.clone().origin())
origin: url.clone().origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(response
.internal_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 (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::POST)
method: Method::POST, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(response
.internal_response .internal_response
@ -227,16 +224,15 @@ fn test_request_and_response_data_with_network_messages() {
let mut request_headers = HeaderMap::new(); let mut request_headers = HeaderMap::new();
request_headers.typed_insert(Host::from("bar.foo".parse::<Authority>().unwrap())); request_headers.typed_insert(Host::from("bar.foo".parse::<Authority>().unwrap()));
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .headers(request_headers)
headers: request_headers, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let (devtools_chan, devtools_port) = unbounded(); let (devtools_chan, devtools_port) = unbounded();
let response = fetch(&mut request, Some(devtools_chan)); let response = fetch(&mut request, Some(devtools_chan));
assert!(response assert!(response
@ -328,14 +324,13 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() {
}; };
let (server, url) = make_server(handler); let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(None)
pipeline_id: None, .build();
..RequestInit::default()
});
let (devtools_chan, devtools_port) = unbounded(); let (devtools_chan, devtools_port) = unbounded();
let response = fetch(&mut request, Some(devtools_chan)); let response = fetch(&mut request, Some(devtools_chan));
assert!(response assert!(response
@ -371,13 +366,12 @@ fn test_redirected_request_to_devtools() {
}; };
let (pre_server, pre_url) = make_server(pre_handler); let (pre_server, pre_url) = make_server(pre_handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(pre_url.clone())
url: pre_url.clone(), .method(Method::POST)
method: Method::POST, .destination(Destination::Document)
destination: Destination::Document, .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let (devtools_chan, devtools_port) = unbounded(); let (devtools_chan, devtools_port) = unbounded();
fetch(&mut request, Some(devtools_chan)); 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 (pre_server, pre_url) = make_server(pre_handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(pre_url.clone())
url: pre_url.clone(), .method(Method::POST)
method: Method::POST, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = pre_server.close(); 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 (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server.close(); 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 (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server.close(); 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 (pre_server, pre_url) = make_server(pre_handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(pre_url.clone())
url: pre_url.clone(), .body(Some(b"Body on POST!".to_vec()))
body: Some(b"Body on POST!".to_vec()), .method(Method::POST)
method: Method::POST, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = pre_server.close(); 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 (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let mut context = new_fetch_context(None, None); let mut context = new_fetch_context(None, None);
let response = fetch_with_context(&mut request, &mut context); 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); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &mut context); let response = fetch_with_context(&mut request, &mut context);
let _ = server.close(); 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); cookie_jar.push(cookie, &url, CookieSource::HTTP);
} }
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &mut context); let response = fetch_with_context(&mut request, &mut context);
let _ = server.close(); let _ = server.close();
@ -715,16 +702,15 @@ fn test_load_sends_cookie_if_nonhttp() {
cookie_jar.push(cookie, &url, CookieSource::HTTP); cookie_jar.push(cookie, &url, CookieSource::HTTP);
} }
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &mut context); let response = fetch_with_context(&mut request, &mut context);
let _ = server.close(); 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); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &mut context); let response = fetch_with_context(&mut request, &mut context);
let _ = server.close(); 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); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &mut context); let response = fetch_with_context(&mut request, &mut context);
let _ = server.close(); 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 (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::POST)
method: Method::POST, .body(Some(content.to_vec()))
body: Some(content.to_vec()), .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -879,15 +862,14 @@ fn test_load_uses_explicit_accept_from_headers_in_load_data() {
let mut accept_headers = HeaderMap::new(); let mut accept_headers = HeaderMap::new();
accept_headers.insert(header::ACCEPT, HeaderValue::from_static("text/html")); accept_headers.insert(header::ACCEPT, HeaderValue::from_static("text/html"));
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .headers(accept_headers)
headers: accept_headers, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server.close(); 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 (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server.close(); 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(); let mut accept_encoding_headers = HeaderMap::new();
accept_encoding_headers.insert(header::ACCEPT_ENCODING, HeaderValue::from_static("chunked")); accept_encoding_headers.insert(header::ACCEPT_ENCODING, HeaderValue::from_static("chunked"));
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .headers(accept_encoding_headers)
headers: accept_encoding_headers, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server.close(); 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 (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server.close(); 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()); *url_b_for_a.lock().unwrap() = Some(url_b.clone());
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url_a.clone())
url: url_a.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server_a.close(); 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()); *url_b_for_a.lock().unwrap() = Some(url_b.clone());
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url_a.clone())
url: url_a.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server_a.close(); let _ = server_a.close();
@ -1145,14 +1122,13 @@ fn test_load_follows_a_redirect() {
}; };
let (pre_server, pre_url) = make_server(pre_handler); let (pre_server, pre_url) = make_server(pre_handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(pre_url.clone())
url: pre_url.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = pre_server.close(); 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); cookie_jar.push(cookie_y, &url_y, CookieSource::HTTP);
} }
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url_x.clone())
url: url_x.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let response = fetch_with_context(&mut request, &mut context); let response = fetch_with_context(&mut request, &mut context);
let _ = server.close(); 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 url = url.join("/initial/").unwrap();
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
let _ = server.close(); 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 (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let mut context = new_fetch_context(None, None); let mut context = new_fetch_context(None, None);
let auth_entry = AuthCacheEntry { let auth_entry = AuthCacheEntry {
@ -1356,16 +1329,14 @@ fn test_auth_ui_needs_www_auth() {
}; };
let (server, url) = make_server(handler); let (server, url) = make_server(handler);
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .body(None)
body: None, .destination(Destination::Document)
destination: Destination::Document, .origin(mock_origin())
origin: mock_origin(), .pipeline_id(Some(TEST_PIPELINE_ID))
pipeline_id: Some(TEST_PIPELINE_ID), .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
@ -1395,13 +1366,12 @@ fn test_origin_set() {
let mut origin = let mut origin =
Origin::try_from_parts(url.scheme(), url.host_str().unwrap(), url.port()).unwrap(); Origin::try_from_parts(url.scheme(), url.host_str().unwrap(), url.port()).unwrap();
*origin_header_clone.lock().unwrap() = Some(origin.clone()); *origin_header_clone.lock().unwrap() = Some(origin.clone());
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::POST)
method: Method::POST, .body(None)
body: None, .origin(url.clone().origin())
origin: url.clone().origin(), .build();
..RequestInit::default()
});
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
assert!(response assert!(response
.internal_response .internal_response
@ -1415,14 +1385,12 @@ fn test_origin_set() {
origin = origin =
Origin::try_from_parts(origin_url.scheme(), origin_url.host_str().unwrap(), None).unwrap(); 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 // Test Origin header is set on Get request with CORS mode
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::GET)
method: Method::GET, .mode(RequestMode::CorsMode)
mode: RequestMode::CorsMode, .body(None)
body: None, .origin(origin_url.clone().origin())
origin: origin_url.clone().origin(), .build();
..RequestInit::default()
});
*origin_header_clone.lock().unwrap() = Some(origin.clone()); *origin_header_clone.lock().unwrap() = Some(origin.clone());
let response = fetch(&mut request, None); let response = fetch(&mut request, None);
@ -1435,13 +1403,11 @@ fn test_origin_set() {
.is_success()); .is_success());
// Test Origin header is not set on method Head // Test Origin header is not set on method Head
let mut request = Request::from_init(RequestInit { let mut request = RequestBuilder::new(url.clone())
url: url.clone(), .method(Method::HEAD)
method: Method::HEAD, .body(None)
body: None, .origin(url.clone().origin())
origin: url.clone().origin(), .build();
..RequestInit::default()
});
*origin_header_clone.lock().unwrap() = None; *origin_header_clone.lock().unwrap() = None;
let response = fetch(&mut request, 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::header::{self, HeaderMap, HeaderName, HeaderValue};
use http::uri::Authority; use http::uri::Authority;
use ipc_channel::ipc::{IpcReceiver, IpcSender}; 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::{CookieSource, MessageData};
use net_traits::{WebSocketDomAction, WebSocketNetworkEvent}; use net_traits::{WebSocketDomAction, WebSocketNetworkEvent};
use openssl::ssl::SslStream; use openssl::ssl::SslStream;
@ -174,21 +174,23 @@ impl<'a> Handler for Client<'a> {
} }
pub fn init( pub fn init(
req_init: RequestInit, req_builder: RequestBuilder,
resource_event_sender: IpcSender<WebSocketNetworkEvent>, resource_event_sender: IpcSender<WebSocketNetworkEvent>,
dom_action_receiver: IpcReceiver<WebSocketDomAction>, dom_action_receiver: IpcReceiver<WebSocketDomAction>,
http_state: Arc<HttpState>, http_state: Arc<HttpState>,
) { ) {
thread::Builder::new() thread::Builder::new()
.name(format!("WebSocket connection to {}", req_init.url)) .name(format!("WebSocket connection to {}", req_builder.url))
.spawn(move || { .spawn(move || {
let protocols = match req_init.mode { let protocols = match req_builder.mode {
RequestMode::WebSocket { protocols } => protocols, 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 scheme = req_builder.url.scheme();
let mut req_url = req_init.url.clone(); let mut req_url = req_builder.url.clone();
if scheme == "ws" { if scheme == "ws" {
req_url.as_mut_url().set_scheme("http").unwrap(); req_url.as_mut_url().set_scheme("http").unwrap();
} else if scheme == "wss" { } else if scheme == "wss" {
@ -201,15 +203,15 @@ pub fn init(
return; return;
} }
let host = replace_host(req_init.url.host_str().unwrap()); let host = replace_host(req_builder.url.host_str().unwrap());
let mut net_url = req_init.url.clone().into_url(); let mut net_url = req_builder.url.clone().into_url();
net_url.set_host(Some(&host)).unwrap(); net_url.set_host(Some(&host)).unwrap();
let host = Host::from( let host = Host::from(
format!( format!(
"{}{}", "{}{}",
req_init.url.host_str().unwrap(), req_builder.url.host_str().unwrap(),
req_init req_builder
.url .url
.port_or_known_default() .port_or_known_default()
.map(|v| format!(":{}", v)) .map(|v| format!(":{}", v))
@ -220,11 +222,11 @@ pub fn init(
); );
let client = Client { let client = Client {
origin: &req_init.origin.ascii_serialization(), origin: &req_builder.origin.ascii_serialization(),
host: &host, host: &host,
protocols: &protocols, protocols: &protocols,
http_state: &http_state, http_state: &http_state,
resource_url: &req_init.url, resource_url: &req_builder.url,
event_sender: &resource_event_sender, event_sender: &resource_event_sender,
protocol_in_use: None, protocol_in_use: None,
}; };

10
components/net_traits/lib.rs
View file

@ -18,7 +18,7 @@ extern crate serde;
extern crate url; extern crate url;
use crate::filemanager_thread::FileManagerThreadMsg; use crate::filemanager_thread::FileManagerThreadMsg;
use crate::request::{Request, RequestInit}; use crate::request::{Request, RequestBuilder};
use crate::response::{HttpsState, Response, ResponseInit}; use crate::response::{HttpsState, Response, ResponseInit};
use crate::storage_thread::StorageThreadMsg; use crate::storage_thread::StorageThreadMsg;
use cookie::Cookie; use cookie::Cookie;
@ -377,10 +377,10 @@ pub enum FetchChannels {
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
pub enum CoreResourceMsg { pub enum CoreResourceMsg {
Fetch(RequestInit, FetchChannels), Fetch(RequestBuilder, FetchChannels),
/// Initiate a fetch in response to processing a redirection /// Initiate a fetch in response to processing a redirection
FetchRedirect( FetchRedirect(
RequestInit, RequestBuilder,
ResponseInit, ResponseInit,
IpcSender<FetchResponseMsg>, IpcSender<FetchResponseMsg>,
/* cancel_chan */ Option<IpcReceiver<()>>, /* cancel_chan */ Option<IpcReceiver<()>>,
@ -415,7 +415,7 @@ pub enum CoreResourceMsg {
} }
/// Instruct the resource thread to make a new request. /// 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 where
F: Fn(FetchResponseMsg) + Send + 'static, F: Fn(FetchResponseMsg) + Send + 'static,
{ {
@ -595,7 +595,7 @@ pub enum CookieSource {
/// Convenience function for synchronously loading a whole resource. /// Convenience function for synchronously loading a whole resource.
pub fn load_whole_resource( pub fn load_whole_resource(
request: RequestInit, request: RequestBuilder,
core_resource_thread: &CoreResourceThread, core_resource_thread: &CoreResourceThread,
) -> Result<(Metadata, Vec<u8>), NetworkError> { ) -> Result<(Metadata, Vec<u8>), NetworkError> {
let (action_sender, action_receiver) = ipc::channel().unwrap(); 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 hyper::Method;
use msg::constellation_msg::PipelineId; use msg::constellation_msg::PipelineId;
use servo_url::{ImmutableOrigin, ServoUrl}; use servo_url::{ImmutableOrigin, ServoUrl};
use std::default::Default;
/// An [initiator](https://fetch.spec.whatwg.org/#concept-request-initiator) /// An [initiator](https://fetch.spec.whatwg.org/#concept-request-initiator)
#[derive(Clone, Copy, MallocSizeOf, PartialEq)] #[derive(Clone, Copy, MallocSizeOf, PartialEq)]
@ -136,7 +135,7 @@ pub enum CorsSettings {
} }
#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)] #[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
pub struct RequestInit { pub struct RequestBuilder {
#[serde( #[serde(
deserialize_with = "::hyper_serde::deserialize", deserialize_with = "::hyper_serde::deserialize",
serialize_with = "::hyper_serde::serialize" serialize_with = "::hyper_serde::serialize"
@ -172,11 +171,11 @@ pub struct RequestInit {
pub url_list: Vec<ServoUrl>, pub url_list: Vec<ServoUrl>,
} }
impl Default for RequestInit { impl RequestBuilder {
fn default() -> RequestInit { pub fn new(url: ServoUrl) -> RequestBuilder {
RequestInit { RequestBuilder {
method: Method::GET, method: Method::GET,
url: ServoUrl::parse("about:blank").unwrap(), url: url,
headers: HeaderMap::new(), headers: HeaderMap::new(),
unsafe_request: false, unsafe_request: false,
body: None, body: None,
@ -197,6 +196,139 @@ impl Default for RequestInit {
url_list: vec![], 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 /// 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> /// <https://fetch.spec.whatwg.org/#concept-request-url>
pub fn url(&self) -> ServoUrl { pub fn url(&self) -> ServoUrl {
self.url_list.first().unwrap().clone() 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::dom::document::Document;
use crate::fetch::FetchCanceller; use crate::fetch::FetchCanceller;
use ipc_channel::ipc::IpcSender; use ipc_channel::ipc::IpcSender;
use net_traits::request::RequestInit; use net_traits::request::RequestBuilder;
use net_traits::{CoreResourceMsg, FetchChannels, FetchResponseMsg}; use net_traits::{CoreResourceMsg, FetchChannels, FetchResponseMsg};
use net_traits::{IpcSend, ResourceThreads}; use net_traits::{IpcSend, ResourceThreads};
use servo_url::ServoUrl; use servo_url::ServoUrl;
@ -131,7 +131,7 @@ impl DocumentLoader {
pub fn fetch_async( pub fn fetch_async(
&mut self, &mut self,
load: LoadType, load: LoadType,
request: RequestInit, request: RequestBuilder,
fetch_target: IpcSender<FetchResponseMsg>, fetch_target: IpcSender<FetchResponseMsg>,
) { ) {
self.add_blocking_load(load); self.add_blocking_load(load);
@ -141,7 +141,7 @@ impl DocumentLoader {
/// Initiate a new fetch that does not block the document load event. /// Initiate a new fetch that does not block the document load event.
pub fn fetch_async_background( pub fn fetch_async_background(
&mut self, &mut self,
request: RequestInit, request: RequestBuilder,
fetch_target: IpcSender<FetchResponseMsg>, fetch_target: IpcSender<FetchResponseMsg>,
) { ) {
let mut canceller = FetchCanceller::new(); 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::filemanager_thread::RelativePos;
use net_traits::image::base::{Image, ImageMetadata}; use net_traits::image::base::{Image, ImageMetadata};
use net_traits::image_cache::{ImageCache, PendingImageId}; 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::HttpsState;
use net_traits::response::{Response, ResponseBody}; use net_traits::response::{Response, ResponseBody};
use net_traits::storage_thread::StorageType; use net_traits::storage_thread::StorageType;
@ -446,7 +446,7 @@ unsafe_no_jsmanaged_fields!(PendingRestyle);
unsafe_no_jsmanaged_fields!(Stylesheet); unsafe_no_jsmanaged_fields!(Stylesheet);
unsafe_no_jsmanaged_fields!(HttpsState); unsafe_no_jsmanaged_fields!(HttpsState);
unsafe_no_jsmanaged_fields!(Request); unsafe_no_jsmanaged_fields!(Request);
unsafe_no_jsmanaged_fields!(RequestInit); unsafe_no_jsmanaged_fields!(RequestBuilder);
unsafe_no_jsmanaged_fields!(StyleSharedRwLock); unsafe_no_jsmanaged_fields!(StyleSharedRwLock);
unsafe_no_jsmanaged_fields!(USVString); unsafe_no_jsmanaged_fields!(USVString);
unsafe_no_jsmanaged_fields!(ReferrerPolicy); 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::jsval::UndefinedValue;
use js::rust::HandleValue; use js::rust::HandleValue;
use msg::constellation_msg::{PipelineId, TopLevelBrowsingContextId}; 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 net_traits::{load_whole_resource, IpcSend};
use script_traits::{TimerEvent, TimerSource, WorkerGlobalScopeInit, WorkerScriptLoadOrigin}; use script_traits::{TimerEvent, TimerSource, WorkerGlobalScopeInit, WorkerScriptLoadOrigin};
use servo_rand::random; use servo_rand::random;
@ -305,17 +305,14 @@ impl DedicatedWorkerGlobalScope {
pipeline_id, pipeline_id,
} = worker_load_origin; } = worker_load_origin;
let request = RequestInit { let request = RequestBuilder::new(worker_url.clone())
url: worker_url.clone(), .destination(Destination::Worker)
destination: Destination::Worker, .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .use_url_credentials(true)
use_url_credentials: true, .pipeline_id(pipeline_id)
pipeline_id: pipeline_id, .referrer_url(referrer_url)
referrer_url: referrer_url, .referrer_policy(referrer_policy)
referrer_policy: referrer_policy, .origin(origin);
origin,
..RequestInit::default()
};
let (metadata, bytes) = let (metadata, bytes) =
match load_whole_resource(request, &init.resource_threads.sender()) { 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 mime::{self, Mime};
use msg::constellation_msg::BrowsingContextId; use msg::constellation_msg::BrowsingContextId;
use net_traits::pub_domains::is_pub_domain; 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::response::HttpsState;
use net_traits::CookieSource::NonHTTP; use net_traits::CookieSource::NonHTTP;
use net_traits::CoreResourceMsg::{GetCookiesForUrl, SetCookiesForUrl}; use net_traits::CoreResourceMsg::{GetCookiesForUrl, SetCookiesForUrl};
@ -1712,7 +1712,7 @@ impl Document {
pub fn fetch_async( pub fn fetch_async(
&self, &self,
load: LoadType, load: LoadType,
request: RequestInit, request: RequestBuilder,
fetch_target: IpcSender<FetchResponseMsg>, fetch_target: IpcSender<FetchResponseMsg>,
) { ) {
let mut loader = self.loader.borrow_mut(); 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 js::jsval::UndefinedValue;
use mime::{self, Mime}; use mime::{self, Mime};
use net_traits::request::{CacheMode, CorsSettings, CredentialsMode}; 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::{CoreResourceMsg, FetchChannels, FetchMetadata};
use net_traits::{FetchResponseListener, FetchResponseMsg, NetworkError}; use net_traits::{FetchResponseListener, FetchResponseMsg, NetworkError};
use net_traits::{ResourceFetchTiming, ResourceTimingType}; use net_traits::{ResourceFetchTiming, ResourceTimingType};
@ -61,7 +61,7 @@ enum ReadyState {
pub struct EventSource { pub struct EventSource {
eventtarget: EventTarget, eventtarget: EventTarget,
url: ServoUrl, url: ServoUrl,
request: DomRefCell<Option<RequestInit>>, request: DomRefCell<Option<RequestBuilder>>,
last_event_id: DomRefCell<DOMString>, last_event_id: DomRefCell<DOMString>,
reconnection_time: Cell<u64>, reconnection_time: Cell<u64>,
generation_id: Cell<GenerationId>, 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() self.request.borrow().clone().unwrap()
} }
@ -519,20 +519,18 @@ impl EventSource {
}; };
// Step 8 // Step 8
// TODO: Step 9 set request's client settings // TODO: Step 9 set request's client settings
let mut request = RequestInit { let mut request = RequestBuilder::new(url_record)
url: url_record, .origin(global.origin().immutable().clone())
origin: global.origin().immutable().clone(), .pipeline_id(Some(global.pipeline_id()))
pipeline_id: Some(global.pipeline_id()),
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request // https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
use_url_credentials: true, .use_url_credentials(true)
mode: RequestMode::CorsMode, .mode(RequestMode::CorsMode)
credentials_mode: if cors_attribute_state == CorsSettings::Anonymous { .credentials_mode(if cors_attribute_state == CorsSettings::Anonymous {
CredentialsMode::CredentialsSameOrigin CredentialsMode::CredentialsSameOrigin
} else { } else {
CredentialsMode::Include CredentialsMode::Include
}, });
..RequestInit::default()
};
// Step 10 // Step 10
// TODO(eijebong): Replace once typed headers allow it // TODO(eijebong): Replace once typed headers allow it
request.headers.insert( 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::UsePlaceholder;
use net_traits::image_cache::{CanRequestImages, ImageCache, ImageOrMetadataAvailable}; use net_traits::image_cache::{CanRequestImages, ImageCache, ImageOrMetadataAvailable};
use net_traits::image_cache::{ImageResponder, ImageResponse, ImageState, PendingImageId}; 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::{FetchMetadata, FetchResponseListener, FetchResponseMsg, NetworkError};
use net_traits::{ResourceFetchTiming, ResourceTimingType}; use net_traits::{ResourceFetchTiming, ResourceTimingType};
use num_traits::ToPrimitive; use num_traits::ToPrimitive;
@ -324,12 +324,9 @@ impl HTMLImageElement {
}), }),
); );
let request = RequestInit { let request = RequestBuilder::new(img_url.clone())
url: img_url.clone(), .origin(document.origin().immutable().clone())
origin: document.origin().immutable().clone(), .pipeline_id(Some(document.global().pipeline_id()));
pipeline_id: Some(document.global().pipeline_id()),
..RequestInit::default()
};
// This is a background load because the load blocker already fulfills the // This is a background load because the load blocker already fulfills the
// purpose of delaying the document's load event. // 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 mime::{self, Mime};
use net_traits::image::base::Image; use net_traits::image::base::Image;
use net_traits::image_cache::ImageResponse; 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::{CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseListener, Metadata};
use net_traits::{NetworkError, ResourceFetchTiming, ResourceTimingType}; use net_traits::{NetworkError, ResourceFetchTiming, ResourceTimingType};
use script_layout_interface::HTMLMediaData; use script_layout_interface::HTMLMediaData;
@ -710,18 +710,16 @@ impl HTMLMediaElement {
Some(url) => url.clone(), Some(url) => url.clone(),
None => self.blob_url.borrow().as_ref().unwrap().clone(), None => self.blob_url.borrow().as_ref().unwrap().clone(),
}; };
let request = RequestInit {
url: url.clone(), let request = RequestBuilder::new(url.clone())
headers, .headers(headers)
destination, .destination(destination)
credentials_mode: CredentialsMode::Include, .credentials_mode(CredentialsMode::Include)
use_url_credentials: true, .use_url_credentials(true)
origin: document.origin().immutable().clone(), .origin(document.origin().immutable().clone())
pipeline_id: Some(self.global().pipeline_id()), .pipeline_id(Some(self.global().pipeline_id()))
referrer_url: Some(document.url()), .referrer_url(Some(document.url()))
referrer_policy: document.get_referrer_policy(), .referrer_policy(document.get_referrer_policy());
..RequestInit::default()
};
let mut current_fetch_context = self.current_fetch_context.borrow_mut(); let mut current_fetch_context = self.current_fetch_context.borrow_mut();
if let Some(ref mut current_fetch_context) = *current_fetch_context { 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::ipc;
use ipc_channel::router::ROUTER; use ipc_channel::router::ROUTER;
use js::jsval::UndefinedValue; 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::{FetchMetadata, FetchResponseListener, Metadata, NetworkError};
use net_traits::{ResourceFetchTiming, ResourceTimingType}; use net_traits::{ResourceFetchTiming, ResourceTimingType};
use servo_atoms::Atom; use servo_atoms::Atom;
@ -290,28 +292,25 @@ fn fetch_a_classic_script(
let doc = document_from_node(script); let doc = document_from_node(script);
// Step 1, 2. // Step 1, 2.
let request = RequestInit { let request = RequestBuilder::new(url.clone())
url: url.clone(), .destination(Destination::Script)
destination: Destination::Script,
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request // https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
// Step 1 // Step 1
mode: match cors_setting { .mode(match cors_setting {
Some(_) => RequestMode::CorsMode, Some(_) => RequestMode::CorsMode,
None => RequestMode::NoCors, None => RequestMode::NoCors,
}, })
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request // https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
// Step 3-4 // Step 3-4
credentials_mode: match cors_setting { .credentials_mode(match cors_setting {
Some(CorsSettings::Anonymous) => CredentialsMode::CredentialsSameOrigin, Some(CorsSettings::Anonymous) => CredentialsMode::CredentialsSameOrigin,
_ => CredentialsMode::Include, _ => CredentialsMode::Include,
}, })
origin: doc.origin().immutable().clone(), .origin(doc.origin().immutable().clone())
pipeline_id: Some(script.global().pipeline_id()), .pipeline_id(Some(script.global().pipeline_id()))
referrer_url: Some(doc.url()), .referrer_url(Some(doc.url()))
referrer_policy: doc.get_referrer_policy(), .referrer_policy(doc.get_referrer_policy())
integrity_metadata: integrity_metadata, .integrity_metadata(integrity_metadata);
..RequestInit::default()
};
// TODO: Step 3, Add custom steps to perform fetch // 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::UsePlaceholder;
use net_traits::image_cache::{CanRequestImages, ImageCache, ImageOrMetadataAvailable}; use net_traits::image_cache::{CanRequestImages, ImageCache, ImageOrMetadataAvailable};
use net_traits::image_cache::{ImageResponse, ImageState, PendingImageId}; 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::{ use net_traits::{
CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseListener, FetchResponseMsg, CoreResourceMsg, FetchChannels, FetchMetadata, FetchResponseListener, FetchResponseMsg,
}; };
@ -162,15 +162,12 @@ impl HTMLVideoElement {
) { ) {
// Continuation of step 4. // Continuation of step 4.
let document = document_from_node(self); let document = document_from_node(self);
let request = RequestInit { let request = RequestBuilder::new(poster_url.clone())
url: poster_url.clone(), .destination(Destination::Image)
destination: Destination::Image, .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .use_url_credentials(true)
use_url_credentials: true, .origin(document.origin().immutable().clone())
origin: document.origin().immutable().clone(), .pipeline_id(Some(document.global().pipeline_id()));
pipeline_id: Some(document.global().pipeline_id()),
..RequestInit::default()
};
// Step 5. // Step 5.
// This delay must be independent from the ones created by HTMLMediaElement during // 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::jsapi::{JSAutoCompartment, JSContext, JS_AddInterruptCallback};
use js::jsval::UndefinedValue; use js::jsval::UndefinedValue;
use msg::constellation_msg::PipelineId; 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 net_traits::{load_whole_resource, CustomResponseMediator, IpcSend};
use script_traits::{ use script_traits::{
ScopeThings, ServiceWorkerMsg, TimerEvent, WorkerGlobalScopeInit, WorkerScriptLoadOrigin, ScopeThings, ServiceWorkerMsg, TimerEvent, WorkerGlobalScopeInit, WorkerScriptLoadOrigin,
@ -281,17 +281,14 @@ impl ServiceWorkerGlobalScope {
pipeline_id, pipeline_id,
} = worker_load_origin; } = worker_load_origin;
let request = RequestInit { let request = RequestBuilder::new(script_url.clone())
url: script_url.clone(), .destination(Destination::ServiceWorker)
destination: Destination::ServiceWorker, .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .use_url_credentials(true)
use_url_credentials: true, .pipeline_id(pipeline_id)
pipeline_id: pipeline_id, .referrer_url(referrer_url)
referrer_url: referrer_url, .referrer_policy(referrer_policy)
referrer_policy: referrer_policy, .origin(origin);
origin,
..RequestInit::default()
};
let (url, source) = let (url, source) =
match load_whole_resource(request, &init.resource_threads.sender()) { 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::jsval::UndefinedValue;
use js::rust::CustomAutoRooterGuard; use js::rust::CustomAutoRooterGuard;
use js::typedarray::{ArrayBuffer, ArrayBufferView, CreateWith}; 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::MessageData;
use net_traits::{CoreResourceMsg, FetchChannels}; use net_traits::{CoreResourceMsg, FetchChannels};
use net_traits::{WebSocketDomAction, WebSocketNetworkEvent}; use net_traits::{WebSocketDomAction, WebSocketNetworkEvent};
@ -201,12 +201,10 @@ impl WebSocket {
let address = Trusted::new(&*ws); let address = Trusted::new(&*ws);
// Step 8. // Step 8.
let request = RequestInit { let request = RequestBuilder::new(url_record)
url: url_record, .origin(global.origin().immutable().clone())
origin: global.origin().immutable().clone(), .mode(RequestMode::WebSocket { protocols });
mode: RequestMode::WebSocket { protocols },
..RequestInit::default()
};
let channels = FetchChannels::WebSocket { let channels = FetchChannels::WebSocket {
event_sender: resource_event_sender, event_sender: resource_event_sender,
action_receiver: resource_action_receiver, 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::panic::maybe_resume_unwind;
use js::rust::{HandleValue, ParentRuntime}; use js::rust::{HandleValue, ParentRuntime};
use msg::constellation_msg::PipelineId; 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 net_traits::{load_whole_resource, IpcSend};
use script_traits::WorkerGlobalScopeInit; use script_traits::WorkerGlobalScopeInit;
use script_traits::{TimerEvent, TimerEventId}; use script_traits::{TimerEvent, TimerEventId};
@ -207,17 +207,15 @@ impl WorkerGlobalScopeMethods for WorkerGlobalScope {
rooted!(in(self.runtime.cx()) let mut rval = UndefinedValue()); rooted!(in(self.runtime.cx()) let mut rval = UndefinedValue());
for url in urls { for url in urls {
let global_scope = self.upcast::<GlobalScope>(); let global_scope = self.upcast::<GlobalScope>();
let request = NetRequestInit { let request = NetRequestInit::new(url.clone())
url: url.clone(), .destination(Destination::Script)
destination: Destination::Script, .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .use_url_credentials(true)
use_url_credentials: true, .origin(global_scope.origin().immutable().clone())
origin: global_scope.origin().immutable().clone(), .pipeline_id(Some(self.upcast::<GlobalScope>().pipeline_id()))
pipeline_id: Some(self.upcast::<GlobalScope>().pipeline_id()), .referrer_url(None)
referrer_url: None, .referrer_policy(None);
referrer_policy: None, ;
..NetRequestInit::default()
};
let (url, source) = let (url, source) =
match load_whole_resource(request, &global_scope.resource_threads().sender()) { match load_whole_resource(request, &global_scope.resource_threads().sender()) {
Err(_) => return Err(Error::Network), 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 msg::constellation_msg::PipelineId;
use net_traits::load_whole_resource; use net_traits::load_whole_resource;
use net_traits::request::Destination; use net_traits::request::Destination;
use net_traits::request::RequestInit; use net_traits::request::RequestBuilder;
use net_traits::request::RequestMode; use net_traits::request::RequestMode;
use net_traits::IpcSend; use net_traits::IpcSend;
use servo_url::ImmutableOrigin; use servo_url::ImmutableOrigin;
@ -620,14 +620,12 @@ impl WorkletThread {
// TODO: Fetch the script asynchronously? // TODO: Fetch the script asynchronously?
// TODO: Caching. // TODO: Caching.
let resource_fetcher = self.global_init.resource_threads.sender(); let resource_fetcher = self.global_init.resource_threads.sender();
let request = RequestInit { let request = RequestBuilder::new(script_url)
url: script_url, .destination(Destination::Script)
destination: Destination::Script, .mode(RequestMode::CorsMode)
mode: RequestMode::CorsMode, .credentials_mode(credentials.into())
credentials_mode: credentials.into(), .origin(origin);
origin,
..RequestInit::default()
};
let script = load_whole_resource(request, &resource_fetcher) let script = load_whole_resource(request, &resource_fetcher)
.ok() .ok()
.and_then(|(_, bytes)| String::from_utf8(bytes).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::rust::wrappers::JS_ParseJSON;
use js::typedarray::{ArrayBuffer, CreateWith}; use js::typedarray::{ArrayBuffer, CreateWith};
use mime::{self, Mime, Name}; 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::trim_http_whitespace;
use net_traits::CoreResourceMsg::Fetch; use net_traits::CoreResourceMsg::Fetch;
use net_traits::{FetchChannels, FetchMetadata, FilteredMetadata}; use net_traits::{FetchChannels, FetchMetadata, FilteredMetadata};
@ -233,7 +233,7 @@ impl XMLHttpRequest {
context: Arc<Mutex<XHRContext>>, context: Arc<Mutex<XHRContext>>,
task_source: NetworkingTaskSource, task_source: NetworkingTaskSource,
global: &GlobalScope, global: &GlobalScope,
init: RequestInit, init: RequestBuilder,
cancellation_chan: ipc::IpcReceiver<()>, cancellation_chan: ipc::IpcReceiver<()>,
) { ) {
impl FetchResponseListener for XHRContext { impl FetchResponseListener for XHRContext {
@ -638,27 +638,24 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
unreachable!() unreachable!()
}; };
let mut request = RequestInit { let mut request = RequestBuilder::new(self.request_url.borrow().clone().unwrap())
method: self.request_method.borrow().clone(), .method(self.request_method.borrow().clone())
url: self.request_url.borrow().clone().unwrap(), .headers((*self.request_headers.borrow()).clone())
headers: (*self.request_headers.borrow()).clone(), .unsafe_request(true)
unsafe_request: true,
// XXXManishearth figure out how to avoid this clone // 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 // XXXManishearth actually "subresource", but it doesn't exist
// https://github.com/whatwg/xhr/issues/71 // https://github.com/whatwg/xhr/issues/71
destination: Destination::None, .destination(Destination::None)
synchronous: self.sync.get(), .synchronous(self.sync.get())
mode: RequestMode::CorsMode, .mode(RequestMode::CorsMode)
use_cors_preflight: has_handlers, .use_cors_preflight(has_handlers)
credentials_mode: credentials_mode, .credentials_mode(credentials_mode)
use_url_credentials: use_url_credentials, .use_url_credentials(use_url_credentials)
origin: self.global().origin().immutable().clone(), .origin(self.global().origin().immutable().clone())
referrer_url: self.referrer_url.clone(), .referrer_url(self.referrer_url.clone())
referrer_policy: self.referrer_policy.clone(), .referrer_policy(self.referrer_policy.clone())
pipeline_id: Some(self.global().pipeline_id()), .pipeline_id(Some(self.global().pipeline_id()));
..RequestInit::default()
};
// step 4 (second half) // step 4 (second half)
match extracted_or_serialized { match extracted_or_serialized {
@ -1458,7 +1455,7 @@ impl XMLHttpRequest {
self.response_status.set(Err(())); 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 xhr = Trusted::new(self);
let context = Arc::new(Mutex::new(XHRContext { 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::ipc;
use ipc_channel::router::ROUTER; use ipc_channel::router::ROUTER;
use js::jsapi::JSAutoCompartment; 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::request::{Request as NetTraitsRequest, ServiceWorkersMode};
use net_traits::CoreResourceMsg::Fetch as NetTraitsFetch; use net_traits::CoreResourceMsg::Fetch as NetTraitsFetch;
use net_traits::{FetchChannels, FetchResponseListener, NetworkError}; 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()) request.referrer.to_url().map(|url| url.clone())
} }
fn request_init_from_request(request: NetTraitsRequest) -> NetTraitsRequestInit { fn request_init_from_request(request: NetTraitsRequest) -> RequestBuilder {
NetTraitsRequestInit { RequestBuilder {
method: request.method.clone(), method: request.method.clone(),
url: request.url(), url: request.url(),
headers: request.headers.clone(), headers: request.headers.clone(),
unsafe_request: request.unsafe_request, unsafe_request: request.unsafe_request,
body: request.body.clone(), body: request.body.clone(),
service_workers_mode: ServiceWorkersMode::All,
destination: request.destination, destination: request.destination,
synchronous: request.synchronous, synchronous: request.synchronous,
mode: request.mode.clone(), mode: request.mode.clone(),
cache_mode: request.cache_mode,
use_cors_preflight: request.use_cors_preflight, use_cors_preflight: request.use_cors_preflight,
credentials_mode: request.credentials_mode, credentials_mode: request.credentials_mode,
use_url_credentials: request.use_url_credentials, use_url_credentials: request.use_url_credentials,
@ -120,8 +122,8 @@ fn request_init_from_request(request: NetTraitsRequest) -> NetTraitsRequestInit
referrer_policy: request.referrer_policy, referrer_policy: request.referrer_policy,
pipeline_id: request.pipeline_id, pipeline_id: request.pipeline_id,
redirect_mode: request.redirect_mode, redirect_mode: request.redirect_mode,
cache_mode: request.cache_mode, integrity_metadata: "".to_owned(),
..NetTraitsRequestInit::default() 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::ipc;
use ipc_channel::router::ROUTER; use ipc_channel::router::ROUTER;
use net_traits::image_cache::{ImageCache, PendingImageId}; 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::{FetchMetadata, FetchResponseListener, FetchResponseMsg, NetworkError};
use net_traits::{ResourceFetchTiming, ResourceTimingType}; use net_traits::{ResourceFetchTiming, ResourceTimingType};
use servo_url::ServoUrl; use servo_url::ServoUrl;
@ -110,13 +110,10 @@ pub fn fetch_image_for_layout(
}), }),
); );
let request = FetchRequestInit { let request = FetchRequestInit::new(url)
url: url, .origin(document.origin().immutable().clone())
origin: document.origin().immutable().clone(), .destination(Destination::Image)
destination: Destination::Image, .pipeline_id(Some(document.global().pipeline_id()));
pipeline_id: Some(document.global().pipeline_id()),
..FetchRequestInit::default()
};
// Layout image loads do not delay the document load event. // Layout image loads do not delay the document load event.
document 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::{HangAnnotation, MonitoredComponentId, MonitoredComponentType};
use msg::constellation_msg::{PipelineNamespace, TopLevelBrowsingContextId}; use msg::constellation_msg::{PipelineNamespace, TopLevelBrowsingContextId};
use net_traits::image_cache::{ImageCache, PendingImageResponse}; 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::storage_thread::StorageType;
use net_traits::{FetchMetadata, FetchResponseListener, FetchResponseMsg}; use net_traits::{FetchMetadata, FetchResponseListener, FetchResponseMsg};
use net_traits::{ use net_traits::{
@ -3327,21 +3327,18 @@ impl ScriptThread {
/// argument until a notification is received that the fetch is complete. /// argument until a notification is received that the fetch is complete.
fn pre_page_load(&self, mut incomplete: InProgressLoad, load_data: LoadData) { fn pre_page_load(&self, mut incomplete: InProgressLoad, load_data: LoadData) {
let id = incomplete.pipeline_id.clone(); let id = incomplete.pipeline_id.clone();
let req_init = RequestInit { let req_init = RequestBuilder::new(load_data.url.clone())
url: load_data.url.clone(), .method(load_data.method)
method: load_data.method, .destination(Destination::Document)
destination: Destination::Document, .credentials_mode(CredentialsMode::Include)
credentials_mode: CredentialsMode::Include, .use_url_credentials(true)
use_url_credentials: true, .pipeline_id(Some(id))
pipeline_id: Some(id), .referrer_url(load_data.referrer_url)
referrer_url: load_data.referrer_url, .referrer_policy(load_data.referrer_policy)
referrer_policy: load_data.referrer_policy, .headers(load_data.headers)
headers: load_data.headers, .body(load_data.data)
body: load_data.data, .redirect_mode(RedirectMode::Manual)
redirect_mode: RedirectMode::Manual, .origin(incomplete.origin.immutable().clone());
origin: incomplete.origin.immutable().clone(),
..RequestInit::default()
};
let context = ParserContext::new(id, load_data.url); let context = ParserContext::new(id, load_data.url);
self.incomplete_parser_contexts 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::ipc;
use ipc_channel::router::ROUTER; use ipc_channel::router::ROUTER;
use mime::{self, Mime}; 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::{ use net_traits::{
FetchMetadata, FetchResponseListener, FilteredMetadata, Metadata, NetworkError, ReferrerPolicy, FetchMetadata, FetchResponseListener, FilteredMetadata, Metadata, NetworkError, ReferrerPolicy,
}; };
@ -308,28 +310,25 @@ impl<'a> StylesheetLoader<'a> {
document.increment_script_blocking_stylesheet_count(); document.increment_script_blocking_stylesheet_count();
} }
let request = RequestInit { let request = RequestBuilder::new(url.clone())
url: url.clone(), .destination(Destination::Style)
destination: Destination::Style,
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request // https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
// Step 1 // Step 1
mode: match cors_setting { .mode(match cors_setting {
Some(_) => RequestMode::CorsMode, Some(_) => RequestMode::CorsMode,
None => RequestMode::NoCors, None => RequestMode::NoCors,
}, })
// https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request // https://html.spec.whatwg.org/multipage/#create-a-potential-cors-request
// Step 3-4 // Step 3-4
credentials_mode: match cors_setting { .credentials_mode(match cors_setting {
Some(CorsSettings::Anonymous) => CredentialsMode::CredentialsSameOrigin, Some(CorsSettings::Anonymous) => CredentialsMode::CredentialsSameOrigin,
_ => CredentialsMode::Include, _ => CredentialsMode::Include,
}, })
origin: document.origin().immutable().clone(), .origin(document.origin().immutable().clone())
pipeline_id: Some(self.elem.global().pipeline_id()), .pipeline_id(Some(self.elem.global().pipeline_id()))
referrer_url: Some(document.url()), .referrer_url(Some(document.url()))
referrer_policy: referrer_policy, .referrer_policy(referrer_policy)
integrity_metadata: integrity_metadata, .integrity_metadata(integrity_metadata);
..RequestInit::default()
};
document.fetch_async(LoadType::Stylesheet(url), request, action_sender); 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 ipc_channel::ipc::{IpcReceiver, IpcSender};
use msg::constellation_msg::{BrowsingContextId, PipelineId, TopLevelBrowsingContextId}; use msg::constellation_msg::{BrowsingContextId, PipelineId, TopLevelBrowsingContextId};
use msg::constellation_msg::{HistoryStateId, TraversalDirection}; 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::storage_thread::StorageType;
use net_traits::CoreResourceMsg; use net_traits::CoreResourceMsg;
use servo_url::ImmutableOrigin; use servo_url::ImmutableOrigin;
@ -107,7 +107,7 @@ pub enum ScriptMsg {
ForwardToEmbedder(EmbedderMsg), ForwardToEmbedder(EmbedderMsg),
/// Requests are sent to constellation and fetches are checked manually /// Requests are sent to constellation and fetches are checked manually
/// for cross-origin loads /// for cross-origin loads
InitiateNavigateRequest(RequestInit, /* cancellation_chan */ IpcReceiver<()>), InitiateNavigateRequest(RequestBuilder, /* cancellation_chan */ IpcReceiver<()>),
/// Broadcast a storage event to every same-origin pipeline. /// Broadcast a storage event to every same-origin pipeline.
/// The strings are key, old value and new value. /// The strings are key, old value and new value.
BroadcastStorageEvent( BroadcastStorageEvent(