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

Auto merge of #9942 - jdm:load_error, r=ms2ger

Browse source 
Moving the error handling out of network loader

Rebase of #8851. Fixes #8678. Fixes #9944.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="35" align="absmiddle" alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/9942)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2016-04-20 22:19:22 +05:30
commit f051028ee8
30 changed files with 396 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

8
components/script/cors.rs
View file

@ -18,7 +18,7 @@ use hyper::header::{HeaderView, Headers};
use hyper::method::Method;
use hyper::mime::{Mime, SubLevel, TopLevel};
use hyper::status::StatusClass::Success;
use net_traits::{AsyncResponseListener, Metadata, ResponseAction};
use net_traits::{AsyncResponseListener, Metadata, NetworkError, ResponseAction};
use network_listener::{NetworkListener, PreInvoke};
use script_runtime::ScriptChan;
use std::ascii::AsciiExt;
@ -124,13 +124,15 @@ impl CORSRequest {
// This is shoe-horning the CORSReponse stuff into the rest of the async network
// framework right now. It would be worth redesigning http_fetch to do this properly.
impl AsyncResponseListener for CORSContext {
fn headers_available(&mut self, _metadata: Metadata) {
fn headers_available(&mut self, _metadata: Result<Metadata, NetworkError>) {
}
fn data_available(&mut self, _payload: Vec<u8>) {
}
fn response_complete(&mut self, _status: Result<(), String>) {
fn response_complete(&mut self, _status: Result<(), NetworkError>) {
let response = self.response.take().unwrap();
self.listener.response_available(response);
}

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

@ -57,11 +57,11 @@ use layout_interface::{LayoutChan, LayoutRPC};
use libc;
use msg::constellation_msg::ConstellationChan;
use msg::constellation_msg::{PipelineId, SubpageId, WindowSizeData};
use net_traits::Metadata;
use net_traits::image::base::{Image, ImageMetadata};
use net_traits::image_cache_thread::{ImageCacheChan, ImageCacheThread};
use net_traits::response::HttpsState;
use net_traits::storage_thread::StorageType;
use net_traits::{Metadata, NetworkError};
use offscreen_gl_context::GLLimits;
use profile_traits::mem::ProfilerChan as MemProfilerChan;
use profile_traits::time::ProfilerChan as TimeProfilerChan;
@ -287,6 +287,7 @@ no_jsmanaged_fields!(Size2D<T>);
no_jsmanaged_fields!(Arc<T>);
no_jsmanaged_fields!(Image, ImageMetadata, ImageCacheChan, ImageCacheThread);
no_jsmanaged_fields!(Metadata);
no_jsmanaged_fields!(NetworkError);
no_jsmanaged_fields!(Atom, Namespace, QualName);
no_jsmanaged_fields!(Trusted<T: Reflectable>);
no_jsmanaged_fields!(PropertyDeclarationBlock);

13
components/script/dom/htmllinkelement.rs
View file

@ -24,7 +24,7 @@ use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use layout_interface::{LayoutChan, Msg};
use msg::constellation_msg::ConstellationChan;
use net_traits::{AsyncResponseListener, AsyncResponseTarget, Metadata};
use net_traits::{AsyncResponseListener, AsyncResponseTarget, Metadata, NetworkError};
use network_listener::{NetworkListener, PreInvoke};
use script_traits::{MozBrowserEvent, ScriptMsg as ConstellationMsg};
use std::ascii::AsciiExt;
@ -271,8 +271,8 @@ struct StylesheetContext {
impl PreInvoke for StylesheetContext {}
impl AsyncResponseListener for StylesheetContext {
fn headers_available(&mut self, metadata: Metadata) {
self.metadata = Some(metadata);
fn headers_available(&mut self, metadata: Result<Metadata, NetworkError>) {
self.metadata = metadata.ok();
}
fn data_available(&mut self, payload: Vec<u8>) {
@ -280,9 +280,12 @@ impl AsyncResponseListener for StylesheetContext {
self.data.append(&mut payload);
}
fn response_complete(&mut self, _status: Result<(), String>) {
fn response_complete(&mut self, _status: Result<(), NetworkError>) {
let data = mem::replace(&mut self.data, vec!());
let metadata = self.metadata.take().unwrap();
let metadata = match self.metadata.take() {
Some(meta) => meta,
None => return,
};
// TODO: Get the actual value. http://dev.w3.org/csswg/css-syntax/#environment-encoding
let environment_encoding = UTF_8 as EncodingRef;
let protocol_encoding_label = metadata.charset.as_ref().map(|s| &**s);

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

@ -33,7 +33,7 @@ use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
use js::jsapi::RootedValue;
use js::jsval::UndefinedValue;
use net_traits::{AsyncResponseListener, AsyncResponseTarget, Metadata};
use net_traits::{AsyncResponseListener, AsyncResponseTarget, Metadata, NetworkError};
use network_listener::{NetworkListener, PreInvoke};
use script_runtime::ScriptChan;
use script_thread::MainThreadScriptChan;
@ -124,7 +124,7 @@ static SCRIPT_JS_MIMES: StaticStringVec = &[
#[derive(HeapSizeOf, JSTraceable)]
pub enum ScriptOrigin {
Internal(DOMString, Url),
External(Result<(Metadata, Vec<u8>), String>),
External(Result<(Metadata, Vec<u8>), NetworkError>),
}
/// The context required for asynchronously loading an external script source.
@ -138,23 +138,25 @@ struct ScriptContext {
/// The initial URL requested.
url: Url,
/// Indicates whether the request failed, and why
status: Result<(), String>
status: Result<(), NetworkError>
}
impl AsyncResponseListener for ScriptContext {
fn headers_available(&mut self, metadata: Metadata) {
let status_code = match metadata.status {
Some(RawStatus(c, _)) => c,
_ => 0
};
fn headers_available(&mut self, metadata: Result<Metadata, NetworkError>) {
self.metadata = metadata.ok();
let status_code = self.metadata.as_ref().and_then(|m| {
match m.status {
Some(RawStatus(c, _)) => Some(c),
_ => None,
}
}).unwrap_or(0);
self.status = match status_code {
0 => Err("No http status code received".to_owned()),
0 => Err(NetworkError::Internal("No http status code received".to_owned())),
200...299 => Ok(()), // HTTP ok status codes
_ => Err(format!("HTTP error code {}", status_code))
_ => Err(NetworkError::Internal(format!("HTTP error code {}", status_code)))
};
self.metadata = Some(metadata);
}
fn data_available(&mut self, payload: Vec<u8>) {
@ -164,7 +166,7 @@ impl AsyncResponseListener for ScriptContext {
}
}
fn response_complete(&mut self, status: Result<(), String>) {
fn response_complete(&mut self, status: Result<(), NetworkError>) {
let load = status.and(self.status.clone()).map(|_| {
let data = mem::replace(&mut self.data, vec!());
let metadata = self.metadata.take().unwrap();
@ -398,7 +400,7 @@ impl HTMLScriptElement {
let (source, external, url) = match load {
// Step 2.a.
ScriptOrigin::External(Err(e)) => {
error!("error loading script {}", e);
error!("error loading script {:?}", e);
self.dispatch_error_event();
return;
}

40
components/script/dom/servohtmlparser.rs
View file

@ -26,7 +26,7 @@ use hyper::header::ContentType;
use hyper::mime::{Mime, SubLevel, TopLevel};
use js::jsapi::JSTracer;
use msg::constellation_msg::{PipelineId, SubpageId};
use net_traits::{AsyncResponseListener, Metadata};
use net_traits::{AsyncResponseListener, Metadata, NetworkError};
use network_listener::PreInvoke;
use parse::Parser;
use script_runtime::ScriptChan;
@ -36,6 +36,7 @@ use std::cell::UnsafeCell;
use std::default::Default;
use std::ptr;
use url::Url;
use util::resource_files::read_resource_file;
#[must_root]
#[derive(JSTraceable, HeapSizeOf)]
@ -239,12 +240,23 @@ impl ParserContext {
}
impl AsyncResponseListener for ParserContext {
fn headers_available(&mut self, metadata: Metadata) {
let content_type = metadata.content_type.clone();
let parser = ScriptThread::page_fetch_complete(self.id.clone(), self.subpage.clone(),
metadata);
let parser = match parser {
fn headers_available(&mut self, meta_result: Result<Metadata, NetworkError>) {
let mut is_ssl_error = false;
let metadata = match meta_result {
Ok(meta) => Some(meta),
Err(NetworkError::SslValidation(url)) => {
is_ssl_error = true;
let mut meta = Metadata::default(url);
let mime: Option<Mime> = "text/html".parse().ok();
meta.set_content_type(mime.as_ref());
Some(meta)
},
Err(_) => None,
};
let content_type = metadata.clone().and_then(|meta| meta.content_type);
let parser = match ScriptThread::page_fetch_complete(self.id.clone(),
self.subpage.clone(),
metadata) {
Some(parser) => parser,
None => return,
};
@ -274,7 +286,15 @@ impl AsyncResponseListener for ParserContext {
parser.parse_sync();
parser.set_plaintext_state();
},
Some(ContentType(Mime(TopLevel::Text, SubLevel::Html, _))) => {}, // Handle text/html
Some(ContentType(Mime(TopLevel::Text, SubLevel::Html, _))) => { // Handle text/html
if is_ssl_error {
self.is_synthesized_document = true;
let page_bytes = read_resource_file("badcert.html").unwrap();
let page = String::from_utf8(page_bytes).unwrap();
parser.pending_input().borrow_mut().push(page);
parser.parse_sync();
}
},
Some(ContentType(Mime(TopLevel::Text, SubLevel::Xml, _))) => {}, // Handle text/xml
Some(ContentType(Mime(toplevel, sublevel, _))) => {
if toplevel.as_str() == "application" && sublevel.as_str() == "xhtml+xml" {
@ -308,7 +328,7 @@ impl AsyncResponseListener for ParserContext {
}
}
fn response_complete(&mut self, status: Result<(), String>) {
fn response_complete(&mut self, status: Result<(), NetworkError>) {
let parser = match self.parser.as_ref() {
Some(parser) => parser.root(),
None => return,
@ -316,7 +336,7 @@ impl AsyncResponseListener for ParserContext {
parser.r().document().finish_load(LoadType::PageSource(self.url.clone()));
if let Err(err) = status {
debug!("Failed to load page URL {}, error: {}", self.url.serialize(), err);
debug!("Failed to load page URL {}, error: {:?}", self.url.serialize(), err);
// TODO(Savago): we should send a notification to callers #5463.
}

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

@ -45,7 +45,7 @@ use js::jsapi::JS_ClearPendingException;
use js::jsapi::{JSContext, JS_ParseJSON, RootedValue};
use js::jsval::{JSVal, NullValue, UndefinedValue};
use net_traits::ControlMsg::Load;
use net_traits::{AsyncResponseListener, AsyncResponseTarget, Metadata};
use net_traits::{AsyncResponseListener, AsyncResponseTarget, Metadata, NetworkError};
use net_traits::{LoadConsumer, LoadContext, LoadData, ResourceCORSData, ResourceThread};
use network_listener::{NetworkListener, PreInvoke};
use parse::html::{ParseContext, parse_html};
@ -254,7 +254,7 @@ impl XMLHttpRequest {
resource_thread: ResourceThread,
load_data: LoadData) {
impl AsyncResponseListener for XHRContext {
fn headers_available(&mut self, metadata: Metadata) {
fn headers_available(&mut self, metadata: Result<Metadata, NetworkError>) {
let xhr = self.xhr.root();
let rv = xhr.process_headers_available(self.cors_request.clone(),
self.gen_id,
@ -269,7 +269,7 @@ impl XMLHttpRequest {
self.xhr.root().process_data_available(self.gen_id, self.buf.borrow().clone());
}
fn response_complete(&mut self, status: Result<(), String>) {
fn response_complete(&mut self, status: Result<(), NetworkError>) {
let rv = self.xhr.root().process_response_complete(self.gen_id, status);
*self.sync_status.borrow_mut() = Some(rv);
}
@ -870,7 +870,15 @@ impl XMLHttpRequest {
}
fn process_headers_available(&self, cors_request: Option<CORSRequest>,
gen_id: GenerationId, metadata: Metadata) -> Result<(), Error> {
gen_id: GenerationId, metadata: Result<Metadata, NetworkError>)
-> Result<(), Error> {
let metadata = match metadata {
Ok(meta) => meta,
Err(_) => {
self.process_partial_response(XHRProgress::Errored(gen_id, Error::Network));
return Err(Error::Network);
},
};
let bypass_cross_origin_check = {
// We want to be able to do cross-origin requests in browser.html.
@ -904,9 +912,7 @@ impl XMLHttpRequest {
*self.response_url.borrow_mut() = metadata.final_url.serialize_no_fragment();
// XXXManishearth Clear cache entries in case of a network error
self.process_partial_response(XHRProgress::HeadersReceived(gen_id,
metadata.headers,
metadata.status));
self.process_partial_response(XHRProgress::HeadersReceived(gen_id, metadata.headers, metadata.status));
Ok(())
}
@ -914,7 +920,7 @@ impl XMLHttpRequest {
self.process_partial_response(XHRProgress::Loading(gen_id, ByteString::new(payload)));
}
fn process_response_complete(&self, gen_id: GenerationId, status: Result<(), String>)
fn process_response_complete(&self, gen_id: GenerationId, status: Result<(), NetworkError>)
-> ErrorResult {
match status {
Ok(()) => {

6
components/script/script_thread.rs
View file

@ -492,7 +492,7 @@ pub unsafe extern "C" fn shadow_check_callback(_cx: *mut JSContext,
}
impl ScriptThread {
pub fn page_fetch_complete(id: PipelineId, subpage: Option<SubpageId>, metadata: Metadata)
pub fn page_fetch_complete(id: PipelineId, subpage: Option<SubpageId>, metadata: Option<Metadata>)
-> Option<ParserRoot> {
SCRIPT_THREAD_ROOT.with(|root| {
let script_thread = unsafe { &*root.borrow().unwrap() };
@ -1280,7 +1280,7 @@ impl ScriptThread {
/// We have received notification that the response associated with a load has completed.
/// Kick off the document and frame tree creation process using the result.
fn handle_page_fetch_complete(&self, id: PipelineId, subpage: Option<SubpageId>,
metadata: Metadata) -> Option<ParserRoot> {
metadata: Option<Metadata>) -> Option<ParserRoot> {
let idx = self.incomplete_loads.borrow().iter().position(|load| {
load.pipeline_id == id && load.parent_info.map(|info| info.1) == subpage
});
@ -1289,7 +1289,7 @@ impl ScriptThread {
match idx {
Some(idx) => {
let load = self.incomplete_loads.borrow_mut().remove(idx);
Some(self.load(metadata, load))
metadata.map(|meta| self.load(meta, load))
}
None => {
assert!(self.closed_pipelines.borrow().contains(&id));