diff --git a/src/servo/content/content_task.rs b/src/servo/content/content_task.rs index 84f9da7be04..6585aef70c8 100644 --- a/src/servo/content/content_task.rs +++ b/src/servo/content/content_task.rs @@ -2,31 +2,31 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -/*! -The content task is the main task that runs JavaScript and spawns layout -tasks. -*/ +/// The content task (also called the script task) is the main task that owns the DOM in memory, +/// runs JavaScript, and spawns parsing and layout tasks. use dom::bindings::utils::GlobalStaticData; use dom::document::Document; -use dom::node::define_bindings; use dom::event::{Event, ResizeEvent, ReflowEvent}; +use dom::node::define_bindings; use dom::window::Window; -use layout::layout_task; use layout::layout_task::{AddStylesheet, BuildData, BuildMsg, Damage, LayoutTask}; use layout::layout_task::{MatchSelectorsDamage, NoDamage, ReflowDamage}; +use layout::layout_task; use core::cell::Cell; use core::comm::{Port, SharedChan}; -use core::pipes::select2i; use core::either; -use core::task::{SingleThreaded, task}; use core::io::{println, read_whole_file}; +use core::pipes::select2i; use core::ptr::null; +use core::task::{SingleThreaded, task}; use core::util::replace; +use dom; use geom::size::Size2D; use gfx::resource::image_cache_task::ImageCacheTask; use gfx::resource::resource_task::ResourceTask; +use html; use js::JSVAL_NULL; use js::global::{global_class, debug_fns}; use js::glue::bindgen::RUST_JSVAL_TO_OBJECT; @@ -34,10 +34,9 @@ use js::jsapi::JSContext; use js::jsapi::bindgen::{JS_CallFunctionValue, JS_GetContextPrivate}; use js::rust::{Compartment, Cx}; use jsrt = js::rust::rt; +use servo_util::tree::TreeNodeRef; use std::net::url::Url; use url_to_str = std::net::url::to_str; -use dom; -use html; pub enum ControlMsg { ParseMsg(Url), @@ -232,7 +231,7 @@ pub impl Content { ptr::to_mut_unsafe_ptr(&mut *self)); //FIXME store this safely let document = Document(root, Some(window)); - do root.with_mut_node |node| { + do root.with_mutable_node |node| { node.add_to_doc(document); } @@ -312,24 +311,20 @@ pub impl Content { } } - /** - This method will wait until the layout task has completed its current action, - join the layout task, and then request a new layout run. It won't wait for the - new layout computation to finish. - */ + /// This method will wait until the layout task has completed its current action, join the + /// layout task, and then request a new layout run. It won't wait for the new layout + /// computation to finish. fn relayout(&mut self, document: &Document, doc_url: &Url) { debug!("content: performing relayout"); - // Now, join the layout so that they will see the latest - // changes we have made. + // Now, join the layout so that they will see the latest changes we have made. self.join_layout(); - // Layout will let us know when it's done + // Layout will let us know when it's done. let (join_port, join_chan) = comm::stream(); self.layout_join_port = Some(join_port); - // Send new document and relevant styles to layout - + // Send new document and relevant styles to layout. let data = ~BuildData { node: document.root, url: copy *doc_url, @@ -344,7 +339,8 @@ pub impl Content { debug!("content: layout forked"); } - fn query_layout(&mut self, query: layout_task::LayoutQuery) -> layout_task::LayoutQueryResponse { + fn query_layout(&mut self, query: layout_task::LayoutQuery) + -> layout_task::LayoutQueryResponse { //self.relayout(self.document.get(), &(copy self.doc_url).get()); self.join_layout(); @@ -378,7 +374,7 @@ pub impl Content { ReflowEvent => { debug!("content got reflow event"); self.damage.add(MatchSelectorsDamage); - match copy self.document { + match /*bad*/ copy self.document { None => { // Nothing to do. } diff --git a/src/servo/dom/bindings/node.rs b/src/servo/dom/bindings/node.rs index d0228b05445..1ad90162c22 100644 --- a/src/servo/dom/bindings/node.rs +++ b/src/servo/dom/bindings/node.rs @@ -18,6 +18,7 @@ use js::jsval::{INT_TO_JSVAL}; use js::rust::{Compartment, jsobj}; use js::{JSPROP_ENUMERATE, JSPROP_SHARED, JSVAL_NULL}; use js::{JS_THIS_OBJECT, JSPROP_NATIVE_ACCESSORS}; +use servo_util::tree::TreeNodeRef; pub fn init(compartment: @mut Compartment) { let obj = utils::define_empty_prototype(~"Node", None, compartment); @@ -80,7 +81,7 @@ extern fn getFirstChild(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool } let node = unwrap(obj); - let rval = do node.with_mut_node |node| { + let rval = do node.with_mutable_node |node| { node.getFirstChild() }; match rval { @@ -102,7 +103,7 @@ extern fn getNextSibling(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBoo } let node = unwrap(obj); - let rval = do node.with_mut_node |node| { + let rval = do node.with_mutable_node |node| { node.getNextSibling() }; match rval { @@ -127,19 +128,19 @@ impl Node { fn getNextSibling(&mut self) -> Option<&mut AbstractNode> { match self.next_sibling { - // transmute because the compiler can't deduce that the reference - // is safe outside of with_mut_node blocks. - Some(ref mut n) => Some(unsafe { cast::transmute(n) }), - None => None + // transmute because the compiler can't deduce that the reference + // is safe outside of with_mutable_node blocks. + Some(ref mut n) => Some(unsafe { cast::transmute(n) }), + None => None } } fn getFirstChild(&mut self) -> Option<&mut AbstractNode> { match self.first_child { - // transmute because the compiler can't deduce that the reference - // is safe outside of with_mut_node blocks. - Some(ref mut n) => Some(unsafe { cast::transmute(n) }), - None => None + // transmute because the compiler can't deduce that the reference + // is safe outside of with_mutable_node blocks. + Some(ref mut n) => Some(unsafe { cast::transmute(n) }), + None => None } } } @@ -152,7 +153,7 @@ extern fn getNodeType(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool { } let node = unwrap(obj); - let rval = do node.with_imm_node |node| { + let rval = do node.with_immutable_node |node| { node.getNodeType() }; *vp = INT_TO_JSVAL(rval); @@ -162,8 +163,10 @@ extern fn getNodeType(cx: *JSContext, _argc: c_uint, vp: *mut JSVal) -> JSBool { impl CacheableWrapper for AbstractNode { fn get_wrappercache(&mut self) -> &mut WrapperCache { - do self.with_mut_node |n| { - unsafe { cast::transmute(&n.wrapper) } + do self.with_mutable_node |node| { + unsafe { + cast::transmute(&node.wrapper) + } } } diff --git a/src/servo/dom/document.rs b/src/servo/dom/document.rs index fc841534718..99150968d4c 100644 --- a/src/servo/dom/document.rs +++ b/src/servo/dom/document.rs @@ -11,7 +11,7 @@ use dom::node::AbstractNode; use dom::window::Window; use js::jsapi::bindgen::{JS_AddObjectRoot, JS_RemoveObjectRoot}; -use servo_util::tree::TreeUtils; +use servo_util::tree::{TreeNodeRef, TreeUtils}; pub struct Document { root: AbstractNode, @@ -27,7 +27,7 @@ pub fn Document(root: AbstractNode, window: window }; let compartment = global_content().compartment.get(); - do root.with_imm_node |node| { + do root.with_immutable_node |node| { assert!(node.wrapper.get_wrapper().is_not_null()); let rootable = node.wrapper.get_rootable(); JS_AddObjectRoot(compartment.cx.ptr, rootable); @@ -40,7 +40,7 @@ pub fn Document(root: AbstractNode, impl Drop for Document { fn finalize(&self) { let compartment = global_content().compartment.get(); - do self.root.with_imm_node |node| { + do self.root.with_immutable_node |node| { assert!(node.wrapper.get_wrapper().is_not_null()); let rootable = node.wrapper.get_rootable(); JS_RemoveObjectRoot(compartment.cx.ptr, rootable); diff --git a/src/servo/dom/node.rs b/src/servo/dom/node.rs index 5b97149aa1d..22ed52d49f2 100644 --- a/src/servo/dom/node.rs +++ b/src/servo/dom/node.rs @@ -205,13 +205,13 @@ impl TreeNode for Node { } impl TreeNodeRef for AbstractNode { - // FIXME: The duplication between `with_imm_node` and `with_immutable_node` is ugly. + // FIXME: The duplication between `with_immutable_node` and `with_immutable_node` is ugly. fn with_immutable_node(&self, callback: &fn(&Node) -> R) -> R { - self.with_imm_node(callback) + self.transmute(callback) } fn with_mutable_node(&self, callback: &fn(&mut Node) -> R) -> R { - self.with_mut_node(callback) + self.transmute_mut(callback) } } @@ -220,44 +220,44 @@ impl AbstractNode { /// Returns the type ID of this node. Fails if this node is borrowed mutably. pub fn type_id(self) -> NodeTypeId { - self.with_imm_node(|n| n.type_id) + self.with_immutable_node(|n| n.type_id) } /// Returns the parent node of this node. Fails if this node is borrowed mutably. pub fn parent_node(self) -> Option { - self.with_imm_node(|n| n.parent_node) + self.with_immutable_node(|n| n.parent_node) } /// Returns the first child of this node. Fails if this node is borrowed mutably. pub fn first_child(self) -> Option { - self.with_imm_node(|n| n.first_child) + self.with_immutable_node(|n| n.first_child) } /// Returns the last child of this node. Fails if this node is borrowed mutably. pub fn last_child(self) -> Option { - self.with_imm_node(|n| n.last_child) + self.with_immutable_node(|n| n.last_child) } /// Returns the previous sibling of this node. Fails if this node is borrowed mutably. pub fn prev_sibling(self) -> Option { - self.with_imm_node(|n| n.prev_sibling) + self.with_immutable_node(|n| n.prev_sibling) } /// Returns the next sibling of this node. Fails if this node is borrowed mutably. pub fn next_sibling(self) -> Option { - self.with_imm_node(|n| n.next_sibling) + self.with_immutable_node(|n| n.next_sibling) } // NB: You must not call these if you are not layout. We should do something with scoping to // ensure this. pub fn layout_data(self) -> @mut LayoutData { - self.with_imm_node(|n| n.layout_data.get()) + self.with_immutable_node(|n| n.layout_data.get()) } pub fn has_layout_data(self) -> bool { - self.with_imm_node(|n| n.layout_data.is_some()) + self.with_immutable_node(|n| n.layout_data.is_some()) } pub fn set_layout_data(self, data: @mut LayoutData) { - self.with_mut_node(|n| n.layout_data = Some(data)) + self.with_mutable_node(|n| n.layout_data = Some(data)) } // @@ -290,14 +290,6 @@ impl AbstractNode { } } - pub fn with_imm_node(self, f: &fn(&Node) -> R) -> R { - self.transmute(f) - } - - pub fn with_mut_node(self, f: &fn(&mut Node) -> R) -> R { - self.transmute_mut(f) - } - pub fn is_text(self) -> bool { self.type_id() == TextNodeTypeId } @@ -408,12 +400,11 @@ impl Node { self.owner_doc = Some(doc); let mut node = self.first_child; while node.is_some() { - node.get().traverse_preorder(|n| { - do n.with_mut_node |n| { - n.owner_doc = Some(doc); + for node.get().traverse_preorder |node| { + do node.with_mutable_node |node_data| { + node_data.owner_doc = Some(doc); } - true - }); + }; node = node.get().next_sibling(); } }