Auto merge of #13571 - servo:simplify-fetching, r=nox

Simplify fetching code.

<!-- 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/13571)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2016-10-04 08:05:44 -05:00 committed by GitHub
commit b80769dbf5
5 changed files with 48 additions and 114 deletions

View file

@ -7,7 +7,7 @@ use fontsan;
use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
use ipc_channel::router::ROUTER;
use mime::{TopLevel, SubLevel};
use net_traits::{AsyncResponseTarget, LoadContext, PendingAsyncLoad, CoreResourceThread, ResponseAction};
use net_traits::{AsyncResponseTarget, LoadContext, CoreResourceThread, ResponseAction, load_async};
use platform::font_context::FontContextHandle;
use platform::font_list::SANS_SERIF_FONT_FAMILY;
use platform::font_list::for_each_available_family;
@ -208,17 +208,17 @@ impl FontCache {
match src {
Source::Url(ref url_source) => {
let url = &url_source.url;
let load = PendingAsyncLoad::new(LoadContext::Font,
self.core_resource_thread.clone(),
url.clone(),
None,
None,
None);
let (data_sender, data_receiver) = ipc::channel().unwrap();
let data_target = AsyncResponseTarget {
sender: data_sender,
};
load.load_async(data_target);
load_async(LoadContext::Font,
self.core_resource_thread.clone(),
url.clone(),
None,
None,
None,
data_target);
let channel_to_self = self.channel_to_self.clone();
let url = (*url).clone();
let bytes = Mutex::new(Vec::new());

View file

@ -44,7 +44,6 @@ use msg::constellation_msg::{PipelineId, ReferrerPolicy};
use request::{Request, RequestInit};
use response::{HttpsState, Response};
use std::io::Error as IOError;
use std::thread;
use storage_thread::StorageThreadMsg;
use url::Url;
use websocket::header;
@ -467,35 +466,13 @@ pub enum CoreResourceMsg {
/// Initialized but unsent request. Encapsulates everything necessary to instruct
/// the resource thread to make a new request. The `load` method *must* be called before
/// destruction or the thread will panic.
pub struct PendingAsyncLoad {
core_resource_thread: CoreResourceThread,
url: Url,
struct LoadOriginData {
pipeline: Option<PipelineId>,
guard: PendingLoadGuard,
context: LoadContext,
referrer_policy: Option<ReferrerPolicy>,
referrer_url: Option<Url>
}
struct PendingLoadGuard {
loaded: bool,
}
impl PendingLoadGuard {
fn neuter(&mut self) {
self.loaded = true;
}
}
impl Drop for PendingLoadGuard {
fn drop(&mut self) {
if !thread::panicking() {
assert!(self.loaded)
}
}
}
impl LoadOrigin for PendingAsyncLoad {
impl LoadOrigin for LoadOriginData {
fn referrer_url(&self) -> Option<Url> {
self.referrer_url.clone()
}
@ -507,42 +484,22 @@ impl LoadOrigin for PendingAsyncLoad {
}
}
impl PendingAsyncLoad {
pub fn new(context: LoadContext,
/// Instruct the resource thread to make a new request.
pub fn load_async(context: LoadContext,
core_resource_thread: CoreResourceThread,
url: Url,
pipeline: Option<PipelineId>,
referrer_policy: Option<ReferrerPolicy>,
referrer_url: Option<Url>)
-> PendingAsyncLoad {
PendingAsyncLoad {
core_resource_thread: core_resource_thread,
url: url,
referrer_url: Option<Url>,
listener: AsyncResponseTarget) {
let load = LoadOriginData {
pipeline: pipeline,
guard: PendingLoadGuard { loaded: false, },
context: context,
referrer_policy: referrer_policy,
referrer_url: referrer_url
}
}
/// Initiate the network request associated with this pending load, using the provided target.
pub fn load_async(mut self, listener: AsyncResponseTarget) {
self.guard.neuter();
let load_data = LoadData::new(self.context.clone(),
self.url.clone(),
&self);
};
let load_data = LoadData::new(context, url, &load);
let consumer = LoadConsumer::Listener(listener);
self.core_resource_thread.send(CoreResourceMsg::Load(load_data, consumer, None)).unwrap();
}
/// Initiate the fetch associated with this pending load.
pub fn fetch_async(mut self, request: RequestInit, fetch_target: IpcSender<FetchResponseMsg>) {
self.guard.neuter();
self.core_resource_thread.send(CoreResourceMsg::Fetch(request, fetch_target)).unwrap();
}
core_resource_thread.send(CoreResourceMsg::Load(load_data, consumer, None)).unwrap();
}
/// Message sent in response to `Load`. Contains metadata, and a port

View file

@ -9,8 +9,8 @@ use dom::bindings::js::JS;
use dom::document::Document;
use ipc_channel::ipc::IpcSender;
use msg::constellation_msg::{PipelineId, ReferrerPolicy};
use net_traits::{AsyncResponseTarget, PendingAsyncLoad, LoadContext};
use net_traits::{FetchResponseMsg, ResourceThreads, IpcSend};
use net_traits::{AsyncResponseTarget, CoreResourceMsg, load_async};
use net_traits::{FetchResponseMsg, LoadContext, ResourceThreads, IpcSend};
use net_traits::request::RequestInit;
use std::thread;
use url::Url;
@ -49,7 +49,7 @@ impl LoadType {
}
/// Canary value ensuring that manually added blocking loads (ie. ones that weren't
/// created via DocumentLoader::prepare_async_load) are always removed by the time
/// created via DocumentLoader::{load_async, fetch_async}) are always removed by the time
/// that the owner is destroyed.
#[derive(JSTraceable, HeapSizeOf)]
#[must_root]
@ -63,7 +63,7 @@ pub struct LoadBlocker {
impl LoadBlocker {
/// Mark the document's load event as blocked on this new load.
pub fn new(doc: &Document, load: LoadType) -> LoadBlocker {
doc.add_blocking_load(load.clone());
doc.mut_loader().add_blocking_load(load.clone());
LoadBlocker {
doc: JS::from_ref(doc),
load: Some(load),
@ -119,46 +119,35 @@ impl DocumentLoader {
}
/// Add a load to the list of blocking loads.
pub fn add_blocking_load(&mut self, load: LoadType) {
fn add_blocking_load(&mut self, load: LoadType) {
self.blocking_loads.push(load);
}
/// Create a new pending network request, which can be initiated at some point in
/// the future.
pub fn prepare_async_load(&mut self,
load: LoadType,
referrer: &Document,
referrer_policy: Option<ReferrerPolicy>) -> PendingAsyncLoad {
let context = load.to_load_context();
let url = load.url().clone();
self.add_blocking_load(load);
PendingAsyncLoad::new(context,
self.resource_threads.sender(),
url,
self.pipeline,
referrer_policy.or(referrer.get_referrer_policy()),
Some(referrer.url().clone()))
}
/// Create and initiate a new network request.
pub fn load_async(&mut self,
load: LoadType,
listener: AsyncResponseTarget,
referrer: &Document,
referrer_policy: Option<ReferrerPolicy>) {
let pending = self.prepare_async_load(load, referrer, referrer_policy);
pending.load_async(listener)
let context = load.to_load_context();
let url = load.url().clone();
self.add_blocking_load(load);
load_async(context,
self.resource_threads.sender(),
url,
self.pipeline,
referrer_policy.or(referrer.get_referrer_policy()),
Some(referrer.url().clone()),
listener);
}
/// Initiate a new fetch.
pub fn fetch_async(&mut self,
load: LoadType,
request: RequestInit,
fetch_target: IpcSender<FetchResponseMsg>,
referrer: &Document,
referrer_policy: Option<ReferrerPolicy>) {
let pending = self.prepare_async_load(load, referrer, referrer_policy);
pending.fetch_async(request, fetch_target);
fetch_target: IpcSender<FetchResponseMsg>) {
self.add_blocking_load(load);
self.resource_threads.sender().send(CoreResourceMsg::Fetch(request, fetch_target)).unwrap();
}
/// Mark an in-progress network request complete.

View file

@ -96,7 +96,7 @@ use js::jsapi::JS_GetRuntime;
use msg::constellation_msg::{ALT, CONTROL, SHIFT, SUPER};
use msg::constellation_msg::{Key, KeyModifiers, KeyState};
use msg::constellation_msg::{PipelineId, ReferrerPolicy};
use net_traits::{AsyncResponseTarget, FetchResponseMsg, IpcSend, PendingAsyncLoad};
use net_traits::{AsyncResponseTarget, FetchResponseMsg, IpcSend};
use net_traits::CookieSource::NonHTTP;
use net_traits::CoreResourceMsg::{GetCookiesForUrl, SetCookiesForUrl};
use net_traits::request::RequestInit;
@ -1423,17 +1423,6 @@ impl Document {
ReflowReason::RequestAnimationFrame);
}
/// Add a load to the list of loads blocking this document's load.
pub fn add_blocking_load(&self, load: LoadType) {
let mut loader = self.loader.borrow_mut();
loader.add_blocking_load(load)
}
pub fn prepare_async_load(&self, load: LoadType, referrer_policy: Option<ReferrerPolicy>) -> PendingAsyncLoad {
let mut loader = self.loader.borrow_mut();
loader.prepare_async_load(load, self, referrer_policy)
}
pub fn load_async(&self, load: LoadType, listener: AsyncResponseTarget, referrer_policy: Option<ReferrerPolicy>) {
let mut loader = self.loader.borrow_mut();
loader.load_async(load, listener, self, referrer_policy);
@ -1441,10 +1430,9 @@ impl Document {
pub fn fetch_async(&self, load: LoadType,
request: RequestInit,
fetch_target: IpcSender<FetchResponseMsg>,
referrer_policy: Option<ReferrerPolicy>) {
fetch_target: IpcSender<FetchResponseMsg>) {
let mut loader = self.loader.borrow_mut();
loader.fetch_async(load, request, fetch_target, self, referrer_policy);
loader.fetch_async(load, request, fetch_target);
}
pub fn finish_load(&self, load: LoadType) {

View file

@ -269,7 +269,7 @@ fn fetch_a_classic_script(script: &HTMLScriptElement,
ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
listener.notify_fetch(message.to().unwrap());
});
doc.fetch_async(LoadType::Script(url), request, action_sender, None);
doc.fetch_async(LoadType::Script(url), request, action_sender);
}
impl HTMLScriptElement {