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

Auto merge of #16214 - nox:net, r=emilio

Browse source 
Improve the net crate

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/16214)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2017-04-03 07:47:38 -05:00 • committed by GitHub
commit c31ee6e300
14 changed files with 555 additions and 555 deletions
Download patch file Download diff file Expand all files Collapse all files

8
components/net/fetch/cors_cache.rs
View file

@ -66,7 +66,7 @@ impl CorsCacheEntry {
} }
fn match_headers(cors_cache: &CorsCacheEntry, cors_req: &Request) -> bool { fn match_headers(cors_cache: &CorsCacheEntry, cors_req: &Request) -> bool {
cors_cache.origin == *cors_req.origin.borrow() && cors_cache.origin == cors_req.origin &&
cors_cache.url == cors_req.current_url() && cors_cache.url == cors_req.current_url() &&
(cors_cache.credentials || cors_req.credentials_mode != CredentialsMode::Include) (cors_cache.credentials || cors_req.credentials_mode != CredentialsMode::Include)
} }
@ -97,7 +97,7 @@ impl CorsCache {
pub fn clear(&mut self, request: &Request) { pub fn clear(&mut self, request: &Request) {
let CorsCache(buf) = self.clone(); let CorsCache(buf) = self.clone();
let new_buf: Vec<CorsCacheEntry> = let new_buf: Vec<CorsCacheEntry> =
buf.into_iter().filter(|e| e.origin == *request.origin.borrow() && buf.into_iter().filter(|e| e.origin == request.origin &&
request.current_url() == e.url).collect(); request.current_url() == e.url).collect();
*self = CorsCache(new_buf); *self = CorsCache(new_buf);
} }
@ -127,7 +127,7 @@ impl CorsCache {
match self.find_entry_by_header(&request, header_name).map(|e| e.max_age = new_max_age) { match self.find_entry_by_header(&request, header_name).map(|e| e.max_age = new_max_age) {
Some(_) => true, Some(_) => true,
None => { None => {
self.insert(CorsCacheEntry::new(request.origin.borrow().clone(), request.current_url(), new_max_age, self.insert(CorsCacheEntry::new(request.origin.clone(), request.current_url(), new_max_age,
request.credentials_mode == CredentialsMode::Include, request.credentials_mode == CredentialsMode::Include,
HeaderOrMethod::HeaderData(header_name.to_owned()))); HeaderOrMethod::HeaderData(header_name.to_owned())));
false false
@ -149,7 +149,7 @@ impl CorsCache {
match self.find_entry_by_method(&request, method.clone()).map(|e| e.max_age = new_max_age) { match self.find_entry_by_method(&request, method.clone()).map(|e| e.max_age = new_max_age) {
Some(_) => true, Some(_) => true,
None => { None => {
self.insert(CorsCacheEntry::new(request.origin.borrow().clone(), request.current_url(), new_max_age, self.insert(CorsCacheEntry::new(request.origin.clone(), request.current_url(), new_max_age,
request.credentials_mode == CredentialsMode::Include, request.credentials_mode == CredentialsMode::Include,
HeaderOrMethod::MethodData(method))); HeaderOrMethod::MethodData(method)));
false false

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

@ -3,13 +3,14 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use blob_loader::load_blob_sync; use blob_loader::load_blob_sync;
use connector::Connector;
use data_loader::decode; use data_loader::decode;
use devtools_traits::DevtoolsControlMsg; use devtools_traits::DevtoolsControlMsg;
use fetch::cors_cache::CorsCache; use fetch::cors_cache::CorsCache;
use filemanager_thread::FileManager; use filemanager_thread::FileManager;
use http_loader::{HttpState, determine_request_referrer, http_fetch, set_default_accept_language}; use http_loader::{HttpState, determine_request_referrer, http_fetch, set_default_accept_language};
use hyper::Error; use hyper::{Error, Result as HyperResult};
use hyper::error::Result as HyperResult; use hyper::client::Pool;
use hyper::header::{Accept, AcceptLanguage, ContentLanguage, ContentType}; use hyper::header::{Accept, AcceptLanguage, ContentLanguage, ContentType};
use hyper::header::{Header, HeaderFormat, HeaderView, Headers, QualityItem}; use hyper::header::{Header, HeaderFormat, HeaderView, Headers, QualityItem};
use hyper::header::{Referer as RefererHeader, q, qitem}; use hyper::header::{Referer as RefererHeader, q, qitem};
@ -27,8 +28,8 @@ use std::fmt;
use std::fs::File; use std::fs::File;
use std::io::Read; use std::io::Read;
use std::mem; use std::mem;
use std::rc::Rc;
use std::str; use std::str;
use std::sync::Arc;
use std::sync::mpsc::{Sender, Receiver}; use std::sync::mpsc::{Sender, Receiver};
use subresource_integrity::is_response_integrity_valid; use subresource_integrity::is_response_integrity_valid;
@ -40,40 +41,41 @@ pub enum Data {
} }
pub struct FetchContext { pub struct FetchContext {
pub state: HttpState, pub state: Arc<HttpState>,
pub user_agent: Cow<'static, str>, pub user_agent: Cow<'static, str>,
pub devtools_chan: Option<Sender<DevtoolsControlMsg>>, pub devtools_chan: Option<Sender<DevtoolsControlMsg>>,
pub filemanager: FileManager, pub filemanager: FileManager,
pub connector: Arc<Pool<Connector>>,
} }
pub type DoneChannel = Option<(Sender<Data>, Receiver<Data>)>; pub type DoneChannel = Option<(Sender<Data>, Receiver<Data>)>;
/// [Fetch](https://fetch.spec.whatwg.org#concept-fetch) /// [Fetch](https://fetch.spec.whatwg.org#concept-fetch)
pub fn fetch(request: Rc<Request>, pub fn fetch(request: &mut Request,
target: Target, target: Target,
context: &FetchContext) { context: &FetchContext) {
fetch_with_cors_cache(request, &mut CorsCache::new(), target, context); fetch_with_cors_cache(request, &mut CorsCache::new(), target, context);
} }
pub fn fetch_with_cors_cache(request: Rc<Request>, pub fn fetch_with_cors_cache(request: &mut Request,
cache: &mut CorsCache, cache: &mut CorsCache,
target: Target, target: Target,
context: &FetchContext) { context: &FetchContext) {
// Step 1 // Step 1
if request.window.get() == Window::Client { if request.window == Window::Client {
// TODO: Set window to request's client object if client is a Window object // TODO: Set window to request's client object if client is a Window object
} else { } else {
request.window.set(Window::NoWindow); request.window = Window::NoWindow;
} }
// Step 2 // Step 2
if *request.origin.borrow() == Origin::Client { if request.origin == Origin::Client {
// TODO: set request's origin to request's client's origin // TODO: set request's origin to request's client's origin
unimplemented!() unimplemented!()
} }
// Step 3 // Step 3
if !request.headers.borrow().has::<Accept>() { if !request.headers.has::<Accept>() {
let value = match request.type_ { let value = match request.type_ {
// Substep 2 // Substep 2
_ if request.is_navigation_request() => _ if request.is_navigation_request() =>
@ -102,11 +104,11 @@ pub fn fetch_with_cors_cache(request: Rc<Request>,
}; };
// Substep 4 // Substep 4
request.headers.borrow_mut().set(Accept(value)); request.headers.set(Accept(value));
} }
// Step 4 // Step 4
set_default_accept_language(&mut request.headers.borrow_mut()); set_default_accept_language(&mut request.headers);
// Step 5 // Step 5
// TODO: Figure out what a Priority object is // TODO: Figure out what a Priority object is
@ -121,7 +123,7 @@ pub fn fetch_with_cors_cache(request: Rc<Request>,
} }
/// [Main fetch](https://fetch.spec.whatwg.org/#concept-main-fetch) /// [Main fetch](https://fetch.spec.whatwg.org/#concept-main-fetch)
pub fn main_fetch(request: Rc<Request>, pub fn main_fetch(request: &mut Request,
cache: &mut CorsCache, cache: &mut CorsCache,
cors_flag: bool, cors_flag: bool,
recursive_flag: bool, recursive_flag: bool,
@ -129,12 +131,10 @@ pub fn main_fetch(request: Rc<Request>,
done_chan: &mut DoneChannel, done_chan: &mut DoneChannel,
context: &FetchContext) context: &FetchContext)
-> Response { -> Response {
// TODO: Implement main fetch spec // Step 1.
// Step 1
let mut response = None; let mut response = None;
// Step 2 // Step 2.
if request.local_urls_only { if request.local_urls_only {
match request.current_url().scheme() { match request.current_url().scheme() {
"about" | "blob" | "data" | "filesystem" => (), // Ok, the URL is local. "about" | "blob" | "data" | "filesystem" => (), // Ok, the URL is local.
@ -142,120 +142,121 @@ pub fn main_fetch(request: Rc<Request>,
} }
} }
// Step 3 // Step 3.
// TODO be able to execute report CSP // TODO: handle content security policy violations.
// Step 4 // Step 4.
// TODO this step, based off of http_loader.rs (upgrade) // TODO: handle upgrade to a potentially secure URL.
// Step 5 // Step 5.
// TODO this step (CSP port/content blocking)
if should_be_blocked_due_to_bad_port(&request.url()) { if should_be_blocked_due_to_bad_port(&request.url()) {
response = Some(Response::network_error(NetworkError::Internal("Request attempted on bad port".into()))); response = Some(Response::network_error(NetworkError::Internal("Request attempted on bad port".into())));
} }
// TODO: handle blocking as mixed content.
// TODO: handle blocking by content security policy.
// Step 6 // Step 6
// TODO this step (referrer policy) // TODO: handle request's client's referrer policy.
// currently the clients themselves set referrer policy in RequestInit
// Step 7 // Step 7.
let referrer_policy = request.referrer_policy.get().unwrap_or(ReferrerPolicy::NoReferrerWhenDowngrade); let referrer_policy = request.referrer_policy.unwrap_or(ReferrerPolicy::NoReferrerWhenDowngrade);
request.referrer_policy.set(Some(referrer_policy)); request.referrer_policy = Some(referrer_policy);
// Step 8 // Step 8.
{ {
let mut referrer = request.referrer.borrow_mut(); let referrer_url = match mem::replace(&mut request.referrer, Referrer::NoReferrer) {
let referrer_url = match mem::replace(&mut *referrer, Referrer::NoReferrer) {
Referrer::NoReferrer => None, Referrer::NoReferrer => None,
Referrer::Client => { Referrer::Client => {
// FIXME(#14507): We should never get this value here; it should // FIXME(#14507): We should never get this value here; it should
// already have been handled in the script thread. // already have been handled in the script thread.
request.headers.borrow_mut().remove::<RefererHeader>(); request.headers.remove::<RefererHeader>();
None None
}, },
Referrer::ReferrerUrl(url) => { Referrer::ReferrerUrl(url) => {
request.headers.borrow_mut().remove::<RefererHeader>(); request.headers.remove::<RefererHeader>();
determine_request_referrer(&mut *request.headers.borrow_mut(), let current_url = request.current_url().clone();
determine_request_referrer(&mut request.headers,
referrer_policy, referrer_policy,
url, url,
request.current_url().clone()) current_url)
} }
}; };
if let Some(referrer_url) = referrer_url { if let Some(referrer_url) = referrer_url {
*referrer = Referrer::ReferrerUrl(referrer_url); request.referrer = Referrer::ReferrerUrl(referrer_url);
} }
} }
// Step 9 // Step 9.
// TODO: handle FTP URLs.
// Step 10.
if !request.current_url().is_secure_scheme() && request.current_url().domain().is_some() { if !request.current_url().is_secure_scheme() && request.current_url().domain().is_some() {
if context.state if context.state
.hsts_list .hsts_list
.read() .read()
.unwrap() .unwrap()
.is_host_secure(request.current_url().domain().unwrap()) { .is_host_secure(request.current_url().domain().unwrap()) {
request.url_list.borrow_mut().last_mut().unwrap().as_mut_url().set_scheme("https").unwrap(); request.url_list.last_mut().unwrap().as_mut_url().set_scheme("https").unwrap();
} }
} }
// Step 10 // Step 11.
// this step is obsoleted by fetch_async // Not applicable: see fetch_async.
// Step 11 // Step 12.
let response = match response { let response = response.unwrap_or_else(|| {
Some(response) => response, let current_url = request.current_url();
None => { let same_origin = if let Origin::Origin(ref origin) = request.origin {
let current_url = request.current_url(); *origin == current_url.origin()
let same_origin = if let Origin::Origin(ref origin) = *request.origin.borrow() { } else {
*origin == current_url.origin() false
} else { };
false
};
if (same_origin && !cors_flag ) || if (same_origin && !cors_flag ) ||
current_url.scheme() == "data" || current_url.scheme() == "data" ||
current_url.scheme() == "file" || current_url.scheme() == "file" ||
current_url.scheme() == "about" || current_url.scheme() == "about" ||
request.mode == RequestMode::Navigate { request.mode == RequestMode::Navigate {
basic_fetch(request.clone(), cache, target, done_chan, context) basic_fetch(request, cache, target, done_chan, context)
} else if request.mode == RequestMode::SameOrigin { } else if request.mode == RequestMode::SameOrigin {
Response::network_error(NetworkError::Internal("Cross-origin response".into())) Response::network_error(NetworkError::Internal("Cross-origin response".into()))
} else if request.mode == RequestMode::NoCors { } else if request.mode == RequestMode::NoCors {
request.response_tainting.set(ResponseTainting::Opaque); request.response_tainting = ResponseTainting::Opaque;
basic_fetch(request.clone(), cache, target, done_chan, context) basic_fetch(request, cache, target, done_chan, context)
} else if !matches!(current_url.scheme(), "http" | "https") { } else if !matches!(current_url.scheme(), "http" | "https") {
Response::network_error(NetworkError::Internal("Non-http scheme".into())) Response::network_error(NetworkError::Internal("Non-http scheme".into()))
} else if request.use_cors_preflight || } else if request.use_cors_preflight ||
(request.unsafe_request && (request.unsafe_request &&
(!is_simple_method(&request.method.borrow()) || (!is_simple_method(&request.method) ||
request.headers.borrow().iter().any(|h| !is_simple_header(&h)))) { request.headers.iter().any(|h| !is_simple_header(&h)))) {
request.response_tainting.set(ResponseTainting::CorsTainting); request.response_tainting = ResponseTainting::CorsTainting;
let response = http_fetch(request.clone(), cache, true, true, false, let response = http_fetch(request, cache, true, true, false,
target, done_chan, context); target, done_chan, context);
if response.is_network_error() { if response.is_network_error() {
// TODO clear cache entries using request // TODO clear cache entries using request
}
response
} else {
request.response_tainting.set(ResponseTainting::CorsTainting);
http_fetch(request.clone(), cache, true, false, false, target, done_chan, context)
} }
} response
};
// Step 12 } else {
request.response_tainting = ResponseTainting::CorsTainting;
http_fetch(request, cache, true, false, false, target, done_chan, context)
}
});
// Step 13.
if recursive_flag { if recursive_flag {
return response; return response;
} }
// Step 13 // Step 14.
// no need to check if response is a network error, since the type would not be `Default` // We don't need to check whether response is a network error,
let response = if response.response_type == ResponseType::Default { // given its type would not be `Default` in this case.
let response_type = match request.response_tainting.get() { let mut response = if response.response_type == ResponseType::Default {
let response_type = match request.response_tainting {
ResponseTainting::Basic => ResponseType::Basic, ResponseTainting::Basic => ResponseType::Basic,
ResponseTainting::CorsTainting => ResponseType::Cors, ResponseTainting::CorsTainting => ResponseType::Cors,
ResponseTainting::Opaque => ResponseType::Opaque, ResponseTainting::Opaque => ResponseType::Opaque,
@ -265,26 +266,32 @@ pub fn main_fetch(request: Rc<Request>,
response response
}; };
let internal_error = { // Inner scope to reborrow response let internal_error = {
// Step 14 // Tests for steps 17 and 18, before step 15 for borrowing concerns.
let network_error_response; let response_is_network_error = response.is_network_error();
let internal_response = if let Some(error) = response.get_network_error() { let should_replace_with_nosniff_error =
network_error_response = Response::network_error(error.clone()); !response_is_network_error && should_be_blocked_due_to_nosniff(request.type_, &response.headers);
&network_error_response
// Step 15.
let mut network_error_response = response.get_network_error().cloned().map(Response::network_error);
let internal_response = if let Some(error_response) = network_error_response.as_mut() {
error_response
} else { } else {
response.actual_response() response.actual_response_mut()
}; };
// Step 15 // Step 16.
if internal_response.url_list.borrow().is_empty() { if internal_response.url_list.is_empty() {
*internal_response.url_list.borrow_mut() = request.url_list.borrow().clone(); internal_response.url_list = request.url_list.clone();
} }
// Step 16 // Step 17.
// TODO Blocking for CSP, mixed content, MIME type // TODO: handle blocking as mixed content.
// TODO: handle blocking by content security policy.
// TODO: handle blocking due to MIME type.
let blocked_error_response; let blocked_error_response;
let internal_response = let internal_response =
if !response.is_network_error() && should_be_blocked_due_to_nosniff(request.type_, &response.headers) { if should_replace_with_nosniff_error {
// Defer rebinding result // Defer rebinding result
blocked_error_response = Response::network_error(NetworkError::Internal("Blocked by nosniff".into())); blocked_error_response = Response::network_error(NetworkError::Internal("Blocked by nosniff".into()));
&blocked_error_response &blocked_error_response
@ -292,11 +299,12 @@ pub fn main_fetch(request: Rc<Request>,
internal_response internal_response
}; };
// Step 17 // Step 18.
// We check `internal_response` since we did not mutate `response` in the previous step. // We check `internal_response` since we did not mutate `response`
let not_network_error = !response.is_network_error() && !internal_response.is_network_error(); // in the previous step.
let not_network_error = !response_is_network_error && !internal_response.is_network_error();
if not_network_error && (is_null_body_status(&internal_response.status) || if not_network_error && (is_null_body_status(&internal_response.status) ||
match *request.method.borrow() { match request.method {
Method::Head | Method::Connect => true, Method::Head | Method::Connect => true,
_ => false }) { _ => false }) {
// when Fetch is used only asynchronously, we will need to make sure // when Fetch is used only asynchronously, we will need to make sure
@ -308,22 +316,22 @@ pub fn main_fetch(request: Rc<Request>,
internal_response.get_network_error().map(|e| e.clone()) internal_response.get_network_error().map(|e| e.clone())
}; };
// Execute deferred rebinding of response // Execute deferred rebinding of response.
let response = if let Some(error) = internal_error { let response = if let Some(error) = internal_error {
Response::network_error(error) Response::network_error(error)
} else { } else {
response response
}; };
// Step 18 // Step 19.
let mut response_loaded = false; let mut response_loaded = false;
let response = if !response.is_network_error() && *request.integrity_metadata.borrow() != "" { let response = if !response.is_network_error() && !request.integrity_metadata.is_empty() {
// Substep 1 // Step 19.1.
wait_for_response(&response, target, done_chan); wait_for_response(&response, target, done_chan);
response_loaded = true; response_loaded = true;
// Substep 2 // Step 19.2.
let ref integrity_metadata = *request.integrity_metadata.borrow(); let ref integrity_metadata = &request.integrity_metadata;
if response.termination_reason.is_none() && if response.termination_reason.is_none() &&
!is_response_integrity_valid(integrity_metadata, &response) { !is_response_integrity_valid(integrity_metadata, &response) {
Response::network_error(NetworkError::Internal("Subresource integrity validation failed".into())) Response::network_error(NetworkError::Internal("Subresource integrity validation failed".into()))
@ -334,7 +342,7 @@ pub fn main_fetch(request: Rc<Request>,
response response
}; };
// Step 19 // Step 20.
if request.synchronous { if request.synchronous {
// process_response is not supposed to be used // process_response is not supposed to be used
// by sync fetch, but we overload it here for simplicity // by sync fetch, but we overload it here for simplicity
@ -347,8 +355,8 @@ pub fn main_fetch(request: Rc<Request>,
return response; return response;
} }
// Step 20 // Step 21.
if request.body.borrow().is_some() && matches!(request.current_url().scheme(), "http" | "https") { if request.body.is_some() && matches!(request.current_url().scheme(), "http" | "https") {
// XXXManishearth: We actually should be calling process_request // XXXManishearth: We actually should be calling process_request
// in http_network_fetch. However, we can't yet follow the request // in http_network_fetch. However, we can't yet follow the request
// upload progress, so I'm keeping it here for now and pretending // upload progress, so I'm keeping it here for now and pretending
@ -357,19 +365,20 @@ pub fn main_fetch(request: Rc<Request>,
target.process_request_eof(&request); target.process_request_eof(&request);
} }
// Step 21 // Step 22.
target.process_response(&response); target.process_response(&response);
// Step 22 // Step 23.
if !response_loaded { if !response_loaded {
wait_for_response(&response, target, done_chan); wait_for_response(&response, target, done_chan);
} }
// Step 24 // Step 24.
target.process_response_eof(&response); target.process_response_eof(&response);
// TODO remove this line when only asynchronous fetches are used // Steps 25-27.
return response; // TODO: remove this line when only asynchronous fetches are used
response
} }
fn wait_for_response(response: &Response, target: Target, done_chan: &mut DoneChannel) { fn wait_for_response(response: &Response, target: Target, done_chan: &mut DoneChannel) {
@ -397,7 +406,7 @@ fn wait_for_response(response: &Response, target: Target, done_chan: &mut DoneCh
} }
/// [Basic fetch](https://fetch.spec.whatwg.org#basic-fetch) /// [Basic fetch](https://fetch.spec.whatwg.org#basic-fetch)
fn basic_fetch(request: Rc<Request>, fn basic_fetch(request: &mut Request,
cache: &mut CorsCache, cache: &mut CorsCache,
target: Target, target: Target,
done_chan: &mut DoneChannel, done_chan: &mut DoneChannel,
@ -414,11 +423,11 @@ fn basic_fetch(request: Rc<Request>,
}, },
"http" | "https" => { "http" | "https" => {
http_fetch(request.clone(), cache, false, false, false, target, done_chan, context) http_fetch(request, cache, false, false, false, target, done_chan, context)
}, },
"data" => { "data" => {
if *request.method.borrow() == Method::Get { if request.method == Method::Get {
match decode(&url) { match decode(&url) {
Ok((mime, bytes)) => { Ok((mime, bytes)) => {
let mut response = Response::new(url); let mut response = Response::new(url);
@ -434,7 +443,7 @@ fn basic_fetch(request: Rc<Request>,
}, },
"file" => { "file" => {
if *request.method.borrow() == Method::Get { if request.method == Method::Get {
match url.to_file_path() { match url.to_file_path() {
Ok(file_path) => { Ok(file_path) => {
match File::open(file_path.clone()) { match File::open(file_path.clone()) {
@ -461,7 +470,7 @@ fn basic_fetch(request: Rc<Request>,
"blob" => { "blob" => {
println!("Loading blob {}", url.as_str()); println!("Loading blob {}", url.as_str());
// Step 2. // Step 2.
if *request.method.borrow() != Method::Get { if request.method != Method::Get {
return Response::network_error(NetworkError::Internal("Unexpected method for blob".into())); return Response::network_error(NetworkError::Internal("Unexpected method for blob".into()));
} }

242
components/net/http_loader.rs
View file

@ -3,7 +3,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use brotli::Decompressor; use brotli::Decompressor;
use connector::{Connector, create_http_connector, create_ssl_client}; use connector::Connector;
use cookie; use cookie;
use cookie_storage::CookieStorage; use cookie_storage::CookieStorage;
use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, HttpRequest as DevtoolsHttpRequest}; use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, HttpRequest as DevtoolsHttpRequest};
@ -44,7 +44,6 @@ use std::io::{self, Read, Write};
use std::iter::FromIterator; use std::iter::FromIterator;
use std::mem; use std::mem;
use std::ops::Deref; use std::ops::Deref;
use std::rc::Rc;
use std::sync::{Arc, RwLock}; use std::sync::{Arc, RwLock};
use std::sync::mpsc::{channel, Sender}; use std::sync::mpsc::{channel, Sender};
use std::thread; use std::thread;
@ -67,20 +66,17 @@ fn read_block<R: Read>(reader: &mut R) -> Result<Data, ()> {
} }
pub struct HttpState { pub struct HttpState {
pub hsts_list: Arc<RwLock<HstsList>>, pub hsts_list: RwLock<HstsList>,
pub cookie_jar: Arc<RwLock<CookieStorage>>, pub cookie_jar: RwLock<CookieStorage>,
pub auth_cache: Arc<RwLock<AuthCache>>, pub auth_cache: RwLock<AuthCache>,
pub connector_pool: Arc<Pool<Connector>>,
} }
impl HttpState { impl HttpState {
pub fn new(certificate_path: &str) -> HttpState { pub fn new() -> HttpState {
let ssl_client = create_ssl_client(certificate_path);
HttpState { HttpState {
hsts_list: Arc::new(RwLock::new(HstsList::new())), hsts_list: RwLock::new(HstsList::new()),
cookie_jar: Arc::new(RwLock::new(CookieStorage::new(150))), cookie_jar: RwLock::new(CookieStorage::new(150)),
auth_cache: Arc::new(RwLock::new(AuthCache::new())), auth_cache: RwLock::new(AuthCache::new()),
connector_pool: create_http_connector(ssl_client),
} }
} }
} }
@ -241,7 +237,7 @@ pub fn determine_request_referrer(headers: &mut Headers,
} }
} }
pub fn set_request_cookies(url: &ServoUrl, headers: &mut Headers, cookie_jar: &Arc<RwLock<CookieStorage>>) { pub fn set_request_cookies(url: &ServoUrl, headers: &mut Headers, cookie_jar: &RwLock<CookieStorage>) {
let mut cookie_jar = cookie_jar.write().unwrap(); let mut cookie_jar = cookie_jar.write().unwrap();
if let Some(cookie_list) = cookie_jar.cookies_for_url(url, CookieSource::HTTP) { if let Some(cookie_list) = cookie_jar.cookies_for_url(url, CookieSource::HTTP) {
let mut v = Vec::new(); let mut v = Vec::new();
@ -250,7 +246,7 @@ pub fn set_request_cookies(url: &ServoUrl, headers: &mut Headers, cookie_jar: &A
} }
} }
fn set_cookie_for_url(cookie_jar: &Arc<RwLock<CookieStorage>>, fn set_cookie_for_url(cookie_jar: &RwLock<CookieStorage>,
request: &ServoUrl, request: &ServoUrl,
cookie_val: String) { cookie_val: String) {
let mut cookie_jar = cookie_jar.write().unwrap(); let mut cookie_jar = cookie_jar.write().unwrap();
@ -266,7 +262,7 @@ fn set_cookie_for_url(cookie_jar: &Arc<RwLock<CookieStorage>>,
} }
} }
fn set_cookies_from_headers(url: &ServoUrl, headers: &Headers, cookie_jar: &Arc<RwLock<CookieStorage>>) { fn set_cookies_from_headers(url: &ServoUrl, headers: &Headers, cookie_jar: &RwLock<CookieStorage>) {
if let Some(cookies) = headers.get_raw("set-cookie") { if let Some(cookies) = headers.get_raw("set-cookie") {
for cookie in cookies.iter() { for cookie in cookies.iter() {
if let Ok(cookie_value) = String::from_utf8(cookie.clone()) { if let Ok(cookie_value) = String::from_utf8(cookie.clone()) {
@ -366,7 +362,7 @@ fn send_response_to_devtools(devtools_chan: &Sender<DevtoolsControlMsg>,
let _ = devtools_chan.send(DevtoolsControlMsg::FromChrome(msg)); let _ = devtools_chan.send(DevtoolsControlMsg::FromChrome(msg));
} }
fn auth_from_cache(auth_cache: &Arc<RwLock<AuthCache>>, origin: &ImmutableOrigin) -> Option<Basic> { fn auth_from_cache(auth_cache: &RwLock<AuthCache>, origin: &ImmutableOrigin) -> Option<Basic> {
if let Some(ref auth_entry) = auth_cache.read().unwrap().entries.get(&origin.ascii_serialization()) { if let Some(ref auth_entry) = auth_cache.read().unwrap().entries.get(&origin.ascii_serialization()) {
let user_name = auth_entry.user_name.clone(); let user_name = auth_entry.user_name.clone();
let password = Some(auth_entry.password.clone()); let password = Some(auth_entry.password.clone());
@ -477,7 +473,7 @@ fn obtain_response(request_factory: &NetworkHttpRequestFactory,
} }
/// [HTTP fetch](https://fetch.spec.whatwg.org#http-fetch) /// [HTTP fetch](https://fetch.spec.whatwg.org#http-fetch)
pub fn http_fetch(request: Rc<Request>, pub fn http_fetch(request: &mut Request,
cache: &mut CorsCache, cache: &mut CorsCache,
cors_flag: bool, cors_flag: bool,
cors_preflight_flag: bool, cors_preflight_flag: bool,
@ -495,7 +491,7 @@ pub fn http_fetch(request: Rc<Request>,
// nothing to do, since actual_response is a function on response // nothing to do, since actual_response is a function on response
// Step 3 // Step 3
if !request.skip_service_worker.get() && !request.is_service_worker_global_scope { if !request.skip_service_worker && !request.is_service_worker_global_scope {
// Substep 1 // Substep 1
// TODO (handle fetch unimplemented) // TODO (handle fetch unimplemented)
@ -507,9 +503,8 @@ pub fn http_fetch(request: Rc<Request>,
if (res.response_type == ResponseType::Opaque && if (res.response_type == ResponseType::Opaque &&
request.mode != RequestMode::NoCors) || request.mode != RequestMode::NoCors) ||
(res.response_type == ResponseType::OpaqueRedirect && (res.response_type == ResponseType::OpaqueRedirect &&
request.redirect_mode.get() != RedirectMode::Manual) || request.redirect_mode != RedirectMode::Manual) ||
(res.url_list.borrow().len() > 1 && (res.url_list.len() > 1 && request.redirect_mode != RedirectMode::Follow) ||
request.redirect_mode.get() != RedirectMode::Follow) ||
res.is_network_error() { res.is_network_error() {
return Response::network_error(NetworkError::Internal("Request failed".into())); return Response::network_error(NetworkError::Internal("Request failed".into()));
} }
@ -522,7 +517,7 @@ pub fn http_fetch(request: Rc<Request>,
// Step 4 // Step 4
let credentials = match request.credentials_mode { let credentials = match request.credentials_mode {
CredentialsMode::Include => true, CredentialsMode::Include => true,
CredentialsMode::CredentialsSameOrigin if request.response_tainting.get() == ResponseTainting::Basic CredentialsMode::CredentialsSameOrigin if request.response_tainting == ResponseTainting::Basic
=> true, => true,
_ => false _ => false
}; };
@ -532,17 +527,17 @@ pub fn http_fetch(request: Rc<Request>,
// Substep 1 // Substep 1
if cors_preflight_flag { if cors_preflight_flag {
let method_cache_match = cache.match_method(&*request, let method_cache_match = cache.match_method(&*request,
request.method.borrow().clone()); request.method.clone());
let method_mismatch = !method_cache_match && (!is_simple_method(&request.method.borrow()) || let method_mismatch = !method_cache_match && (!is_simple_method(&request.method) ||
request.use_cors_preflight); request.use_cors_preflight);
let header_mismatch = request.headers.borrow().iter().any(|view| let header_mismatch = request.headers.iter().any(|view|
!cache.match_header(&*request, view.name()) && !is_simple_header(&view) !cache.match_header(&*request, view.name()) && !is_simple_header(&view)
); );
// Sub-substep 1 // Sub-substep 1
if method_mismatch || header_mismatch { if method_mismatch || header_mismatch {
let preflight_result = cors_preflight_fetch(request.clone(), cache, context); let preflight_result = cors_preflight_fetch(&request, cache, context);
// Sub-substep 2 // Sub-substep 2
if let Some(e) = preflight_result.get_network_error() { if let Some(e) = preflight_result.get_network_error() {
return Response::network_error(e.clone()); return Response::network_error(e.clone());
@ -551,18 +546,18 @@ pub fn http_fetch(request: Rc<Request>,
} }
// Substep 2 // Substep 2
request.skip_service_worker.set(true); request.skip_service_worker = true;
// Substep 3 // Substep 3
let fetch_result = http_network_or_cache_fetch(request.clone(), authentication_fetch_flag, let mut fetch_result = http_network_or_cache_fetch(
cors_flag, done_chan, context); request, authentication_fetch_flag, cors_flag, done_chan, context);
// Substep 4 // Substep 4
if cors_flag && cors_check(request.clone(), &fetch_result).is_err() { if cors_flag && cors_check(&request, &fetch_result).is_err() {
return Response::network_error(NetworkError::Internal("CORS check failed".into())); return Response::network_error(NetworkError::Internal("CORS check failed".into()));
} }
fetch_result.return_internal.set(false); fetch_result.return_internal = false;
response = Some(fetch_result); response = Some(fetch_result);
} }
@ -573,14 +568,14 @@ pub fn http_fetch(request: Rc<Request>,
match response.actual_response().status { match response.actual_response().status {
// Code 301, 302, 303, 307, 308 // Code 301, 302, 303, 307, 308
status if status.map_or(false, is_redirect_status) => { status if status.map_or(false, is_redirect_status) => {
response = match request.redirect_mode.get() { response = match request.redirect_mode {
RedirectMode::Error => Response::network_error(NetworkError::Internal("Redirect mode error".into())), RedirectMode::Error => Response::network_error(NetworkError::Internal("Redirect mode error".into())),
RedirectMode::Manual => { RedirectMode::Manual => {
response.to_filtered(ResponseType::OpaqueRedirect) response.to_filtered(ResponseType::OpaqueRedirect)
}, },
RedirectMode::Follow => { RedirectMode::Follow => {
// set back to default // set back to default
response.return_internal.set(true); response.return_internal = true;
http_redirect_fetch(request, cache, response, http_redirect_fetch(request, cache, response,
cors_flag, target, done_chan, context) cors_flag, target, done_chan, context)
} }
@ -643,13 +638,13 @@ pub fn http_fetch(request: Rc<Request>,
} }
// set back to default // set back to default
response.return_internal.set(true); response.return_internal = true;
// Step 7 // Step 7
response response
} }
/// [HTTP redirect fetch](https://fetch.spec.whatwg.org#http-redirect-fetch) /// [HTTP redirect fetch](https://fetch.spec.whatwg.org#http-redirect-fetch)
fn http_redirect_fetch(request: Rc<Request>, fn http_redirect_fetch(request: &mut Request,
cache: &mut CorsCache, cache: &mut CorsCache,
response: Response, response: Response,
cors_flag: bool, cors_flag: bool,
@ -658,7 +653,7 @@ fn http_redirect_fetch(request: Rc<Request>,
context: &FetchContext) context: &FetchContext)
-> Response { -> Response {
// Step 1 // Step 1
assert_eq!(response.return_internal.get(), true); assert!(response.return_internal);
// Step 2 // Step 2
if !response.actual_response().headers.has::<Location>() { if !response.actual_response().headers.has::<Location>() {
@ -684,12 +679,12 @@ fn http_redirect_fetch(request: Rc<Request>,
} }
// Step 5 // Step 5
if request.redirect_count.get() >= 20 { if request.redirect_count >= 20 {
return Response::network_error(NetworkError::Internal("Too many redirects".into())); return Response::network_error(NetworkError::Internal("Too many redirects".into()));
} }
// Step 6 // Step 6
request.redirect_count.set(request.redirect_count.get() + 1); request.redirect_count += 1;
// Step 7 // Step 7
let same_origin = location_url.origin()== request.current_url().origin(); let same_origin = location_url.origin()== request.current_url().origin();
@ -706,20 +701,20 @@ fn http_redirect_fetch(request: Rc<Request>,
// Step 9 // Step 9
if cors_flag && !same_origin { if cors_flag && !same_origin {
*request.origin.borrow_mut() = Origin::Origin(ImmutableOrigin::new_opaque()); request.origin = Origin::Origin(ImmutableOrigin::new_opaque());
} }
// Step 10 // Step 10
let status_code = response.actual_response().status.unwrap(); let status_code = response.actual_response().status.unwrap();
if ((status_code == StatusCode::MovedPermanently || status_code == StatusCode::Found) && if ((status_code == StatusCode::MovedPermanently || status_code == StatusCode::Found) &&
*request.method.borrow() == Method::Post) || request.method == Method::Post) ||
status_code == StatusCode::SeeOther { status_code == StatusCode::SeeOther {
*request.method.borrow_mut() = Method::Get; request.method = Method::Get;
*request.body.borrow_mut() = None; request.body = None;
} }
// Step 11 // Step 11
request.url_list.borrow_mut().push(location_url); request.url_list.push(location_url);
// Step 12 // Step 12
// TODO implement referrer policy // TODO implement referrer policy
@ -738,7 +733,7 @@ fn try_immutable_origin_to_hyper_origin(url_origin: &ImmutableOrigin) -> Option<
} }
/// [HTTP network or cache fetch](https://fetch.spec.whatwg.org#http-network-or-cache-fetch) /// [HTTP network or cache fetch](https://fetch.spec.whatwg.org#http-network-or-cache-fetch)
fn http_network_or_cache_fetch(request: Rc<Request>, fn http_network_or_cache_fetch(request: &mut Request,
authentication_fetch_flag: bool, authentication_fetch_flag: bool,
cors_flag: bool, cors_flag: bool,
done_chan: &mut DoneChannel, done_chan: &mut DoneChannel,
@ -748,26 +743,28 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
let request_has_no_window = true; let request_has_no_window = true;
// Step 2 // Step 2
let mut http_request;
let http_request = if request_has_no_window && let http_request = if request_has_no_window &&
request.redirect_mode.get() == RedirectMode::Error { request.redirect_mode == RedirectMode::Error {
request request
} else { } else {
// Step 3 // Step 3
// TODO Implement body source // TODO Implement body source
Rc::new((*request).clone()) http_request = request.clone();
&mut http_request
}; };
// Step 4 // Step 4
let credentials_flag = match http_request.credentials_mode { let credentials_flag = match http_request.credentials_mode {
CredentialsMode::Include => true, CredentialsMode::Include => true,
CredentialsMode::CredentialsSameOrigin if http_request.response_tainting.get() == ResponseTainting::Basic CredentialsMode::CredentialsSameOrigin if http_request.response_tainting == ResponseTainting::Basic
=> true, => true,
_ => false _ => false
}; };
let content_length_value = match *http_request.body.borrow() { let content_length_value = match http_request.body {
None => None =>
match *http_request.method.borrow() { match http_request.method {
// Step 6 // Step 6
Method::Post | Method::Put => Method::Post | Method::Put =>
Some(0), Some(0),
@ -780,16 +777,16 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
// Step 8 // Step 8
if let Some(content_length_value) = content_length_value { if let Some(content_length_value) = content_length_value {
http_request.headers.borrow_mut().set(ContentLength(content_length_value)); http_request.headers.set(ContentLength(content_length_value));
} }
// Step 9 TODO: needs request's client object // Step 9 TODO: needs request's client object
// Step 10 // Step 10
match *http_request.referrer.borrow() { match http_request.referrer {
Referrer::NoReferrer => (), Referrer::NoReferrer => (),
Referrer::ReferrerUrl(ref http_request_referrer) => Referrer::ReferrerUrl(ref http_request_referrer) =>
http_request.headers.borrow_mut().set(Referer(http_request_referrer.to_string())), http_request.headers.set(Referer(http_request_referrer.to_string())),
Referrer::Client => Referrer::Client =>
// it should be impossible for referrer to be anything else during fetching // it should be impossible for referrer to be anything else during fetching
// https://fetch.spec.whatwg.org/#concept-request-referrer // https://fetch.spec.whatwg.org/#concept-request-referrer
@ -797,45 +794,45 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
}; };
// Step 11 // Step 11
if !http_request.omit_origin_header.get() { if !http_request.omit_origin_header {
let method = http_request.method.borrow(); let method = &http_request.method;
if cors_flag || (*method != Method::Get && *method != Method::Head) { if cors_flag || (*method != Method::Get && *method != Method::Head) {
debug_assert!(*http_request.origin.borrow() != Origin::Client); debug_assert!(http_request.origin != Origin::Client);
if let Origin::Origin(ref url_origin) = *http_request.origin.borrow() { if let Origin::Origin(ref url_origin) = http_request.origin {
if let Some(hyper_origin) = try_immutable_origin_to_hyper_origin(url_origin) { if let Some(hyper_origin) = try_immutable_origin_to_hyper_origin(url_origin) {
http_request.headers.borrow_mut().set(hyper_origin) http_request.headers.set(hyper_origin)
} }
} }
} }
} }
// Step 12 // Step 12
if !http_request.headers.borrow().has::<UserAgent>() { if !http_request.headers.has::<UserAgent>() {
let user_agent = context.user_agent.clone().into_owned(); let user_agent = context.user_agent.clone().into_owned();
http_request.headers.borrow_mut().set(UserAgent(user_agent)); http_request.headers.set(UserAgent(user_agent));
} }
match http_request.cache_mode.get() { match http_request.cache_mode {
// Step 13 // Step 13
CacheMode::Default if is_no_store_cache(&http_request.headers.borrow()) => { CacheMode::Default if is_no_store_cache(&http_request.headers) => {
http_request.cache_mode.set(CacheMode::NoStore); http_request.cache_mode = CacheMode::NoStore;
}, },
// Step 14 // Step 14
CacheMode::NoCache if !http_request.headers.borrow().has::<CacheControl>() => { CacheMode::NoCache if !http_request.headers.has::<CacheControl>() => {
http_request.headers.borrow_mut().set(CacheControl(vec![CacheDirective::MaxAge(0)])); http_request.headers.set(CacheControl(vec![CacheDirective::MaxAge(0)]));
}, },
// Step 15 // Step 15
CacheMode::Reload | CacheMode::NoStore => { CacheMode::Reload | CacheMode::NoStore => {
// Substep 1 // Substep 1
if !http_request.headers.borrow().has::<Pragma>() { if !http_request.headers.has::<Pragma>() {
http_request.headers.borrow_mut().set(Pragma::NoCache); http_request.headers.set(Pragma::NoCache);
} }
// Substep 2 // Substep 2
if !http_request.headers.borrow().has::<CacheControl>() { if !http_request.headers.has::<CacheControl>() {
http_request.headers.borrow_mut().set(CacheControl(vec![CacheDirective::NoCache])); http_request.headers.set(CacheControl(vec![CacheDirective::NoCache]));
} }
}, },
@ -844,17 +841,14 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
// Step 16 // Step 16
let current_url = http_request.current_url(); let current_url = http_request.current_url();
{ let host = Host {
let headers = &mut *http_request.headers.borrow_mut(); hostname: current_url.host_str().unwrap().to_owned(),
let host = Host { port: current_url.port()
hostname: current_url.host_str().unwrap().to_owned(), };
port: current_url.port() http_request.headers.set(host);
}; // unlike http_loader, we should not set the accept header
headers.set(host); // here, according to the fetch spec
// unlike http_loader, we should not set the accept header set_default_accept_encoding(&mut http_request.headers);
// here, according to the fetch spec
set_default_accept_encoding(headers);
}
// Step 17 // Step 17
// TODO some of this step can't be implemented yet // TODO some of this step can't be implemented yet
@ -863,10 +857,10 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
// TODO http://mxr.mozilla.org/servo/source/components/net/http_loader.rs#504 // TODO http://mxr.mozilla.org/servo/source/components/net/http_loader.rs#504
// XXXManishearth http_loader has block_cookies: support content blocking here too // XXXManishearth http_loader has block_cookies: support content blocking here too
set_request_cookies(&current_url, set_request_cookies(&current_url,
&mut *http_request.headers.borrow_mut(), &mut http_request.headers,
&context.state.cookie_jar); &context.state.cookie_jar);
// Substep 2 // Substep 2
if !http_request.headers.borrow().has::<Authorization<String>>() { if !http_request.headers.has::<Authorization<String>>() {
// Substep 3 // Substep 3
let mut authorization_value = None; let mut authorization_value = None;
@ -889,7 +883,7 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
// Substep 6 // Substep 6
if let Some(basic) = authorization_value { if let Some(basic) = authorization_value {
http_request.headers.borrow_mut().set(Authorization(basic)); http_request.headers.set(Authorization(basic));
} }
} }
} }
@ -906,8 +900,8 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
// Step 21 // Step 21
// TODO have a HTTP cache to check for a completed response // TODO have a HTTP cache to check for a completed response
let complete_http_response_from_cache: Option<Response> = None; let complete_http_response_from_cache: Option<Response> = None;
if http_request.cache_mode.get() != CacheMode::NoStore && if http_request.cache_mode != CacheMode::NoStore &&
http_request.cache_mode.get() != CacheMode::Reload && http_request.cache_mode != CacheMode::Reload &&
complete_http_response_from_cache.is_some() { complete_http_response_from_cache.is_some() {
// TODO Substep 1 and 2. Select a response from HTTP cache. // TODO Substep 1 and 2. Select a response from HTTP cache.
@ -917,8 +911,8 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
}; };
// Substep 4 // Substep 4
if http_request.cache_mode.get() == CacheMode::ForceCache || if http_request.cache_mode == CacheMode::ForceCache ||
http_request.cache_mode.get() == CacheMode::OnlyIfCached { http_request.cache_mode == CacheMode::OnlyIfCached {
// TODO pull response from HTTP cache // TODO pull response from HTTP cache
// response = http_request // response = http_request
} }
@ -938,18 +932,18 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
// Step 22 // Step 22
if response.is_none() { if response.is_none() {
// Substep 1 // Substep 1
if http_request.cache_mode.get() == CacheMode::OnlyIfCached { if http_request.cache_mode == CacheMode::OnlyIfCached {
return Response::network_error( return Response::network_error(
NetworkError::Internal("Couldn't find response in cache".into())) NetworkError::Internal("Couldn't find response in cache".into()))
} }
// Substep 2 // Substep 2
let forward_response = http_network_fetch(http_request.clone(), credentials_flag, let forward_response = http_network_fetch(http_request, credentials_flag,
done_chan, context); done_chan, context);
match forward_response.raw_status { match forward_response.raw_status {
// Substep 3 // Substep 3
Some((200...303, _)) | Some((200...303, _)) |
Some((305...399, _)) => { Some((305...399, _)) => {
if !http_request.method.borrow().safe() { if !http_request.method.safe() {
// TODO Invalidate HTTP cache response // TODO Invalidate HTTP cache response
} }
}, },
@ -983,7 +977,7 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
// TODO: Spec says requires testing on multiple WWW-Authenticate headers // TODO: Spec says requires testing on multiple WWW-Authenticate headers
// Substep 2 // Substep 2
if http_request.body.borrow().is_some() { if http_request.body.is_some() {
// TODO Implement body source // TODO Implement body source
} }
@ -1033,7 +1027,7 @@ fn http_network_or_cache_fetch(request: Rc<Request>,
} }
/// [HTTP network fetch](https://fetch.spec.whatwg.org/#http-network-fetch) /// [HTTP network fetch](https://fetch.spec.whatwg.org/#http-network-fetch)
fn http_network_fetch(request: Rc<Request>, fn http_network_fetch(request: &Request,
credentials_flag: bool, credentials_flag: bool,
done_chan: &mut DoneChannel, done_chan: &mut DoneChannel,
context: &FetchContext) context: &FetchContext)
@ -1051,7 +1045,7 @@ fn http_network_fetch(request: Rc<Request>,
// Step 4 // Step 4
let factory = NetworkHttpRequestFactory { let factory = NetworkHttpRequestFactory {
connector: context.state.connector_pool.clone(), connector: context.connector.clone(),
}; };
let url = request.current_url(); let url = request.current_url();
@ -1064,13 +1058,13 @@ fn http_network_fetch(request: Rc<Request>,
// do not. Once we support other kinds of fetches we'll need to be more fine grained here // do not. Once we support other kinds of fetches we'll need to be more fine grained here
// since things like image fetches are classified differently by devtools // since things like image fetches are classified differently by devtools
let is_xhr = request.destination == Destination::None; let is_xhr = request.destination == Destination::None;
let wrapped_response = obtain_response(&factory, &url, &request.method.borrow(), let wrapped_response = obtain_response(&factory, &url, &request.method,
&request.headers.borrow(), &request.headers,
&request.body.borrow(), &request.method.borrow(), &request.body, &request.method,
&request.pipeline_id.get(), request.redirect_count.get() + 1, &request.pipeline_id, request.redirect_count + 1,
request_id.as_ref().map(Deref::deref), is_xhr); request_id.as_ref().map(Deref::deref), is_xhr);
let pipeline_id = request.pipeline_id.get(); let pipeline_id = request.pipeline_id;
let (res, msg) = match wrapped_response { let (res, msg) = match wrapped_response {
Ok(wrapped_response) => wrapped_response, Ok(wrapped_response) => wrapped_response,
Err(error) => return Response::network_error(error), Err(error) => return Response::network_error(error),
@ -1081,7 +1075,7 @@ fn http_network_fetch(request: Rc<Request>,
response.raw_status = Some((res.response.status_raw().0, response.raw_status = Some((res.response.status_raw().0,
res.response.status_raw().1.as_bytes().to_vec())); res.response.status_raw().1.as_bytes().to_vec()));
response.headers = res.response.headers.clone(); response.headers = res.response.headers.clone();
response.referrer = request.referrer.borrow().to_url().cloned(); response.referrer = request.referrer.to_url().cloned();
let res_body = response.body.clone(); let res_body = response.body.clone();
@ -1177,7 +1171,7 @@ fn http_network_fetch(request: Rc<Request>,
// TODO this step isn't possible yet (CSP) // TODO this step isn't possible yet (CSP)
// Step 12 // Step 12
if response.is_network_error() && request.cache_mode.get() == CacheMode::NoStore { if response.is_network_error() && request.cache_mode == CacheMode::NoStore {
// TODO update response in the HTTP cache for request // TODO update response in the HTTP cache for request
} }
@ -1204,41 +1198,41 @@ fn http_network_fetch(request: Rc<Request>,
} }
/// [CORS preflight fetch](https://fetch.spec.whatwg.org#cors-preflight-fetch) /// [CORS preflight fetch](https://fetch.spec.whatwg.org#cors-preflight-fetch)
fn cors_preflight_fetch(request: Rc<Request>, fn cors_preflight_fetch(request: &Request,
cache: &mut CorsCache, cache: &mut CorsCache,
context: &FetchContext) context: &FetchContext)
-> Response { -> Response {
// Step 1 // Step 1
let mut preflight = Request::new(request.current_url(), Some(request.origin.borrow().clone()), let mut preflight = Request::new(request.current_url(), Some(request.origin.clone()),
request.is_service_worker_global_scope, request.pipeline_id.get()); request.is_service_worker_global_scope, request.pipeline_id);
*preflight.method.borrow_mut() = Method::Options; preflight.method = Method::Options;
preflight.initiator = request.initiator.clone(); preflight.initiator = request.initiator.clone();
preflight.type_ = request.type_.clone(); preflight.type_ = request.type_.clone();
preflight.destination = request.destination.clone(); preflight.destination = request.destination.clone();
*preflight.referrer.borrow_mut() = request.referrer.borrow().clone(); preflight.referrer = request.referrer.clone();
preflight.referrer_policy.set(request.referrer_policy.get()); preflight.referrer_policy = request.referrer_policy;
// Step 2 // Step 2
preflight.headers.borrow_mut().set::<AccessControlRequestMethod>( preflight.headers.set::<AccessControlRequestMethod>(
AccessControlRequestMethod(request.method.borrow().clone())); AccessControlRequestMethod(request.method.clone()));
// Step 3, 4 // Step 3, 4
let mut value = request.headers.borrow().iter() let mut value = request.headers
.filter(|view| !is_simple_header(view)) .iter()
.map(|view| UniCase(view.name().to_owned())) .filter(|view| !is_simple_header(view))
.collect::<Vec<UniCase<String>>>(); .map(|view| UniCase(view.name().to_owned()))
.collect::<Vec<UniCase<String>>>();
value.sort(); value.sort();
// Step 5 // Step 5
preflight.headers.borrow_mut().set::<AccessControlRequestHeaders>( preflight.headers.set::<AccessControlRequestHeaders>(
AccessControlRequestHeaders(value)); AccessControlRequestHeaders(value));
// Step 6 // Step 6
let preflight = Rc::new(preflight); let response = http_network_or_cache_fetch(&mut preflight, false, false, &mut None, context);
let response = http_network_or_cache_fetch(preflight.clone(), false, false, &mut None, context);
// Step 7 // Step 7
if cors_check(request.clone(), &response).is_ok() && if cors_check(&request, &response).is_ok() &&
response.status.map_or(false, |status| status.is_success()) { response.status.map_or(false, |status| status.is_success()) {
// Substep 1 // Substep 1
let mut methods = if response.headers.has::<AccessControlAllowMethods>() { let mut methods = if response.headers.has::<AccessControlAllowMethods>() {
@ -1264,23 +1258,21 @@ fn cors_preflight_fetch(request: Rc<Request>,
// Substep 4 // Substep 4
if methods.is_empty() && request.use_cors_preflight { if methods.is_empty() && request.use_cors_preflight {
methods = vec![request.method.borrow().clone()]; methods = vec![request.method.clone()];
} }
// Substep 5 // Substep 5
debug!("CORS check: Allowed methods: {:?}, current method: {:?}", debug!("CORS check: Allowed methods: {:?}, current method: {:?}",
methods, request.method.borrow()); methods, request.method);
if methods.iter().all(|method| *method != *request.method.borrow()) && if methods.iter().all(|method| *method != request.method) &&
!is_simple_method(&*request.method.borrow()) { !is_simple_method(&request.method) {
return Response::network_error(NetworkError::Internal("CORS method check failed".into())); return Response::network_error(NetworkError::Internal("CORS method check failed".into()));
} }
// Substep 6 // Substep 6
debug!("CORS check: Allowed headers: {:?}, current headers: {:?}", debug!("CORS check: Allowed headers: {:?}, current headers: {:?}", header_names, request.headers);
header_names, request.headers.borrow());
let set: HashSet<&UniCase<String>> = HashSet::from_iter(header_names.iter()); let set: HashSet<&UniCase<String>> = HashSet::from_iter(header_names.iter());
if request.headers.borrow().iter().any(|ref hv| !set.contains(&UniCase(hv.name().to_owned())) && if request.headers.iter().any(|ref hv| !set.contains(&UniCase(hv.name().to_owned())) && !is_simple_header(hv)) {
!is_simple_header(hv)) {
return Response::network_error(NetworkError::Internal("CORS headers check failed".into())); return Response::network_error(NetworkError::Internal("CORS headers check failed".into()));
} }
@ -1308,7 +1300,7 @@ fn cors_preflight_fetch(request: Rc<Request>,
} }
/// [CORS check](https://fetch.spec.whatwg.org#concept-cors-check) /// [CORS check](https://fetch.spec.whatwg.org#concept-cors-check)
fn cors_check(request: Rc<Request>, response: &Response) -> Result<(), ()> { fn cors_check(request: &Request, response: &Response) -> Result<(), ()> {
// Step 1 // Step 1
let origin = response.headers.get::<AccessControlAllowOrigin>().cloned(); let origin = response.headers.get::<AccessControlAllowOrigin>().cloned();
@ -1328,7 +1320,7 @@ fn cors_check(request: Rc<Request>, response: &Response) -> Result<(), ()> {
_ => return Err(()) _ => return Err(())
}; };
match *request.origin.borrow() { match request.origin {
Origin::Origin(ref o) if o.ascii_serialization() == origin => {}, Origin::Origin(ref o) if o.ascii_serialization() == origin => {},
_ => return Err(()) _ => return Err(())
} }

2
components/net/lib.rs
View file

@ -42,7 +42,7 @@ extern crate websocket;
mod blob_loader; mod blob_loader;
mod chrome_loader; mod chrome_loader;
mod connector; pub mod connector;
pub mod cookie; pub mod cookie;
pub mod cookie_storage; pub mod cookie_storage;
mod data_loader; mod data_loader;

47
components/net/resource_thread.rs
View file

@ -33,7 +33,6 @@ use std::fs::File;
use std::io::prelude::*; use std::io::prelude::*;
use std::ops::Deref; use std::ops::Deref;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::sync::{Arc, RwLock}; use std::sync::{Arc, RwLock};
use std::sync::mpsc::Sender; use std::sync::mpsc::Sender;
use std::thread; use std::thread;
@ -44,9 +43,7 @@ const TFD_PROVIDER: &'static TFDProvider = &TFDProvider;
#[derive(Clone)] #[derive(Clone)]
pub struct ResourceGroup { pub struct ResourceGroup {
cookie_jar: Arc<RwLock<CookieStorage>>, http_state: Arc<HttpState>,
auth_cache: Arc<RwLock<AuthCache>>,
hsts_list: Arc<RwLock<HstsList>>,
ssl_client: OpensslClient, ssl_client: OpensslClient,
connector: Arc<Pool<Connector>>, connector: Arc<Pool<Connector>>,
} }
@ -106,18 +103,19 @@ fn create_resource_groups(config_dir: Option<&Path>)
read_json_from_file(&mut hsts_list, config_dir, "hsts_list.json"); read_json_from_file(&mut hsts_list, config_dir, "hsts_list.json");
read_json_from_file(&mut cookie_jar, config_dir, "cookie_jar.json"); read_json_from_file(&mut cookie_jar, config_dir, "cookie_jar.json");
} }
let http_state = HttpState {
cookie_jar: RwLock::new(cookie_jar),
auth_cache: RwLock::new(auth_cache),
hsts_list: RwLock::new(hsts_list),
};
let ssl_client = create_ssl_client("certs"); let ssl_client = create_ssl_client("certs");
let resource_group = ResourceGroup { let resource_group = ResourceGroup {
cookie_jar: Arc::new(RwLock::new(cookie_jar)), http_state: Arc::new(http_state),
auth_cache: Arc::new(RwLock::new(auth_cache)),
hsts_list: Arc::new(RwLock::new(hsts_list.clone())),
ssl_client: ssl_client.clone(), ssl_client: ssl_client.clone(),
connector: create_http_connector(ssl_client.clone()), connector: create_http_connector(ssl_client.clone()),
}; };
let private_resource_group = ResourceGroup { let private_resource_group = ResourceGroup {
cookie_jar: Arc::new(RwLock::new(CookieStorage::new(150))), http_state: Arc::new(HttpState::new()),
auth_cache: Arc::new(RwLock::new(AuthCache::new())),
hsts_list: Arc::new(RwLock::new(HstsList::new())),
ssl_client: ssl_client.clone(), ssl_client: ssl_client.clone(),
connector: create_http_connector(ssl_client), connector: create_http_connector(ssl_client),
}; };
@ -171,14 +169,14 @@ impl ResourceChannelManager {
} }
} }
CoreResourceMsg::GetCookiesForUrl(url, consumer, source) => { CoreResourceMsg::GetCookiesForUrl(url, consumer, source) => {
let mut cookie_jar = group.cookie_jar.write().unwrap(); let mut cookie_jar = group.http_state.cookie_jar.write().unwrap();
consumer.send(cookie_jar.cookies_for_url(&url, source)).unwrap(); consumer.send(cookie_jar.cookies_for_url(&url, source)).unwrap();
} }
CoreResourceMsg::NetworkMediator(mediator_chan) => { CoreResourceMsg::NetworkMediator(mediator_chan) => {
self.resource_manager.swmanager_chan = Some(mediator_chan) self.resource_manager.swmanager_chan = Some(mediator_chan)
} }
CoreResourceMsg::GetCookiesDataForUrl(url, consumer, source) => { CoreResourceMsg::GetCookiesDataForUrl(url, consumer, source) => {
let mut cookie_jar = group.cookie_jar.write().unwrap(); let mut cookie_jar = group.http_state.cookie_jar.write().unwrap();
let cookies = cookie_jar.cookies_data_for_url(&url, source).map(Serde).collect(); let cookies = cookie_jar.cookies_data_for_url(&url, source).map(Serde).collect();
consumer.send(cookies).unwrap(); consumer.send(cookies).unwrap();
} }
@ -194,15 +192,15 @@ impl ResourceChannelManager {
CoreResourceMsg::ToFileManager(msg) => self.resource_manager.filemanager.handle(msg, TFD_PROVIDER), CoreResourceMsg::ToFileManager(msg) => self.resource_manager.filemanager.handle(msg, TFD_PROVIDER),
CoreResourceMsg::Exit(sender) => { CoreResourceMsg::Exit(sender) => {
if let Some(ref config_dir) = self.config_dir { if let Some(ref config_dir) = self.config_dir {
match group.auth_cache.read() { match group.http_state.auth_cache.read() {
Ok(auth_cache) => write_json_to_file(&*auth_cache, config_dir, "auth_cache.json"), Ok(auth_cache) => write_json_to_file(&*auth_cache, config_dir, "auth_cache.json"),
Err(_) => warn!("Error writing auth cache to disk"), Err(_) => warn!("Error writing auth cache to disk"),
} }
match group.cookie_jar.read() { match group.http_state.cookie_jar.read() {
Ok(jar) => write_json_to_file(&*jar, config_dir, "cookie_jar.json"), Ok(jar) => write_json_to_file(&*jar, config_dir, "cookie_jar.json"),
Err(_) => warn!("Error writing cookie jar to disk"), Err(_) => warn!("Error writing cookie jar to disk"),
} }
match group.hsts_list.read() { match group.http_state.hsts_list.read() {
Ok(hsts) => write_json_to_file(&*hsts, config_dir, "hsts_list.json"), Ok(hsts) => write_json_to_file(&*hsts, config_dir, "hsts_list.json"),
Err(_) => warn!("Error writing hsts list to disk"), Err(_) => warn!("Error writing hsts list to disk"),
} }
@ -318,7 +316,7 @@ impl CoreResourceManager {
source: CookieSource, source: CookieSource,
resource_group: &ResourceGroup) { resource_group: &ResourceGroup) {
if let Some(cookie) = cookie::Cookie::new_wrapped(cookie, request, source) { if let Some(cookie) = cookie::Cookie::new_wrapped(cookie, request, source) {
let mut cookie_jar = resource_group.cookie_jar.write().unwrap(); let mut cookie_jar = resource_group.http_state.cookie_jar.write().unwrap();
cookie_jar.push(cookie, request, source) cookie_jar.push(cookie, request, source)
} }
} }
@ -327,19 +325,15 @@ impl CoreResourceManager {
init: RequestInit, init: RequestInit,
mut sender: IpcSender<FetchResponseMsg>, mut sender: IpcSender<FetchResponseMsg>,
group: &ResourceGroup) { group: &ResourceGroup) {
let http_state = HttpState { let http_state = group.http_state.clone();
hsts_list: group.hsts_list.clone(),
cookie_jar: group.cookie_jar.clone(),
auth_cache: group.auth_cache.clone(),
// FIXME(#15694): use group.connector.clone() instead.
connector_pool: create_http_connector(group.ssl_client.clone()),
};
let ua = self.user_agent.clone(); let ua = self.user_agent.clone();
let dc = self.devtools_chan.clone(); let dc = self.devtools_chan.clone();
let filemanager = self.filemanager.clone(); let filemanager = self.filemanager.clone();
// FIXME(#15694): use group.connector.clone() instead.
let connector = create_http_connector(group.ssl_client.clone());
thread::Builder::new().name(format!("fetch thread for {}", init.url)).spawn(move || { thread::Builder::new().name(format!("fetch thread for {}", init.url)).spawn(move || {
let request = Request::from_init(init); let mut request = Request::from_init(init);
// 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?
@ -349,8 +343,9 @@ impl CoreResourceManager {
user_agent: ua, user_agent: ua,
devtools_chan: dc, devtools_chan: dc,
filemanager: filemanager, filemanager: filemanager,
connector: connector,
}; };
fetch(Rc::new(request), &mut sender, &context); fetch(&mut request, &mut sender, &context);
}).expect("Thread spawning failed"); }).expect("Thread spawning failed");
} }
@ -360,6 +355,6 @@ impl CoreResourceManager {
resource_grp: &ResourceGroup) { resource_grp: &ResourceGroup) {
websocket_loader::init(connect, websocket_loader::init(connect,
connect_data, connect_data,
resource_grp.cookie_jar.clone()); resource_grp.http_state.clone());
} }
} }

20
components/net/websocket_loader.rs
View file

@ -6,7 +6,7 @@ use cookie::Cookie;
use cookie_rs; use cookie_rs;
use cookie_storage::CookieStorage; use cookie_storage::CookieStorage;
use fetch::methods::{should_be_blocked_due_to_bad_port, should_be_blocked_due_to_nosniff}; use fetch::methods::{should_be_blocked_due_to_bad_port, should_be_blocked_due_to_nosniff};
use http_loader::{is_redirect_status, set_request_cookies}; use http_loader::{HttpState, is_redirect_status, set_request_cookies};
use hyper::buffer::BufReader; use hyper::buffer::BufReader;
use hyper::header::{Accept, CacheControl, CacheDirective, Connection, ConnectionOption}; use hyper::header::{Accept, CacheControl, CacheDirective, Connection, ConnectionOption};
use hyper::header::{Headers, Host, SetCookie, Pragma, Protocol, ProtocolName, Upgrade}; use hyper::header::{Headers, Host, SetCookie, Pragma, Protocol, ProtocolName, Upgrade};
@ -35,12 +35,12 @@ use websocket::sender::Sender;
pub fn init(connect: WebSocketCommunicate, pub fn init(connect: WebSocketCommunicate,
connect_data: WebSocketConnectData, connect_data: WebSocketConnectData,
cookie_jar: Arc<RwLock<CookieStorage>>) { http_state: Arc<HttpState>) {
thread::Builder::new().name(format!("WebSocket connection to {}", connect_data.resource_url)).spawn(move || { thread::Builder::new().name(format!("WebSocket connection to {}", connect_data.resource_url)).spawn(move || {
let channel = establish_a_websocket_connection(&connect_data.resource_url, let channel = establish_a_websocket_connection(&connect_data.resource_url,
connect_data.origin, connect_data.origin,
connect_data.protocols, connect_data.protocols,
cookie_jar); &http_state.cookie_jar);
let (ws_sender, mut receiver) = match channel { let (ws_sender, mut receiver) = match channel {
Ok((protocol_in_use, sender, receiver)) => { Ok((protocol_in_use, sender, receiver)) => {
let _ = connect.event_sender.send(WebSocketNetworkEvent::ConnectionEstablished { protocol_in_use }); let _ = connect.event_sender.send(WebSocketNetworkEvent::ConnectionEstablished { protocol_in_use });
@ -150,7 +150,7 @@ fn obtain_a_websocket_connection(url: &ServoUrl) -> Result<Stream, NetworkError>
fn establish_a_websocket_connection(resource_url: &ServoUrl, fn establish_a_websocket_connection(resource_url: &ServoUrl,
origin: String, origin: String,
protocols: Vec<String>, protocols: Vec<String>,
cookie_jar: Arc<RwLock<CookieStorage>>) cookie_jar: &RwLock<CookieStorage>)
-> Result<(Option<String>, -> Result<(Option<String>,
Sender<Stream>, Sender<Stream>,
Receiver<Stream>), Receiver<Stream>),
@ -272,7 +272,7 @@ struct Response {
fn fetch(url: &ServoUrl, fn fetch(url: &ServoUrl,
origin: String, origin: String,
mut headers: Headers, mut headers: Headers,
cookie_jar: Arc<RwLock<CookieStorage>>) cookie_jar: &RwLock<CookieStorage>)
-> Result<Response, NetworkError> { -> Result<Response, NetworkError> {
// Step 1. // Step 1.
// TODO: handle request's window. // TODO: handle request's window.
@ -323,7 +323,7 @@ fn fetch(url: &ServoUrl,
fn main_fetch(url: &ServoUrl, fn main_fetch(url: &ServoUrl,
origin: String, origin: String,
mut headers: Headers, mut headers: Headers,
cookie_jar: Arc<RwLock<CookieStorage>>) cookie_jar: &RwLock<CookieStorage>)
-> Result<Response, NetworkError> { -> Result<Response, NetworkError> {
// Step 1. // Step 1.
let mut response = None; let mut response = None;
@ -404,7 +404,7 @@ fn main_fetch(url: &ServoUrl,
fn basic_fetch(url: &ServoUrl, fn basic_fetch(url: &ServoUrl,
origin: String, origin: String,
headers: &mut Headers, headers: &mut Headers,
cookie_jar: Arc<RwLock<CookieStorage>>) cookie_jar: &RwLock<CookieStorage>)
-> Result<Response, NetworkError> { -> Result<Response, NetworkError> {
// In the case of a WebSocket request, HTTP fetch is always used. // In the case of a WebSocket request, HTTP fetch is always used.
http_fetch(url, origin, headers, cookie_jar) http_fetch(url, origin, headers, cookie_jar)
@ -414,7 +414,7 @@ fn basic_fetch(url: &ServoUrl,
fn http_fetch(url: &ServoUrl, fn http_fetch(url: &ServoUrl,
origin: String, origin: String,
headers: &mut Headers, headers: &mut Headers,
cookie_jar: Arc<RwLock<CookieStorage>>) cookie_jar: &RwLock<CookieStorage>)
-> Result<Response, NetworkError> { -> Result<Response, NetworkError> {
// Step 1. // Step 1.
// Not applicable: with step 3 being useless here, this one is too. // Not applicable: with step 3 being useless here, this one is too.
@ -464,7 +464,7 @@ fn http_fetch(url: &ServoUrl,
fn http_network_or_cache_fetch(url: &ServoUrl, fn http_network_or_cache_fetch(url: &ServoUrl,
origin: String, origin: String,
headers: &mut Headers, headers: &mut Headers,
cookie_jar: Arc<RwLock<CookieStorage>>) cookie_jar: &RwLock<CookieStorage>)
-> Result<Response, NetworkError> { -> Result<Response, NetworkError> {
// Steps 1-3. // Steps 1-3.
// Not applicable: we don't even have a request yet, and there is no body // Not applicable: we don't even have a request yet, and there is no body
@ -569,7 +569,7 @@ fn http_network_or_cache_fetch(url: &ServoUrl,
// https://fetch.spec.whatwg.org/#concept-http-network-fetch // https://fetch.spec.whatwg.org/#concept-http-network-fetch
fn http_network_fetch(url: &ServoUrl, fn http_network_fetch(url: &ServoUrl,
headers: &Headers, headers: &Headers,
cookie_jar: Arc<RwLock<CookieStorage>>) cookie_jar: &RwLock<CookieStorage>)
-> Result<Response, NetworkError> { -> Result<Response, NetworkError> {
// Step 1. // Step 1.
// Not applicable: credentials flag is set. // Not applicable: credentials flag is set.

91
components/net_traits/request.rs
View file

@ -7,7 +7,6 @@ use hyper::header::Headers;
use hyper::method::Method; use hyper::method::Method;
use msg::constellation_msg::PipelineId; use msg::constellation_msg::PipelineId;
use servo_url::{ImmutableOrigin, ServoUrl}; use servo_url::{ImmutableOrigin, ServoUrl};
use std::cell::{Cell, RefCell};
use std::default::Default; use std::default::Default;
/// An [initiator](https://fetch.spec.whatwg.org/#concept-request-initiator) /// An [initiator](https://fetch.spec.whatwg.org/#concept-request-initiator)
@ -191,42 +190,42 @@ impl Default for RequestInit {
#[derive(Clone, HeapSizeOf)] #[derive(Clone, HeapSizeOf)]
pub struct Request { pub struct Request {
#[ignore_heap_size_of = "Defined in hyper"] #[ignore_heap_size_of = "Defined in hyper"]
pub method: RefCell<Method>, pub method: Method,
pub local_urls_only: bool, pub local_urls_only: bool,
pub sandboxed_storage_area_urls: bool, pub sandboxed_storage_area_urls: bool,
#[ignore_heap_size_of = "Defined in hyper"] #[ignore_heap_size_of = "Defined in hyper"]
pub headers: RefCell<Headers>, pub headers: Headers,
pub unsafe_request: bool, pub unsafe_request: bool,
pub body: RefCell<Option<Vec<u8>>>, pub body: Option<Vec<u8>>,
// TODO: client object // TODO: client object
pub is_service_worker_global_scope: bool, pub is_service_worker_global_scope: bool,
pub window: Cell<Window>, pub window: Window,
// TODO: target browsing context // TODO: target browsing context
pub keep_alive: Cell<bool>, pub keep_alive: bool,
pub skip_service_worker: Cell<bool>, pub skip_service_worker: bool,
pub initiator: Initiator, pub initiator: Initiator,
pub type_: Type, pub type_: Type,
pub destination: Destination, pub destination: Destination,
// TODO: priority object // TODO: priority object
pub origin: RefCell<Origin>, pub origin: Origin,
pub omit_origin_header: Cell<bool>, pub omit_origin_header: bool,
/// https://fetch.spec.whatwg.org/#concept-request-referrer /// https://fetch.spec.whatwg.org/#concept-request-referrer
pub referrer: RefCell<Referrer>, pub referrer: Referrer,
pub referrer_policy: Cell<Option<ReferrerPolicy>>, pub referrer_policy: Option<ReferrerPolicy>,
pub pipeline_id: Cell<Option<PipelineId>>, pub pipeline_id: Option<PipelineId>,
pub synchronous: bool, pub synchronous: bool,
pub mode: RequestMode, pub mode: RequestMode,
pub use_cors_preflight: bool, pub use_cors_preflight: bool,
pub credentials_mode: CredentialsMode, pub credentials_mode: CredentialsMode,
pub use_url_credentials: bool, pub use_url_credentials: bool,
pub cache_mode: Cell<CacheMode>, pub cache_mode: CacheMode,
pub redirect_mode: Cell<RedirectMode>, pub redirect_mode: RedirectMode,
pub integrity_metadata: RefCell<String>, pub integrity_metadata: String,
// Use the last method on url_list to act as spec current url field, and // Use the last method on url_list to act as spec current url field, and
// first method to act as spec url field // first method to act as spec url field
pub url_list: RefCell<Vec<ServoUrl>>, pub url_list: Vec<ServoUrl>,
pub redirect_count: Cell<u32>, pub redirect_count: u32,
pub response_tainting: Cell<ResponseTainting>, pub response_tainting: ResponseTainting,
} }
impl Request { impl Request {
@ -236,35 +235,35 @@ impl Request {
pipeline_id: Option<PipelineId>) pipeline_id: Option<PipelineId>)
-> Request { -> Request {
Request { Request {
method: RefCell::new(Method::Get), method: Method::Get,
local_urls_only: false, local_urls_only: false,
sandboxed_storage_area_urls: false, sandboxed_storage_area_urls: false,
headers: RefCell::new(Headers::new()), headers: Headers::new(),
unsafe_request: false, unsafe_request: false,
body: RefCell::new(None), body: None,
is_service_worker_global_scope: is_service_worker_global_scope, is_service_worker_global_scope: is_service_worker_global_scope,
window: Cell::new(Window::Client), window: Window::Client,
keep_alive: Cell::new(false), keep_alive: false,
skip_service_worker: Cell::new(false), skip_service_worker: false,
initiator: Initiator::None, initiator: Initiator::None,
type_: Type::None, type_: Type::None,
destination: Destination::None, destination: Destination::None,
origin: RefCell::new(origin.unwrap_or(Origin::Client)), origin: origin.unwrap_or(Origin::Client),
omit_origin_header: Cell::new(false), omit_origin_header: false,
referrer: RefCell::new(Referrer::Client), referrer: Referrer::Client,
referrer_policy: Cell::new(None), referrer_policy: None,
pipeline_id: Cell::new(pipeline_id), pipeline_id: pipeline_id,
synchronous: false, synchronous: false,
mode: RequestMode::NoCors, mode: RequestMode::NoCors,
use_cors_preflight: false, use_cors_preflight: false,
credentials_mode: CredentialsMode::Omit, credentials_mode: CredentialsMode::Omit,
use_url_credentials: false, use_url_credentials: false,
cache_mode: Cell::new(CacheMode::Default), cache_mode: CacheMode::Default,
redirect_mode: Cell::new(RedirectMode::Follow), redirect_mode: RedirectMode::Follow,
integrity_metadata: RefCell::new(String::new()), integrity_metadata: String::new(),
url_list: RefCell::new(vec![url]), url_list: vec![url],
redirect_count: Cell::new(0), redirect_count: 0,
response_tainting: Cell::new(ResponseTainting::Basic), response_tainting: ResponseTainting::Basic,
} }
} }
@ -273,10 +272,10 @@ impl Request {
Some(Origin::Origin(init.origin.origin())), Some(Origin::Origin(init.origin.origin())),
false, false,
init.pipeline_id); init.pipeline_id);
*req.method.borrow_mut() = init.method; req.method = init.method;
*req.headers.borrow_mut() = init.headers; req.headers = init.headers;
req.unsafe_request = init.unsafe_request; req.unsafe_request = init.unsafe_request;
*req.body.borrow_mut() = init.body; req.body = init.body;
req.type_ = init.type_; req.type_ = init.type_;
req.destination = init.destination; req.destination = init.destination;
req.synchronous = init.synchronous; req.synchronous = init.synchronous;
@ -284,25 +283,25 @@ impl Request {
req.use_cors_preflight = init.use_cors_preflight; req.use_cors_preflight = init.use_cors_preflight;
req.credentials_mode = init.credentials_mode; req.credentials_mode = init.credentials_mode;
req.use_url_credentials = init.use_url_credentials; req.use_url_credentials = init.use_url_credentials;
req.cache_mode.set(init.cache_mode); req.cache_mode = init.cache_mode;
*req.referrer.borrow_mut() = if let Some(url) = init.referrer_url { req.referrer = if let Some(url) = init.referrer_url {
Referrer::ReferrerUrl(url) Referrer::ReferrerUrl(url)
} else { } else {
Referrer::NoReferrer Referrer::NoReferrer
}; };
req.referrer_policy.set(init.referrer_policy); req.referrer_policy = init.referrer_policy;
req.pipeline_id.set(init.pipeline_id); req.pipeline_id = init.pipeline_id;
req.redirect_mode.set(init.redirect_mode); req.redirect_mode = init.redirect_mode;
*req.integrity_metadata.borrow_mut() = init.integrity_metadata; req.integrity_metadata = init.integrity_metadata;
req req
} }
pub fn url(&self) -> ServoUrl { pub fn url(&self) -> ServoUrl {
self.url_list.borrow().first().unwrap().clone() self.url_list.first().unwrap().clone()
} }
pub fn current_url(&self) -> ServoUrl { pub fn current_url(&self) -> ServoUrl {
self.url_list.borrow().last().unwrap().clone() self.url_list.last().unwrap().clone()
} }
pub fn is_navigation_request(&self) -> bool { pub fn is_navigation_request(&self) -> bool {

27
components/net_traits/response.rs
View file

@ -10,7 +10,6 @@ use hyper::status::StatusCode;
use hyper_serde::Serde; use hyper_serde::Serde;
use servo_url::ServoUrl; use servo_url::ServoUrl;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::cell::{Cell, RefCell};
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
/// [Response type](https://fetch.spec.whatwg.org/#concept-response-type) /// [Response type](https://fetch.spec.whatwg.org/#concept-response-type)
@ -81,7 +80,7 @@ pub struct Response {
pub response_type: ResponseType, pub response_type: ResponseType,
pub termination_reason: Option<TerminationReason>, pub termination_reason: Option<TerminationReason>,
url: Option<ServoUrl>, url: Option<ServoUrl>,
pub url_list: RefCell<Vec<ServoUrl>>, pub url_list: Vec<ServoUrl>,
/// `None` can be considered a StatusCode of `0`. /// `None` can be considered a StatusCode of `0`.
#[ignore_heap_size_of = "Defined in hyper"] #[ignore_heap_size_of = "Defined in hyper"]
pub status: Option<StatusCode>, pub status: Option<StatusCode>,
@ -97,7 +96,7 @@ pub struct Response {
/// is a filtered response /// is a filtered response
pub internal_response: Option<Box<Response>>, pub internal_response: Option<Box<Response>>,
/// whether or not to try to return the internal_response when asked for actual_response /// whether or not to try to return the internal_response when asked for actual_response
pub return_internal: Cell<bool>, pub return_internal: bool,
} }
impl Response { impl Response {
@ -106,7 +105,7 @@ impl Response {
response_type: ResponseType::Default, response_type: ResponseType::Default,
termination_reason: None, termination_reason: None,
url: Some(url), url: Some(url),
url_list: RefCell::new(Vec::new()), url_list: vec![],
status: Some(StatusCode::Ok), status: Some(StatusCode::Ok),
raw_status: Some((200, b"OK".to_vec())), raw_status: Some((200, b"OK".to_vec())),
headers: Headers::new(), headers: Headers::new(),
@ -115,7 +114,7 @@ impl Response {
https_state: HttpsState::None, https_state: HttpsState::None,
referrer: None, referrer: None,
internal_response: None, internal_response: None,
return_internal: Cell::new(true), return_internal: true,
} }
} }
@ -124,7 +123,7 @@ impl Response {
response_type: ResponseType::Error(e), response_type: ResponseType::Error(e),
termination_reason: None, termination_reason: None,
url: None, url: None,
url_list: RefCell::new(vec![]), url_list: vec![],
status: None, status: None,
raw_status: None, raw_status: None,
headers: Headers::new(), headers: Headers::new(),
@ -133,7 +132,7 @@ impl Response {
https_state: HttpsState::None, https_state: HttpsState::None,
referrer: None, referrer: None,
internal_response: None, internal_response: None,
return_internal: Cell::new(true), return_internal: true,
} }
} }
@ -156,15 +155,23 @@ impl Response {
} }
pub fn actual_response(&self) -> &Response { pub fn actual_response(&self) -> &Response {
if self.return_internal.get() && self.internal_response.is_some() { if self.return_internal && self.internal_response.is_some() {
&**self.internal_response.as_ref().unwrap() &**self.internal_response.as_ref().unwrap()
} else { } else {
self self
} }
} }
pub fn actual_response_mut(&mut self) -> &mut Response {
if self.return_internal && self.internal_response.is_some() {
&mut **self.internal_response.as_mut().unwrap()
} else {
self
}
}
pub fn to_actual(self) -> Response { pub fn to_actual(self) -> Response {
if self.return_internal.get() && self.internal_response.is_some() { if self.return_internal && self.internal_response.is_some() {
*self.internal_response.unwrap() *self.internal_response.unwrap()
} else { } else {
self self
@ -226,7 +233,7 @@ impl Response {
}, },
ResponseType::Opaque => { ResponseType::Opaque => {
response.url_list = RefCell::new(vec![]); response.url_list = vec![];
response.url = None; response.url = None;
response.headers = Headers::new(); response.headers = Headers::new();
response.status = None; response.status = None;

80
components/script/dom/request.rs
View file

@ -158,9 +158,9 @@ impl Request {
request.method = temporary_request.method; request.method = temporary_request.method;
request.headers = temporary_request.headers.clone(); request.headers = temporary_request.headers.clone();
request.unsafe_request = true; request.unsafe_request = true;
request.window.set(window); request.window = window;
// TODO: `entry settings object` is not implemented in Servo yet. // TODO: `entry settings object` is not implemented in Servo yet.
*request.origin.borrow_mut() = Origin::Client; request.origin = Origin::Client;
request.omit_origin_header = temporary_request.omit_origin_header; request.omit_origin_header = temporary_request.omit_origin_header;
request.referrer = temporary_request.referrer; request.referrer = temporary_request.referrer;
request.referrer_policy = temporary_request.referrer_policy; request.referrer_policy = temporary_request.referrer_policy;
@ -187,11 +187,11 @@ impl Request {
request.mode = NetTraitsRequestMode::SameOrigin; request.mode = NetTraitsRequestMode::SameOrigin;
} }
// Step 13.2 // Step 13.2
request.omit_origin_header.set(false); request.omit_origin_header = false;
// Step 13.3 // Step 13.3
*request.referrer.borrow_mut() = NetTraitsRequestReferrer::Client; request.referrer = NetTraitsRequestReferrer::Client;
// Step 13.4 // Step 13.4
request.referrer_policy.set(None); request.referrer_policy = None;
} }
// Step 14 // Step 14
@ -200,7 +200,7 @@ impl Request {
let ref referrer = init_referrer.0; let ref referrer = init_referrer.0;
// Step 14.2 // Step 14.2
if referrer.is_empty() { if referrer.is_empty() {
*request.referrer.borrow_mut() = NetTraitsRequestReferrer::NoReferrer; request.referrer = NetTraitsRequestReferrer::NoReferrer;
} else { } else {
// Step 14.3 // Step 14.3
let parsed_referrer = base_url.join(referrer); let parsed_referrer = base_url.join(referrer);
@ -215,10 +215,10 @@ impl Request {
parsed_referrer.scheme() == "about" && parsed_referrer.scheme() == "about" &&
parsed_referrer.path() == "client") || parsed_referrer.path() == "client") ||
parsed_referrer.origin() != origin { parsed_referrer.origin() != origin {
*request.referrer.borrow_mut() = NetTraitsRequestReferrer::Client; request.referrer = NetTraitsRequestReferrer::Client;
} else { } else {
// Step 14.6 // Step 14.6
*request.referrer.borrow_mut() = NetTraitsRequestReferrer::ReferrerUrl(parsed_referrer); request.referrer = NetTraitsRequestReferrer::ReferrerUrl(parsed_referrer);
} }
} }
} }
@ -227,7 +227,7 @@ impl Request {
// Step 15 // Step 15
if let Some(init_referrerpolicy) = init.referrerPolicy.as_ref() { if let Some(init_referrerpolicy) = init.referrerPolicy.as_ref() {
let init_referrer_policy = init_referrerpolicy.clone().into(); let init_referrer_policy = init_referrerpolicy.clone().into();
request.referrer_policy.set(Some(init_referrer_policy)); request.referrer_policy = Some(init_referrer_policy);
} }
// Step 16 // Step 16
@ -254,11 +254,11 @@ impl Request {
// Step 21 // Step 21
if let Some(init_cache) = init.cache.as_ref() { if let Some(init_cache) = init.cache.as_ref() {
let cache = init_cache.clone().into(); let cache = init_cache.clone().into();
request.cache_mode.set(cache); request.cache_mode = cache;
} }
// Step 22 // Step 22
if request.cache_mode.get() == NetTraitsRequestCache::OnlyIfCached { if request.cache_mode == NetTraitsRequestCache::OnlyIfCached {
if request.mode != NetTraitsRequestMode::SameOrigin { if request.mode != NetTraitsRequestMode::SameOrigin {
return Err(Error::Type( return Err(Error::Type(
"Cache is 'only-if-cached' and mode is not 'same-origin'".to_string())); "Cache is 'only-if-cached' and mode is not 'same-origin'".to_string()));
@ -268,13 +268,13 @@ impl Request {
// Step 23 // Step 23
if let Some(init_redirect) = init.redirect.as_ref() { if let Some(init_redirect) = init.redirect.as_ref() {
let redirect = init_redirect.clone().into(); let redirect = init_redirect.clone().into();
request.redirect_mode.set(redirect); request.redirect_mode = redirect;
} }
// Step 24 // Step 24
if let Some(init_integrity) = init.integrity.as_ref() { if let Some(init_integrity) = init.integrity.as_ref() {
let integrity = init_integrity.clone().to_string(); let integrity = init_integrity.clone().to_string();
*request.integrity_metadata.borrow_mut() = integrity; request.integrity_metadata = integrity;
} }
// Step 25 // Step 25
@ -292,7 +292,7 @@ impl Request {
None => return Err(Error::Type("Method is not a valid UTF8".to_string())), None => return Err(Error::Type("Method is not a valid UTF8".to_string())),
}; };
// Step 25.3 // Step 25.3
*request.method.borrow_mut() = method; request.method = method;
} }
// Step 26 // Step 26
@ -334,12 +334,12 @@ impl Request {
if r.request.borrow().mode == NetTraitsRequestMode::NoCors { if r.request.borrow().mode == NetTraitsRequestMode::NoCors {
let borrowed_request = r.request.borrow(); let borrowed_request = r.request.borrow();
// Step 30.1 // Step 30.1
if !is_cors_safelisted_method(&borrowed_request.method.borrow()) { if !is_cors_safelisted_method(&borrowed_request.method) {
return Err(Error::Type( return Err(Error::Type(
"The mode is 'no-cors' but the method is not a cors-safelisted method".to_string())); "The mode is 'no-cors' but the method is not a cors-safelisted method".to_string()));
} }
// Step 30.2 // Step 30.2
if !borrowed_request.integrity_metadata.borrow().is_empty() { if !borrowed_request.integrity_metadata.is_empty() {
return Err(Error::Type("Integrity metadata is not an empty string".to_string())); return Err(Error::Type("Integrity metadata is not an empty string".to_string()));
} }
// Step 30.3 // Step 30.3
@ -364,8 +364,7 @@ impl Request {
// Step 32 // Step 32
let mut input_body = if let RequestInfo::Request(ref input_request) = input { let mut input_body = if let RequestInfo::Request(ref input_request) = input {
let input_request_request = input_request.request.borrow(); let input_request_request = input_request.request.borrow();
let body = input_request_request.body.borrow(); input_request_request.body.clone()
body.clone()
} else { } else {
None None
}; };
@ -374,11 +373,11 @@ impl Request {
if let Some(init_body_option) = init.body.as_ref() { if let Some(init_body_option) = init.body.as_ref() {
if init_body_option.is_some() || input_body.is_some() { if init_body_option.is_some() || input_body.is_some() {
let req = r.request.borrow(); let req = r.request.borrow();
let req_method = req.method.borrow(); let req_method = &req.method;
match &*req_method { match *req_method {
&HttpMethod::Get => return Err(Error::Type( HttpMethod::Get => return Err(Error::Type(
"Init's body is non-null, and request method is GET".to_string())), "Init's body is non-null, and request method is GET".to_string())),
&HttpMethod::Head => return Err(Error::Type( HttpMethod::Head => return Err(Error::Type(
"Init's body is non-null, and request method is HEAD".to_string())), "Init's body is non-null, and request method is HEAD".to_string())),
_ => {}, _ => {},
} }
@ -402,10 +401,7 @@ impl Request {
} }
// Step 35 // Step 35
{ r.request.borrow_mut().body = input_body;
let borrowed_request = r.request.borrow();
*borrowed_request.body.borrow_mut() = input_body;
}
// Step 36 // Step 36
let extracted_mime_type = r.Headers().extract_mime_type(); let extracted_mime_type = r.Headers().extract_mime_type();
@ -445,10 +441,10 @@ impl Request {
let mime_type = r.mime_type.borrow().clone(); let mime_type = r.mime_type.borrow().clone();
let headers_guard = r.Headers().get_guard(); let headers_guard = r.Headers().get_guard();
let r_clone = Request::new(&r.global(), url, is_service_worker_global_scope); let r_clone = Request::new(&r.global(), url, is_service_worker_global_scope);
r_clone.request.borrow_mut().pipeline_id.set(req.pipeline_id.get()); r_clone.request.borrow_mut().pipeline_id = req.pipeline_id;
{ {
let mut borrowed_r_request = r_clone.request.borrow_mut(); let mut borrowed_r_request = r_clone.request.borrow_mut();
*borrowed_r_request.origin.borrow_mut() = req.origin.borrow().clone(); borrowed_r_request.origin = req.origin.clone();
} }
*r_clone.request.borrow_mut() = req.clone(); *r_clone.request.borrow_mut() = req.clone();
r_clone.body_used.set(body_used); r_clone.body_used.set(body_used);
@ -540,15 +536,13 @@ impl RequestMethods for Request {
// https://fetch.spec.whatwg.org/#dom-request-method // https://fetch.spec.whatwg.org/#dom-request-method
fn Method(&self) -> ByteString { fn Method(&self) -> ByteString {
let r = self.request.borrow(); let r = self.request.borrow();
let m = r.method.borrow(); ByteString::new(r.method.as_ref().as_bytes().into())
ByteString::new(m.as_ref().as_bytes().into())
} }
// https://fetch.spec.whatwg.org/#dom-request-url // https://fetch.spec.whatwg.org/#dom-request-url
fn Url(&self) -> USVString { fn Url(&self) -> USVString {
let r = self.request.borrow(); let r = self.request.borrow();
let url = r.url_list.borrow(); USVString(r.url_list.get(0).map_or("", |u| u.as_str()).into())
USVString(url.get(0).map_or("", |u| u.as_str()).into())
} }
// https://fetch.spec.whatwg.org/#dom-request-headers // https://fetch.spec.whatwg.org/#dom-request-headers
@ -569,11 +563,10 @@ impl RequestMethods for Request {
// https://fetch.spec.whatwg.org/#dom-request-referrer // https://fetch.spec.whatwg.org/#dom-request-referrer
fn Referrer(&self) -> USVString { fn Referrer(&self) -> USVString {
let r = self.request.borrow(); let r = self.request.borrow();
let referrer = r.referrer.borrow(); USVString(match r.referrer {
USVString(match &*referrer { NetTraitsRequestReferrer::NoReferrer => String::from("no-referrer"),
&NetTraitsRequestReferrer::NoReferrer => String::from("no-referrer"), NetTraitsRequestReferrer::Client => String::from("about:client"),
&NetTraitsRequestReferrer::Client => String::from("about:client"), NetTraitsRequestReferrer::ReferrerUrl(ref u) => {
&NetTraitsRequestReferrer::ReferrerUrl(ref u) => {
let u_c = u.clone(); let u_c = u.clone();
u_c.into_string() u_c.into_string()
} }
@ -582,7 +575,7 @@ impl RequestMethods for Request {
// https://fetch.spec.whatwg.org/#dom-request-referrerpolicy // https://fetch.spec.whatwg.org/#dom-request-referrerpolicy
fn ReferrerPolicy(&self) -> ReferrerPolicy { fn ReferrerPolicy(&self) -> ReferrerPolicy {
self.request.borrow().referrer_policy.get().map(|m| m.into()).unwrap_or(ReferrerPolicy::_empty) self.request.borrow().referrer_policy.map(|m| m.into()).unwrap_or(ReferrerPolicy::_empty)
} }
// https://fetch.spec.whatwg.org/#dom-request-mode // https://fetch.spec.whatwg.org/#dom-request-mode
@ -599,20 +592,19 @@ impl RequestMethods for Request {
// https://fetch.spec.whatwg.org/#dom-request-cache // https://fetch.spec.whatwg.org/#dom-request-cache
fn Cache(&self) -> RequestCache { fn Cache(&self) -> RequestCache {
let r = self.request.borrow().clone(); let r = self.request.borrow().clone();
r.cache_mode.get().into() r.cache_mode.into()
} }
// https://fetch.spec.whatwg.org/#dom-request-redirect // https://fetch.spec.whatwg.org/#dom-request-redirect
fn Redirect(&self) -> RequestRedirect { fn Redirect(&self) -> RequestRedirect {
let r = self.request.borrow().clone(); let r = self.request.borrow().clone();
r.redirect_mode.get().into() r.redirect_mode.into()
} }
// https://fetch.spec.whatwg.org/#dom-request-integrity // https://fetch.spec.whatwg.org/#dom-request-integrity
fn Integrity(&self) -> DOMString { fn Integrity(&self) -> DOMString {
let r = self.request.borrow(); let r = self.request.borrow();
let integrity = r.integrity_metadata.borrow(); DOMString::from_string(r.integrity_metadata.clone())
DOMString::from_string(integrity.clone())
} }
// https://fetch.spec.whatwg.org/#dom-body-bodyused // https://fetch.spec.whatwg.org/#dom-body-bodyused
@ -675,8 +667,8 @@ impl BodyOperations for Request {
} }
fn take_body(&self) -> Option<Vec<u8>> { fn take_body(&self) -> Option<Vec<u8>> {
let request = self.request.borrow_mut(); let mut request = self.request.borrow_mut();
let body = request.body.borrow_mut().take(); let body = request.body.take();
Some(body.unwrap_or(vec![])) Some(body.unwrap_or(vec![]))
} }

15
components/script/fetch.rs
View file

@ -37,17 +37,16 @@ struct FetchContext {
} }
fn from_referrer_to_referrer_url(request: &NetTraitsRequest) -> Option<ServoUrl> { fn from_referrer_to_referrer_url(request: &NetTraitsRequest) -> Option<ServoUrl> {
let referrer = request.referrer.borrow(); request.referrer.to_url().map(|url| url.clone())
referrer.to_url().map(|url| url.clone())
} }
fn request_init_from_request(request: NetTraitsRequest) -> NetTraitsRequestInit { fn request_init_from_request(request: NetTraitsRequest) -> NetTraitsRequestInit {
NetTraitsRequestInit { NetTraitsRequestInit {
method: request.method.borrow().clone(), method: request.method.clone(),
url: request.url(), url: request.url(),
headers: request.headers.borrow().clone(), headers: request.headers.clone(),
unsafe_request: request.unsafe_request, unsafe_request: request.unsafe_request,
body: request.body.borrow().clone(), body: request.body.clone(),
type_: request.type_, type_: request.type_,
destination: request.destination, destination: request.destination,
synchronous: request.synchronous, synchronous: request.synchronous,
@ -60,9 +59,9 @@ fn request_init_from_request(request: NetTraitsRequest) -> NetTraitsRequestInit
// ... NetTraitsRequest.origin: RefCell<Origin> // ... NetTraitsRequest.origin: RefCell<Origin>
origin: request.url(), origin: request.url(),
referrer_url: from_referrer_to_referrer_url(&request), referrer_url: from_referrer_to_referrer_url(&request),
referrer_policy: request.referrer_policy.get(), referrer_policy: request.referrer_policy,
pipeline_id: request.pipeline_id.get(), pipeline_id: request.pipeline_id,
redirect_mode: request.redirect_mode.get(), redirect_mode: request.redirect_mode,
..NetTraitsRequestInit::default() ..NetTraitsRequestInit::default()
} }
} }

4
tests/unit/net/data_loader.rs
View file

@ -19,9 +19,9 @@ fn assert_parse(url: &'static str,
data: Option<&[u8]>) { data: Option<&[u8]>) {
let url = ServoUrl::parse(url).unwrap(); let url = ServoUrl::parse(url).unwrap();
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
let response = fetch(request, None); let response = fetch(&mut request, None);
match data { match data {
Some(data) => { Some(data) => {

166
tests/unit/net/fetch.rs
View file

@ -23,6 +23,7 @@ use hyper::status::StatusCode;
use hyper::uri::RequestUri; use hyper::uri::RequestUri;
use hyper_openssl; use hyper_openssl;
use msg::constellation_msg::TEST_PIPELINE_ID; use msg::constellation_msg::TEST_PIPELINE_ID;
use net::connector::{create_http_connector, create_ssl_client};
use net::fetch::cors_cache::CorsCache; use net::fetch::cors_cache::CorsCache;
use net::fetch::methods::FetchContext; use net::fetch::methods::FetchContext;
use net::filemanager_thread::FileManager; use net::filemanager_thread::FileManager;
@ -37,7 +38,6 @@ use servo_config::resource_files::resources_dir_path;
use servo_url::{ImmutableOrigin, ServoUrl}; use servo_url::{ImmutableOrigin, ServoUrl};
use std::fs::File; use std::fs::File;
use std::io::Read; use std::io::Read;
use std::rc::Rc;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::mpsc::{Sender, channel}; use std::sync::mpsc::{Sender, channel};
@ -55,9 +55,9 @@ fn test_fetch_response_is_not_network_error() {
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
if fetch_response.is_network_error() { if fetch_response.is_network_error() {
@ -69,9 +69,9 @@ fn test_fetch_response_is_not_network_error() {
fn test_fetch_on_bad_port_is_network_error() { fn test_fetch_on_bad_port_is_network_error() {
let url = ServoUrl::parse("http://www.example.org:6667").unwrap(); let url = ServoUrl::parse("http://www.example.org:6667").unwrap();
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
assert!(fetch_response.is_network_error()); assert!(fetch_response.is_network_error());
let fetch_error = fetch_response.get_network_error().unwrap(); let fetch_error = fetch_response.get_network_error().unwrap();
assert!(fetch_error == &NetworkError::Internal("Request attempted on bad port".into())) assert!(fetch_error == &NetworkError::Internal("Request attempted on bad port".into()))
@ -86,9 +86,9 @@ fn test_fetch_response_body_matches_const_message() {
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
@ -106,9 +106,9 @@ fn test_fetch_response_body_matches_const_message() {
fn test_fetch_aboutblank() { fn test_fetch_aboutblank() {
let url = ServoUrl::parse("about:blank").unwrap(); let url = ServoUrl::parse("about:blank").unwrap();
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
assert!(*fetch_response.body.lock().unwrap() == ResponseBody::Done(vec![])); assert!(*fetch_response.body.lock().unwrap() == ResponseBody::Done(vec![]));
} }
@ -136,8 +136,8 @@ fn test_fetch_blob() {
let url = ServoUrl::parse(&format!("blob:{}{}", origin.as_str(), id.simple())).unwrap(); let url = ServoUrl::parse(&format!("blob:{}{}", origin.as_str(), id.simple())).unwrap();
let request = Request::new(url, Some(Origin::Origin(origin.origin())), false, None); let mut request = Request::new(url, Some(Origin::Origin(origin.origin())), false, None);
let fetch_response = fetch_with_context(request, &context); let fetch_response = fetch_with_context(&mut request, &context);
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
@ -160,9 +160,9 @@ fn test_fetch_file() {
let url = ServoUrl::from_file_path(path.clone()).unwrap(); let url = ServoUrl::from_file_path(path.clone()).unwrap();
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
assert_eq!(fetch_response.headers.len(), 1); assert_eq!(fetch_response.headers.len(), 1);
let content_type: &ContentType = fetch_response.headers.get().unwrap(); let content_type: &ContentType = fetch_response.headers.get().unwrap();
@ -185,9 +185,9 @@ fn test_fetch_file() {
fn test_fetch_ftp() { fn test_fetch_ftp() {
let url = ServoUrl::parse("ftp://not-supported").unwrap(); let url = ServoUrl::parse("ftp://not-supported").unwrap();
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
assert!(fetch_response.is_network_error()); assert!(fetch_response.is_network_error());
} }
@ -195,9 +195,9 @@ fn test_fetch_ftp() {
fn test_fetch_bogus_scheme() { fn test_fetch_bogus_scheme() {
let url = ServoUrl::parse("bogus://whatever").unwrap(); let url = ServoUrl::parse("bogus://whatever").unwrap();
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
assert!(fetch_response.is_network_error()); assert!(fetch_response.is_network_error());
} }
@ -224,11 +224,11 @@ fn test_cors_preflight_fetch() {
let origin = Origin::Origin(ImmutableOrigin::new_opaque()); let origin = Origin::Origin(ImmutableOrigin::new_opaque());
let mut request = Request::new(url.clone(), Some(origin), false, None); let mut request = Request::new(url.clone(), Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::ReferrerUrl(target_url); request.referrer = Referrer::ReferrerUrl(target_url);
*request.referrer_policy.get_mut() = Some(ReferrerPolicy::Origin); request.referrer_policy = Some(ReferrerPolicy::Origin);
request.use_cors_preflight = true; request.use_cors_preflight = true;
request.mode = RequestMode::CorsMode; request.mode = RequestMode::CorsMode;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
@ -261,14 +261,14 @@ fn test_cors_preflight_cache_fetch() {
let origin = Origin::Origin(ImmutableOrigin::new_opaque()); let origin = Origin::Origin(ImmutableOrigin::new_opaque());
let mut request = Request::new(url.clone(), Some(origin.clone()), false, None); let mut request = Request::new(url.clone(), Some(origin.clone()), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
request.use_cors_preflight = true; request.use_cors_preflight = true;
request.mode = RequestMode::CorsMode; request.mode = RequestMode::CorsMode;
let wrapped_request0 = Rc::new(request.clone()); let mut wrapped_request0 = request.clone();
let wrapped_request1 = Rc::new(request); let mut wrapped_request1 = request;
let fetch_response0 = fetch_with_cors_cache(wrapped_request0.clone(), &mut cache); let fetch_response0 = fetch_with_cors_cache(&mut wrapped_request0, &mut cache);
let fetch_response1 = fetch_with_cors_cache(wrapped_request1.clone(), &mut cache); let fetch_response1 = fetch_with_cors_cache(&mut wrapped_request1, &mut cache);
let _ = server.close(); let _ = server.close();
assert!(!fetch_response0.is_network_error() && !fetch_response1.is_network_error()); assert!(!fetch_response0.is_network_error() && !fetch_response1.is_network_error());
@ -277,8 +277,8 @@ fn test_cors_preflight_cache_fetch() {
assert_eq!(1, counter.load(Ordering::SeqCst)); assert_eq!(1, counter.load(Ordering::SeqCst));
// The entry exists in the CORS-preflight cache // The entry exists in the CORS-preflight cache
assert_eq!(true, cache.match_method(&*wrapped_request0, Method::Get)); assert_eq!(true, cache.match_method(&wrapped_request0, Method::Get));
assert_eq!(true, cache.match_method(&*wrapped_request1, Method::Get)); assert_eq!(true, cache.match_method(&wrapped_request1, Method::Get));
match *fetch_response0.body.lock().unwrap() { match *fetch_response0.body.lock().unwrap() {
ResponseBody::Done(ref body) => assert_eq!(&**body, ACK), ResponseBody::Done(ref body) => assert_eq!(&**body, ACK),
@ -310,11 +310,11 @@ fn test_cors_preflight_fetch_network_error() {
let origin = Origin::Origin(ImmutableOrigin::new_opaque()); let origin = Origin::Origin(ImmutableOrigin::new_opaque());
let mut request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.method.borrow_mut() = Method::Extension("CHICKEN".to_owned()); request.method = Method::Extension("CHICKEN".to_owned());
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
request.use_cors_preflight = true; request.use_cors_preflight = true;
request.mode = RequestMode::CorsMode; request.mode = RequestMode::CorsMode;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert!(fetch_response.is_network_error()); assert!(fetch_response.is_network_error());
@ -333,9 +333,9 @@ fn test_fetch_response_is_basic_filtered() {
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
@ -379,9 +379,9 @@ fn test_fetch_response_is_cors_filtered() {
// an origin mis-match will stop it from defaulting to a basic filtered response // an origin mis-match will stop it from defaulting to a basic filtered response
let origin = Origin::Origin(ImmutableOrigin::new_opaque()); let origin = Origin::Origin(ImmutableOrigin::new_opaque());
let mut request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
request.mode = RequestMode::CorsMode; request.mode = RequestMode::CorsMode;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
@ -410,16 +410,16 @@ fn test_fetch_response_is_opaque_filtered() {
// an origin mis-match will fall through to an Opaque filtered response // an origin mis-match will fall through to an Opaque filtered response
let origin = Origin::Origin(ImmutableOrigin::new_opaque()); let origin = Origin::Origin(ImmutableOrigin::new_opaque());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
assert_eq!(fetch_response.response_type, ResponseType::Opaque); assert_eq!(fetch_response.response_type, ResponseType::Opaque);
assert!(fetch_response.url().is_none()); assert!(fetch_response.url().is_none());
assert!(fetch_response.url_list.into_inner().len() == 0); assert!(fetch_response.url_list.is_empty());
// this also asserts that status message is "the empty byte sequence" // this also asserts that status message is "the empty byte sequence"
assert!(fetch_response.status.is_none()); assert!(fetch_response.status.is_none());
assert_eq!(fetch_response.headers, Headers::new()); assert_eq!(fetch_response.headers, Headers::new());
@ -457,10 +457,10 @@ fn test_fetch_response_is_opaque_redirect_filtered() {
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
request.redirect_mode.set(RedirectMode::Manual); request.redirect_mode = RedirectMode::Manual;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert!(!fetch_response.is_network_error()); assert!(!fetch_response.is_network_error());
@ -492,12 +492,12 @@ fn test_fetch_with_local_urls_only() {
let do_fetch = |url: ServoUrl| { let do_fetch = |url: ServoUrl| {
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let mut request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
// Set the flag. // Set the flag.
request.local_urls_only = true; request.local_urls_only = true;
fetch(request, None) fetch(&mut request, None)
}; };
let local_url = ServoUrl::parse("about:blank").unwrap(); let local_url = ServoUrl::parse("about:blank").unwrap();
@ -530,11 +530,15 @@ fn test_fetch_with_hsts() {
//takes an address and something that implements hyper::net::Ssl //takes an address and something that implements hyper::net::Ssl
let mut server = Server::https("0.0.0.0:0", ssl).unwrap().handle_threads(handler, 1).unwrap(); let mut server = Server::https("0.0.0.0:0", ssl).unwrap().handle_threads(handler, 1).unwrap();
let ssl_client = create_ssl_client("self_signed_certificate_for_testing.crt");
let connector = create_http_connector(ssl_client);
let context = FetchContext { let context = FetchContext {
state: HttpState::new("self_signed_certificate_for_testing.crt"), state: Arc::new(HttpState::new()),
user_agent: DEFAULT_USER_AGENT.into(), user_agent: DEFAULT_USER_AGENT.into(),
devtools_chan: None, devtools_chan: None,
filemanager: FileManager::new(), filemanager: FileManager::new(),
connector: connector,
}; };
{ {
@ -546,10 +550,10 @@ fn test_fetch_with_hsts() {
let url = ServoUrl::parse(&url_string).unwrap(); let url = ServoUrl::parse(&url_string).unwrap();
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let mut request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
// Set the flag. // Set the flag.
request.local_urls_only = false; request.local_urls_only = false;
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
assert_eq!(response.internal_response.unwrap().url().unwrap().scheme(), assert_eq!(response.internal_response.unwrap().url().unwrap().scheme(),
"https"); "https");
@ -565,15 +569,15 @@ fn test_fetch_with_sri_network_error() {
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let mut request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
// To calulate hash use : // To calulate hash use :
// echo -n "alert('Hello, Network Error');" | openssl dgst -sha384 -binary | openssl base64 -A // echo -n "alert('Hello, Network Error');" | openssl dgst -sha384 -binary | openssl base64 -A
*request.integrity_metadata.borrow_mut() = request.integrity_metadata =
"sha384-H8BRh8j48O9oYatfu5AZzq6A9RINhZO5H16dQZngK7T62em8MUt1FLm52t+eX6xO".to_owned(); "sha384-H8BRh8j48O9oYatfu5AZzq6A9RINhZO5H16dQZngK7T62em8MUt1FLm52t+eX6xO".to_owned();
// Set the flag. // Set the flag.
request.local_urls_only = false; request.local_urls_only = false;
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert!(response.is_network_error()); assert!(response.is_network_error());
@ -589,15 +593,15 @@ fn test_fetch_with_sri_sucess() {
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let mut request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
// To calulate hash use : // To calulate hash use :
// echo -n "alert('Hello, Network Error');" | openssl dgst -sha384 -binary | openssl base64 -A // echo -n "alert('Hello, Network Error');" | openssl dgst -sha384 -binary | openssl base64 -A
*request.integrity_metadata.borrow_mut() = request.integrity_metadata =
"sha384-H8BRh8j48O9oYatfu5AZzq6A9RINhZO5H16dQZngK7T62em8MUt1FLm52t+eX6xO".to_owned(); "sha384-H8BRh8j48O9oYatfu5AZzq6A9RINhZO5H16dQZngK7T62em8MUt1FLm52t+eX6xO".to_owned();
// Set the flag. // Set the flag.
request.local_urls_only = false; request.local_urls_only = false;
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert_eq!(response_is_done(&response), true); assert_eq!(response_is_done(&response), true);
@ -629,7 +633,7 @@ fn test_fetch_blocked_nosniff() {
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let mut request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
request.type_ = request_type; request.type_ = request_type;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert_eq!(fetch_response.is_network_error(), should_error); assert_eq!(fetch_response.is_network_error(), should_error);
@ -669,9 +673,9 @@ fn setup_server_and_fetch(message: &'static [u8], redirect_cap: u32) -> Response
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
fetch_response fetch_response
} }
@ -752,11 +756,11 @@ fn test_fetch_redirect_updates_method_runner(tx: Sender<bool>, status_code: Stat
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
*request.method.borrow_mut() = method; request.method = method;
let _ = fetch(request, None); let _ = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
} }
@ -827,10 +831,10 @@ fn test_fetch_async_returns_complete_response() {
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
assert_eq!(response_is_done(&fetch_response), true); assert_eq!(response_is_done(&fetch_response), true);
@ -846,10 +850,10 @@ fn test_opaque_filtered_fetch_async_returns_complete_response() {
// an origin mis-match will fall through to an Opaque filtered response // an origin mis-match will fall through to an Opaque filtered response
let origin = Origin::Origin(ImmutableOrigin::new_opaque()); let origin = Origin::Origin(ImmutableOrigin::new_opaque());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -881,11 +885,11 @@ fn test_opaque_redirect_filtered_fetch_async_returns_complete_response() {
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url, Some(origin), false, None); let mut request = Request::new(url, Some(origin), false, None);
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
request.redirect_mode.set(RedirectMode::Manual); request.redirect_mode = RedirectMode::Manual;
let fetch_response = fetch(request, None); let fetch_response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -903,12 +907,12 @@ fn test_fetch_with_devtools() {
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let origin = Origin::Origin(url.origin()); let origin = Origin::Origin(url.origin());
let request = Request::new(url.clone(), Some(origin), false, Some(TEST_PIPELINE_ID)); let mut request = Request::new(url.clone(), Some(origin), false, Some(TEST_PIPELINE_ID));
*request.referrer.borrow_mut() = Referrer::NoReferrer; request.referrer = Referrer::NoReferrer;
let (devtools_chan, devtools_port) = channel::<DevtoolsControlMsg>(); let (devtools_chan, devtools_port) = channel::<DevtoolsControlMsg>();
let _ = fetch(request, Some(devtools_chan)); let _ = fetch(&mut request, Some(devtools_chan));
let _ = server.close(); let _ = server.close();
// notification received from devtools // notification received from devtools

141
tests/unit/net/http_loader.rs
View file

@ -50,7 +50,7 @@ fn read_response(reader: &mut Read) -> String {
} }
} }
fn assert_cookie_for_domain(cookie_jar: Arc<RwLock<CookieStorage>>, domain: &str, cookie: Option<&str>) { fn assert_cookie_for_domain(cookie_jar: &RwLock<CookieStorage>, domain: &str, cookie: Option<&str>) {
let mut cookie_jar = cookie_jar.write().unwrap(); let mut cookie_jar = cookie_jar.write().unwrap();
let url = ServoUrl::parse(&*domain).unwrap(); let url = ServoUrl::parse(&*domain).unwrap();
let cookies = cookie_jar.cookies_for_url(&url, CookieSource::HTTP); let cookies = cookie_jar.cookies_for_url(&url, CookieSource::HTTP);
@ -134,7 +134,7 @@ 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 request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -142,7 +142,7 @@ fn test_check_default_headers_loaded_in_every_request() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
// Testing for method.POST // Testing for method.POST
@ -153,7 +153,7 @@ fn test_check_default_headers_loaded_in_every_request() {
// "Origin: http://example.com/" which do not match for equality so strip trailing '/' // "Origin: http://example.com/" which do not match for equality so strip trailing '/'
post_headers.set(Origin::from_str(&url_str[..url_str.len()-1]).unwrap()); post_headers.set(Origin::from_str(&url_str[..url_str.len()-1]).unwrap());
*expected_headers.lock().unwrap() = Some(post_headers); *expected_headers.lock().unwrap() = Some(post_headers);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Post, method: Method::Post,
destination: Destination::Document, destination: Destination::Document,
@ -161,7 +161,7 @@ fn test_check_default_headers_loaded_in_every_request() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
let _ = server.close(); let _ = server.close();
@ -174,7 +174,7 @@ fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Post, method: Method::Post,
body: None, body: None,
@ -183,7 +183,7 @@ fn test_load_when_request_is_not_get_or_head_and_there_is_no_body_content_length
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
let _ = server.close(); let _ = server.close();
@ -199,7 +199,7 @@ fn test_request_and_response_data_with_network_messages() {
let mut request_headers = Headers::new(); let mut request_headers = Headers::new();
request_headers.set(Host { hostname: "bar.foo".to_owned(), port: None }); request_headers.set(Host { hostname: "bar.foo".to_owned(), port: None });
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
headers: request_headers, headers: request_headers,
@ -210,7 +210,7 @@ fn test_request_and_response_data_with_network_messages() {
.. RequestInit::default() .. RequestInit::default()
}); });
let (devtools_chan, devtools_port) = mpsc::channel(); let (devtools_chan, devtools_port) = mpsc::channel();
let response = fetch(request, Some(devtools_chan)); let response = fetch(&mut request, Some(devtools_chan));
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
let _ = server.close(); let _ = server.close();
@ -288,7 +288,7 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() {
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -297,7 +297,7 @@ fn test_request_and_response_message_from_devtool_without_pipeline_id() {
.. RequestInit::default() .. RequestInit::default()
}); });
let (devtools_chan, devtools_port) = mpsc::channel(); let (devtools_chan, devtools_port) = mpsc::channel();
let response = fetch(request, Some(devtools_chan)); let response = fetch(&mut request, Some(devtools_chan));
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
let _ = server.close(); let _ = server.close();
@ -323,7 +323,7 @@ fn test_redirected_request_to_devtools() {
}; };
let (mut pre_server, pre_url) = make_server(pre_handler); let (mut pre_server, pre_url) = make_server(pre_handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: pre_url.clone(), url: pre_url.clone(),
method: Method::Post, method: Method::Post,
destination: Destination::Document, destination: Destination::Document,
@ -332,7 +332,7 @@ fn test_redirected_request_to_devtools() {
.. RequestInit::default() .. RequestInit::default()
}); });
let (devtools_chan, devtools_port) = mpsc::channel(); let (devtools_chan, devtools_port) = mpsc::channel();
fetch(request, Some(devtools_chan)); fetch(&mut request, Some(devtools_chan));
let _ = pre_server.close(); let _ = pre_server.close();
let _ = post_server.close(); let _ = post_server.close();
@ -371,7 +371,7 @@ fn test_load_when_redirecting_from_a_post_should_rewrite_next_request_as_get() {
}; };
let (mut pre_server, pre_url) = make_server(pre_handler); let (mut pre_server, pre_url) = make_server(pre_handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: pre_url.clone(), url: pre_url.clone(),
method: Method::Post, method: Method::Post,
destination: Destination::Document, destination: Destination::Document,
@ -379,7 +379,7 @@ fn test_load_when_redirecting_from_a_post_should_rewrite_next_request_as_get() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = pre_server.close(); let _ = pre_server.close();
let _ = post_server.close(); let _ = post_server.close();
@ -398,7 +398,7 @@ fn test_load_should_decode_the_response_as_deflate_when_response_headers_have_co
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -407,7 +407,7 @@ fn test_load_should_decode_the_response_as_deflate_when_response_headers_have_co
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -427,7 +427,7 @@ fn test_load_should_decode_the_response_as_gzip_when_response_headers_have_conte
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -436,7 +436,7 @@ fn test_load_should_decode_the_response_as_gzip_when_response_headers_have_conte
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -465,7 +465,7 @@ fn test_load_doesnt_send_request_body_on_any_redirect() {
}; };
let (mut pre_server, pre_url) = make_server(pre_handler); let (mut pre_server, pre_url) = make_server(pre_handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: 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,
@ -474,7 +474,7 @@ fn test_load_doesnt_send_request_body_on_any_redirect() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = pre_server.close(); let _ = pre_server.close();
let _ = post_server.close(); let _ = post_server.close();
@ -490,7 +490,7 @@ fn test_load_doesnt_add_host_to_sts_list_when_url_is_http_even_if_sts_headers_ar
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -500,7 +500,7 @@ fn test_load_doesnt_add_host_to_sts_list_when_url_is_http_even_if_sts_headers_ar
.. RequestInit::default() .. RequestInit::default()
}); });
let context = new_fetch_context(None); let context = new_fetch_context(None);
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
@ -518,9 +518,9 @@ fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_
let context = new_fetch_context(None); let context = new_fetch_context(None);
assert_cookie_for_domain(context.state.cookie_jar.clone(), url.as_str(), None); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -530,13 +530,13 @@ fn test_load_sets_cookies_in_the_resource_manager_when_it_get_set_cookie_header_
credentials_mode: CredentialsMode::Include, credentials_mode: CredentialsMode::Include,
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
assert_cookie_for_domain(context.state.cookie_jar.clone(), url.as_str(), Some("mozillaIs=theBest")); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), Some("mozillaIs=theBest"));
} }
#[test] #[test]
@ -560,7 +560,7 @@ 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 request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -570,7 +570,7 @@ fn test_load_sets_requests_cookies_header_for_url_by_getting_cookies_from_the_re
credentials_mode: CredentialsMode::Include, credentials_mode: CredentialsMode::Include,
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
@ -598,7 +598,7 @@ fn test_load_sends_cookie_if_nonhttp() {
cookie_jar.push(cookie, &url, CookieSource::HTTP); cookie_jar.push(cookie, &url, CookieSource::HTTP);
} }
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -608,7 +608,7 @@ fn test_load_sends_cookie_if_nonhttp() {
credentials_mode: CredentialsMode::Include, credentials_mode: CredentialsMode::Include,
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
@ -626,9 +626,9 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl(
let context = new_fetch_context(None); let context = new_fetch_context(None);
assert_cookie_for_domain(context.state.cookie_jar.clone(), url.as_str(), None); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -638,13 +638,13 @@ fn test_cookie_set_with_httponly_should_not_be_available_using_getcookiesforurl(
credentials_mode: CredentialsMode::Include, credentials_mode: CredentialsMode::Include,
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
assert_cookie_for_domain(context.state.cookie_jar.clone(), url.as_str(), Some("mozillaIs=theBest")); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), Some("mozillaIs=theBest"));
let mut cookie_jar = context.state.cookie_jar.write().unwrap(); let mut cookie_jar = context.state.cookie_jar.write().unwrap();
assert!(cookie_jar.cookies_for_url(&url, CookieSource::NonHTTP).is_none()); assert!(cookie_jar.cookies_for_url(&url, CookieSource::NonHTTP).is_none());
} }
@ -660,9 +660,9 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() {
let context = new_fetch_context(None); let context = new_fetch_context(None);
assert_cookie_for_domain(context.state.cookie_jar.clone(), url.as_str(), None); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -672,13 +672,13 @@ fn test_when_cookie_received_marked_secure_is_ignored_for_http() {
credentials_mode: CredentialsMode::Include, credentials_mode: CredentialsMode::Include,
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
assert_cookie_for_domain(context.state.cookie_jar.clone(), url.as_str(), None); assert_cookie_for_domain(&context.state.cookie_jar, url.as_str(), None);
} }
#[test] #[test]
@ -691,7 +691,7 @@ fn test_load_sets_content_length_to_length_of_request_body() {
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Post, method: Method::Post,
body: Some(content.to_vec()), body: Some(content.to_vec()),
@ -700,7 +700,7 @@ fn test_load_sets_content_length_to_length_of_request_body() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -719,7 +719,7 @@ fn test_load_uses_explicit_accept_from_headers_in_load_data() {
let mut accept_headers = Headers::new(); let mut accept_headers = Headers::new();
accept_headers.set(accept); accept_headers.set(accept);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
headers: accept_headers, headers: accept_headers,
@ -728,7 +728,7 @@ fn test_load_uses_explicit_accept_from_headers_in_load_data() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -748,7 +748,7 @@ fn test_load_sets_default_accept_to_html_xhtml_xml_and_then_anything_else() {
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -756,7 +756,7 @@ fn test_load_sets_default_accept_to_html_xhtml_xml_and_then_anything_else() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -775,7 +775,7 @@ fn test_load_uses_explicit_accept_encoding_from_load_data_headers() {
let mut accept_encoding_headers = Headers::new(); let mut accept_encoding_headers = Headers::new();
accept_encoding_headers.set(accept_encoding); accept_encoding_headers.set(accept_encoding);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
headers: accept_encoding_headers, headers: accept_encoding_headers,
@ -784,7 +784,7 @@ fn test_load_uses_explicit_accept_encoding_from_load_data_headers() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -803,7 +803,7 @@ fn test_load_sets_default_accept_encoding_to_gzip_and_deflate() {
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -811,7 +811,7 @@ fn test_load_sets_default_accept_encoding_to_gzip_and_deflate() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -839,7 +839,7 @@ 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 request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url_a.clone(), url: url_a.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -847,7 +847,7 @@ fn test_load_errors_when_there_a_redirect_loop() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server_a.close(); let _ = server_a.close();
let _ = server_b.close(); let _ = server_b.close();
@ -882,7 +882,7 @@ 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 request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url_a.clone(), url: url_a.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -890,14 +890,13 @@ fn test_load_succeeds_with_a_redirect_loop() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server_a.close(); let _ = server_a.close();
let _ = server_b.close(); let _ = server_b.close();
let response = response.to_actual(); let response = response.to_actual();
assert_eq!(*response.url_list.borrow(), assert_eq!(response.url_list, [url_a.clone(), url_b, url_a]);
[url_a.clone(), url_b, url_a]);
assert_eq!(*response.body.lock().unwrap(), assert_eq!(*response.body.lock().unwrap(),
ResponseBody::Done(b"Success".to_vec())); ResponseBody::Done(b"Success".to_vec()));
} }
@ -919,7 +918,7 @@ fn test_load_follows_a_redirect() {
}; };
let (mut pre_server, pre_url) = make_server(pre_handler); let (mut pre_server, pre_url) = make_server(pre_handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: pre_url.clone(), url: pre_url.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -927,7 +926,7 @@ fn test_load_follows_a_redirect() {
pipeline_id: Some(TEST_PIPELINE_ID), pipeline_id: Some(TEST_PIPELINE_ID),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = pre_server.close(); let _ = pre_server.close();
let _ = post_server.close(); let _ = post_server.close();
@ -996,7 +995,7 @@ 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 request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url_x.clone(), url: url_x.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -1005,7 +1004,7 @@ fn test_redirect_from_x_to_y_provides_y_cookies_from_y() {
credentials_mode: CredentialsMode::Include, credentials_mode: CredentialsMode::Include,
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
@ -1040,7 +1039,7 @@ 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 request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
destination: Destination::Document, destination: Destination::Document,
@ -1049,7 +1048,7 @@ fn test_redirect_from_x_to_x_provides_x_with_cookie_from_first_response() {
credentials_mode: CredentialsMode::Include, credentials_mode: CredentialsMode::Include,
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -1071,7 +1070,7 @@ fn test_if_auth_creds_not_in_url_but_in_cache_it_sets_it() {
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -1090,7 +1089,7 @@ fn test_if_auth_creds_not_in_url_but_in_cache_it_sets_it() {
context.state.auth_cache.write().unwrap().entries.insert(url.origin().clone().ascii_serialization(), auth_entry); context.state.auth_cache.write().unwrap().entries.insert(url.origin().clone().ascii_serialization(), auth_entry);
let response = fetch_with_context(request, &context); let response = fetch_with_context(&mut request, &context);
let _ = server.close(); let _ = server.close();
@ -1105,7 +1104,7 @@ fn test_auth_ui_needs_www_auth() {
}; };
let (mut server, url) = make_server(handler); let (mut server, url) = make_server(handler);
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
body: None, body: None,
@ -1116,7 +1115,7 @@ fn test_auth_ui_needs_www_auth() {
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
let _ = server.close(); let _ = server.close();
@ -1139,20 +1138,20 @@ fn test_origin_set() {
let mut origin = Origin::new(url.scheme(), url.host_str().unwrap(), url.port()); let mut origin = Origin::new(url.scheme(), url.host_str().unwrap(), url.port());
*origin_header_clone.lock().unwrap() = Some(origin.clone()); *origin_header_clone.lock().unwrap() = Some(origin.clone());
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Post, method: Method::Post,
body: None, body: None,
origin: url.clone(), origin: url.clone(),
.. RequestInit::default() .. RequestInit::default()
}); });
let response = fetch(request, None); let response = fetch(&mut request, None);
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
let origin_url = ServoUrl::parse("http://example.com").unwrap(); let origin_url = ServoUrl::parse("http://example.com").unwrap();
origin = Origin::new(origin_url.scheme(), origin_url.host_str().unwrap(), origin_url.port()); origin = Origin::new(origin_url.scheme(), origin_url.host_str().unwrap(), origin_url.port());
// Test Origin header is set on Get request with CORS mode // Test Origin header is set on Get request with CORS mode
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Get, method: Method::Get,
mode: RequestMode::CorsMode, mode: RequestMode::CorsMode,
@ -1162,11 +1161,11 @@ fn test_origin_set() {
}); });
*origin_header_clone.lock().unwrap() = Some(origin.clone()); *origin_header_clone.lock().unwrap() = Some(origin.clone());
let response = fetch(request, None); let response = fetch(&mut request, None);
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
// Test Origin header is not set on method Head // Test Origin header is not set on method Head
let request = Request::from_init(RequestInit { let mut request = Request::from_init(RequestInit {
url: url.clone(), url: url.clone(),
method: Method::Head, method: Method::Head,
body: None, body: None,
@ -1175,7 +1174,7 @@ fn test_origin_set() {
}); });
*origin_header_clone.lock().unwrap() = None; *origin_header_clone.lock().unwrap() = None;
let response = fetch(request, None); let response = fetch(&mut request, None);
assert!(response.status.unwrap().is_success()); assert!(response.status.unwrap().is_success());
let _ = server.close(); let _ = server.close();

16
tests/unit/net/lib.rs
View file

@ -34,6 +34,7 @@ extern crate url;
use devtools_traits::DevtoolsControlMsg; use devtools_traits::DevtoolsControlMsg;
use hyper::server::{Handler, Listening, Server}; use hyper::server::{Handler, Listening, Server};
use net::connector::{create_http_connector, create_ssl_client};
use net::fetch::cors_cache::CorsCache; use net::fetch::cors_cache::CorsCache;
use net::fetch::methods::{self, FetchContext}; use net::fetch::methods::{self, FetchContext};
use net::filemanager_thread::FileManager; use net::filemanager_thread::FileManager;
@ -42,7 +43,7 @@ use net_traits::FetchTaskTarget;
use net_traits::request::Request; use net_traits::request::Request;
use net_traits::response::Response; use net_traits::response::Response;
use servo_url::ServoUrl; use servo_url::ServoUrl;
use std::rc::Rc; use std::sync::Arc;
use std::sync::mpsc::{Sender, channel}; use std::sync::mpsc::{Sender, channel};
const DEFAULT_USER_AGENT: &'static str = "Such Browser. Very Layout. Wow."; const DEFAULT_USER_AGENT: &'static str = "Such Browser. Very Layout. Wow.";
@ -52,11 +53,14 @@ struct FetchResponseCollector {
} }
fn new_fetch_context(dc: Option<Sender<DevtoolsControlMsg>>) -> FetchContext { fn new_fetch_context(dc: Option<Sender<DevtoolsControlMsg>>) -> FetchContext {
let ssl_client = create_ssl_client("certs");
let connector = create_http_connector(ssl_client);
FetchContext { FetchContext {
state: HttpState::new("certs"), state: Arc::new(HttpState::new()),
user_agent: DEFAULT_USER_AGENT.into(), user_agent: DEFAULT_USER_AGENT.into(),
devtools_chan: dc, devtools_chan: dc,
filemanager: FileManager::new(), filemanager: FileManager::new(),
connector: connector,
} }
} }
impl FetchTaskTarget for FetchResponseCollector { impl FetchTaskTarget for FetchResponseCollector {
@ -70,22 +74,22 @@ impl FetchTaskTarget for FetchResponseCollector {
} }
} }
fn fetch(request: Request, dc: Option<Sender<DevtoolsControlMsg>>) -> Response { fn fetch(request: &mut Request, dc: Option<Sender<DevtoolsControlMsg>>) -> Response {
fetch_with_context(request, &new_fetch_context(dc)) fetch_with_context(request, &new_fetch_context(dc))
} }
fn fetch_with_context(request: Request, context: &FetchContext) -> Response { fn fetch_with_context(request: &mut Request, context: &FetchContext) -> Response {
let (sender, receiver) = channel(); let (sender, receiver) = channel();
let mut target = FetchResponseCollector { let mut target = FetchResponseCollector {
sender: sender, sender: sender,
}; };
methods::fetch(Rc::new(request), &mut target, context); methods::fetch(request, &mut target, context);
receiver.recv().unwrap() receiver.recv().unwrap()
} }
fn fetch_with_cors_cache(request: Rc<Request>, cache: &mut CorsCache) -> Response { fn fetch_with_cors_cache(request: &mut Request, cache: &mut CorsCache) -> Response {
let (sender, receiver) = channel(); let (sender, receiver) = channel();
let mut target = FetchResponseCollector { let mut target = FetchResponseCollector {
sender: sender, sender: sender,