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

Make all task source runnables cancellable

Browse source 
Implement all Runnable methods on CancellableRunnable to redirect to their inner runnable
This commit is contained in:
Connor Brewster 2016-07-11 22:59:53 -06:00
parent afc0ccb48d
commit 5f7324a9a5
14 changed files with 69 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1488,11 +1488,12 @@ impl Document {
update_with_current_time_ms(&self.dom_content_loaded_event_start);
self.window().dom_manipulation_task_source().queue_event(self.upcast(), atom!("DOMContentLoaded"),
EventBubbles::Bubbles, EventCancelable::NotCancelable);
self.window().reflow(ReflowGoal::ForDisplay,
ReflowQueryType::NoQuery,
ReflowReason::DOMContentLoaded);
let window = self.window();
window.dom_manipulation_task_source().queue_event(self.upcast(), atom!("DOMContentLoaded"),
EventBubbles::Bubbles, EventCancelable::NotCancelable, window);
window.reflow(ReflowGoal::ForDisplay,
ReflowQueryType::NoQuery,
ReflowReason::DOMContentLoaded);
update_with_current_time_ms(&self.dom_content_loaded_event_end);
}

6
components/script/dom/htmldetailselement.rs
View file

@ -19,7 +19,6 @@ use script_thread::Runnable;
use std::cell::Cell;
use string_cache::Atom;
use task_source::TaskSource;
use task_source::dom_manipulation::DOMManipulationTask;
#[dom_struct]
pub struct HTMLDetailsElement {
@ -72,14 +71,13 @@ impl VirtualMethods for HTMLDetailsElement {
self.toggle_counter.set(counter);
let window = window_from_node(self);
let window = window.r();
let task_source = window.dom_manipulation_task_source();
let details = Trusted::new(self);
let runnable = box DetailsNotificationRunnable {
let runnable = DetailsNotificationRunnable {
element: details,
toggle_number: counter
};
let _ = task_source.queue(DOMManipulationTask(runnable));
let _ = task_source.queue(runnable, window.r());
}
}
}

5
components/script/dom/htmlformelement.rs
View file

@ -53,7 +53,6 @@ use string_cache::Atom;
use style::attr::AttrValue;
use style::str::split_html_space_chars;
use task_source::TaskSource;
use task_source::dom_manipulation::DOMManipulationTask;
use url::form_urlencoded;
#[derive(JSTraceable, PartialEq, Clone, Copy, HeapSizeOf)]
@ -475,7 +474,7 @@ impl HTMLFormElement {
self.generation_id.set(GenerationId(prev_id + 1));
// Step 2
let nav = box PlannedNavigation {
let nav = PlannedNavigation {
load_data: load_data,
pipeline_id: window.pipeline(),
script_chan: window.main_thread_script_chan().clone(),
@ -484,7 +483,7 @@ impl HTMLFormElement {
};
// Step 3
window.dom_manipulation_task_source().queue(DOMManipulationTask(nav)).unwrap();
window.dom_manipulation_task_source().queue(nav, window).unwrap();
}
/// Interactively validate the constraints of form elements

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

@ -32,7 +32,6 @@ use std::sync::Arc;
use string_cache::Atom;
use style::attr::{AttrValue, LengthOrPercentageOrAuto};
use task_source::TaskSource;
use task_source::dom_manipulation::DOMManipulationTask;
use url::Url;
#[derive(JSTraceable, HeapSizeOf)]
@ -180,12 +179,12 @@ impl HTMLImageElement {
}
}
let runnable = Box::new(ImgParseErrorRunnable {
let runnable = ImgParseErrorRunnable {
img: Trusted::new(self),
src: src.into(),
});
};
let task = window.dom_manipulation_task_source();
let _ = task.queue(DOMManipulationTask(runnable));
let _ = task.queue(runnable, window);
}
}
}

6
components/script/dom/htmlinputelement.rs
View file

@ -576,7 +576,8 @@ impl HTMLInputElementMethods for HTMLInputElement {
&self.upcast(),
atom!("select"),
EventBubbles::Bubbles,
EventCancelable::NotCancelable);
EventCancelable::NotCancelable,
window.r());
self.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);
}
@ -1061,7 +1062,8 @@ impl VirtualMethods for HTMLInputElement {
&self.upcast(),
atom!("input"),
EventBubbles::Bubbles,
EventCancelable::NotCancelable);
EventCancelable::NotCancelable,
window.r());
}
self.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);

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

@ -33,7 +33,6 @@ use std::cell::Cell;
use std::sync::{Arc, Mutex};
use string_cache::Atom;
use task_source::TaskSource;
use task_source::dom_manipulation::DOMManipulationTask;
use time::{self, Timespec, Duration};
use url::Url;
@ -242,7 +241,7 @@ impl HTMLMediaElement {
elem: Trusted::new(self),
};
let win = window_from_node(self);
let _ = win.dom_manipulation_task_source().queue(DOMManipulationTask(box task));
let _ = win.dom_manipulation_task_source().queue(task, win.r());
}
// https://html.spec.whatwg.org/multipage/#internal-pause-steps step 2.2
@ -266,13 +265,13 @@ impl HTMLMediaElement {
elem: Trusted::new(self),
};
let win = window_from_node(self);
let _ = win.dom_manipulation_task_source().queue(DOMManipulationTask(box task));
let _ = win.dom_manipulation_task_source().queue(task, win.r());
}
fn queue_fire_simple_event(&self, type_: &'static str) {
let win = window_from_node(self);
let task = FireSimpleEventTask::new(self, type_);
let _ = win.dom_manipulation_task_source().queue(DOMManipulationTask(box task));
let _ = win.dom_manipulation_task_source().queue(task, win.r());
}
fn fire_simple_event(&self, type_: &str) {
@ -498,8 +497,8 @@ impl HTMLMediaElement {
}
fn queue_dedicated_media_source_failure_steps(&self) {
let _ = window_from_node(self).dom_manipulation_task_source().queue(
DOMManipulationTask(box DedicatedMediaSourceFailureTask::new(self)));
let window = window_from_node(self);
let _ = window.dom_manipulation_task_source().queue(DedicatedMediaSourceFailureTask::new(self), window.r());
}
// https://html.spec.whatwg.org/multipage/#dedicated-media-source-failure-steps

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

@ -460,12 +460,13 @@ impl HTMLScriptElement {
if external {
self.dispatch_load_event();
} else {
window.dom_manipulation_task_source().queue_simple_event(self.upcast(), atom!("load"));
window.dom_manipulation_task_source().queue_simple_event(self.upcast(), atom!("load"), window.r());
}
}
pub fn queue_error_event(&self) {
window_from_node(self).dom_manipulation_task_source().queue_simple_event(self.upcast(), atom!("error"));
let window = window_from_node(self);
window.dom_manipulation_task_source().queue_simple_event(self.upcast(), atom!("error"), window.r());
}
pub fn dispatch_before_script_execute_event(&self) -> bool {

6
components/script/dom/htmltextareaelement.rs
View file

@ -260,7 +260,8 @@ impl HTMLTextAreaElementMethods for HTMLTextAreaElement {
&self.upcast(),
atom!("select"),
EventBubbles::Bubbles,
EventCancelable::NotCancelable);
EventCancelable::NotCancelable,
window.r());
self.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);
}
}
@ -383,7 +384,8 @@ impl VirtualMethods for HTMLTextAreaElement {
&self.upcast(),
atom!("input"),
EventBubbles::Bubbles,
EventCancelable::NotCancelable);
EventCancelable::NotCancelable,
window.r());
}
self.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);

7
components/script/dom/storage.rs
View file

@ -19,7 +19,6 @@ use net_traits::IpcSend;
use net_traits::storage_thread::{StorageThreadMsg, StorageType};
use script_thread::{Runnable, ScriptThread};
use task_source::TaskSource;
use task_source::dom_manipulation::DOMManipulationTask;
use url::Url;
#[dom_struct]
@ -159,10 +158,10 @@ impl Storage {
new_value: Option<String>) {
let global_root = self.global();
let global_ref = global_root.r();
let task_source = global_ref.as_window().dom_manipulation_task_source();
let window = global_ref.as_window();
let task_source = window.dom_manipulation_task_source();
let trusted_storage = Trusted::new(self);
task_source.queue(DOMManipulationTask(
box StorageEventRunnable::new(trusted_storage, key, old_value, new_value))).unwrap();
task_source.queue(StorageEventRunnable::new(trusted_storage, key, old_value, new_value), window).unwrap();
}
}

15
components/script/network_listener.rs
View file

@ -23,16 +23,13 @@ impl<Listener: PreInvoke + Send + 'static> NetworkListener<Listener> {
context: self.context.clone(),
action: action,
};
if let Some(ref wrapper) = self.wrapper {
if let Err(err) = self.script_chan.send(
CommonScriptMsg::RunnableMsg(NetworkEvent, wrapper.wrap_runnable(runnable))) {
warn!("failed to deliver network data: {:?}", err);
}
let result = if let Some(ref wrapper) = self.wrapper {
self.script_chan.send(CommonScriptMsg::RunnableMsg(NetworkEvent, wrapper.wrap_runnable(runnable)))
} else {
if let Err(err) = self.script_chan.send(
CommonScriptMsg::RunnableMsg(NetworkEvent, box runnable)) {
warn!("failed to deliver network data: {:?}", err);
}
self.script_chan.send(CommonScriptMsg::RunnableMsg(NetworkEvent, box runnable))
};
if let Err(err) = result {
warn!("failed to deliver network data: {:?}", err);
}
}
}

10
components/script/script_thread.rs
View file

@ -189,10 +189,16 @@ pub struct CancellableRunnable<T: Runnable + Send> {
}
impl<T: Runnable + Send> Runnable for CancellableRunnable<T> {
fn name(&self) -> &'static str { self.inner.name() }
fn is_cancelled(&self) -> bool {
self.cancelled.load(Ordering::SeqCst)
}
fn main_thread_handler(self: Box<CancellableRunnable<T>>, script_thread: &ScriptThread) {
self.inner.main_thread_handler(script_thread);
}
fn handler(self: Box<CancellableRunnable<T>>) {
self.inner.handler()
}
@ -1220,8 +1226,8 @@ impl ScriptThread {
doc.mut_loader().inhibit_events();
// https://html.spec.whatwg.org/multipage/#the-end step 7
let handler = box DocumentProgressHandler::new(Trusted::new(doc));
self.dom_manipulation_task_source.queue(DOMManipulationTask(handler)).unwrap();
let handler = DocumentProgressHandler::new(Trusted::new(doc));
self.dom_manipulation_task_source.queue(handler, doc.window()).unwrap();
self.constellation_chan.send(ConstellationMsg::LoadComplete(pipeline)).unwrap();
}

19
components/script/task_source/dom_manipulation.rs
View file

@ -5,6 +5,7 @@
use dom::bindings::refcounted::Trusted;
use dom::event::{EventBubbles, EventCancelable, EventRunnable, SimpleEventRunnable};
use dom::eventtarget::EventTarget;
use dom::window::Window;
use script_thread::{MainThreadScriptMsg, Runnable, ScriptThread};
use std::result::Result;
use std::sync::mpsc::Sender;
@ -14,8 +15,9 @@ use task_source::TaskSource;
#[derive(JSTraceable, Clone)]
pub struct DOMManipulationTaskSource(pub Sender<MainThreadScriptMsg>);
impl TaskSource<DOMManipulationTask> for DOMManipulationTaskSource {
fn queue(&self, msg: DOMManipulationTask) -> Result<(), ()> {
impl TaskSource for DOMManipulationTaskSource {
fn queue<T: Runnable + Send + 'static>(&self, msg: T, window: &Window) -> Result<(), ()> {
let msg = DOMManipulationTask(window.get_runnable_wrapper().wrap_runnable(msg));
self.0.send(MainThreadScriptMsg::DOMManipulation(msg)).map_err(|_| ())
}
}
@ -25,24 +27,25 @@ impl DOMManipulationTaskSource {
target: &EventTarget,
name: Atom,
bubbles: EventBubbles,
cancelable: EventCancelable) {
cancelable: EventCancelable,
window: &Window) {
let target = Trusted::new(target);
let runnable = box EventRunnable {
let runnable = EventRunnable {
target: target,
name: name,
bubbles: bubbles,
cancelable: cancelable,
};
let _ = self.queue(DOMManipulationTask(runnable));
let _ = self.queue(runnable, window);
}
pub fn queue_simple_event(&self, target: &EventTarget, name: Atom) {
pub fn queue_simple_event(&self, target: &EventTarget, name: Atom, window: &Window) {
let target = Trusted::new(target);
let runnable = box SimpleEventRunnable {
let runnable = SimpleEventRunnable {
target: target,
name: name,
};
let _ = self.queue(DOMManipulationTask(runnable));
let _ = self.queue(runnable, window);
}
}

6
components/script/task_source/mod.rs
View file

@ -8,8 +8,10 @@ pub mod history_traversal;
pub mod networking;
pub mod user_interaction;
use dom::window::Window;
use script_thread::Runnable;
use std::result::Result;
pub trait TaskSource<T> {
fn queue(&self, msg: T) -> Result<(), ()>;
pub trait TaskSource {
fn queue<T: Runnable + Send + 'static>(&self, msg: T, window: &Window) -> Result<(), ()>;
}

13
components/script/task_source/user_interaction.rs
View file

@ -5,6 +5,7 @@
use dom::bindings::refcounted::Trusted;
use dom::event::{EventBubbles, EventCancelable, EventRunnable};
use dom::eventtarget::EventTarget;
use dom::window::Window;
use script_thread::{MainThreadScriptMsg, Runnable, ScriptThread};
use std::result::Result;
use std::sync::mpsc::Sender;
@ -14,8 +15,9 @@ use task_source::TaskSource;
#[derive(JSTraceable, Clone)]
pub struct UserInteractionTaskSource(pub Sender<MainThreadScriptMsg>);
impl TaskSource<UserInteractionTask> for UserInteractionTaskSource {
fn queue(&self, msg: UserInteractionTask) -> Result<(), ()> {
impl TaskSource for UserInteractionTaskSource {
fn queue<T: Runnable + Send + 'static>(&self, msg: T, window: &Window) -> Result<(), ()> {
let msg = UserInteractionTask(window.get_runnable_wrapper().wrap_runnable(msg));
self.0.send(MainThreadScriptMsg::UserInteraction(msg)).map_err(|_| ())
}
}
@ -25,15 +27,16 @@ impl UserInteractionTaskSource {
target: &EventTarget,
name: Atom,
bubbles: EventBubbles,
cancelable: EventCancelable) {
cancelable: EventCancelable,
window: &Window) {
let target = Trusted::new(target);
let runnable = box EventRunnable {
let runnable = EventRunnable {
target: target,
name: name,
bubbles: bubbles,
cancelable: cancelable,
};
let _ = self.queue(UserInteractionTask(runnable));
let _ = self.queue(runnable, window);
}
}