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

Rename Root<T> to DomRoot<T>

Browse source 
In a later PR, DomRoot<T> will become a type alias of Root<Dom<T>>,
where Root<T> will be able to handle all the things that need to be
rooted that have a stable traceable address that doesn't move for the
whole lifetime of the root. Stay tuned.
This commit is contained in:
Anthony Ramine 2017-09-26 01:53:40 +02:00
parent 577370746e
commit f87c2a8d76
291 changed files with 1774 additions and 1770 deletions
Download patch file Download diff file Expand all files Collapse all files

12
components/script/dom/servoparser/async_html.rs
View file

@ -7,7 +7,7 @@
use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods;
use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
use dom::bindings::inheritance::Castable;
use dom::bindings::root::{Dom, Root};
use dom::bindings::root::{Dom, DomRoot};
use dom::bindings::str::DOMString;
use dom::comment::Comment;
use dom::document::Document;
@ -230,7 +230,7 @@ impl Tokenizer {
tokenizer
}
pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), Root<HTMLScriptElement>> {
pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), DomRoot<HTMLScriptElement>> {
let mut send_tendrils = VecDeque::new();
while let Some(str) = input.pop_front() {
send_tendrils.push_back(SendTendril::from(str));
@ -252,7 +252,7 @@ impl Tokenizer {
let buffer_queue = create_buffer_queue(updated_input);
*input = buffer_queue;
let script = self.get_node(&script.id);
return Err(Root::from_ref(script.downcast().unwrap()));
return Err(DomRoot::from_ref(script.downcast().unwrap()));
}
ToTokenizerMsg::End => unreachable!(),
};
@ -326,11 +326,11 @@ impl Tokenizer {
}
fn process_operation(&mut self, op: ParseOperation) {
let document = Root::from_ref(&**self.get_node(&0));
let document = DomRoot::from_ref(&**self.get_node(&0));
let document = document.downcast::<Document>().expect("Document node should be downcasted!");
match op {
ParseOperation::GetTemplateContents { target, contents } => {
let target = Root::from_ref(&**self.get_node(&target));
let target = DomRoot::from_ref(&**self.get_node(&target));
let template = target.downcast::<HTMLTemplateElement>().expect(
"Tried to extract contents from non-template element while parsing");
self.insert_node(contents, Dom::from_ref(template.Content().upcast()));
@ -407,7 +407,7 @@ impl Tokenizer {
return;
}
let form = self.get_node(&form);
let form = Root::downcast::<HTMLFormElement>(Root::from_ref(&**form))
let form = DomRoot::downcast::<HTMLFormElement>(DomRoot::from_ref(&**form))
.expect("Owner must be a form element");
let node = self.get_node(&target);

18
components/script/dom/servoparser/html.rs
View file

@ -6,7 +6,7 @@
use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods;
use dom::bindings::inheritance::{Castable, CharacterDataTypeId, NodeTypeId};
use dom::bindings::root::{Dom, Root};
use dom::bindings::root::{Dom, DomRoot};
use dom::bindings::trace::JSTraceable;
use dom::characterdata::CharacterData;
use dom::document::Document;
@ -75,10 +75,10 @@ impl Tokenizer {
}
}
pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), Root<HTMLScriptElement>> {
pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), DomRoot<HTMLScriptElement>> {
match self.inner.feed(input) {
TokenizerResult::Done => Ok(()),
TokenizerResult::Script(script) => Err(Root::from_ref(script.downcast().unwrap())),
TokenizerResult::Script(script) => Err(DomRoot::from_ref(script.downcast().unwrap())),
}
}
@ -140,16 +140,16 @@ fn end_element<S: Serializer>(node: &Element, serializer: &mut S) -> io::Result<
enum SerializationCommand {
OpenElement(Root<Element>),
CloseElement(Root<Element>),
SerializeNonelement(Root<Node>),
OpenElement(DomRoot<Element>),
CloseElement(DomRoot<Element>),
SerializeNonelement(DomRoot<Node>),
}
struct SerializationIterator {
stack: Vec<SerializationCommand>,
}
fn rev_children_iter(n: &Node) -> impl Iterator<Item=Root<Node>>{
fn rev_children_iter(n: &Node) -> impl Iterator<Item=DomRoot<Node>>{
match n.downcast::<HTMLTemplateElement>() {
Some(t) => t.Content().upcast::<Node>().rev_children(),
None => n.rev_children(),
@ -173,8 +173,8 @@ impl SerializationIterator {
fn push_node(&mut self, n: &Node) {
match n.downcast::<Element>() {
Some(e) => self.stack.push(SerializationCommand::OpenElement(Root::from_ref(e))),
None => self.stack.push(SerializationCommand::SerializeNonelement(Root::from_ref(n))),
Some(e) => self.stack.push(SerializationCommand::OpenElement(DomRoot::from_ref(e))),
None => self.stack.push(SerializationCommand::SerializeNonelement(DomRoot::from_ref(n))),
}
}
}

28
components/script/dom/servoparser/mod.rs
View file

@ -12,7 +12,7 @@ use dom::bindings::codegen::Bindings::ServoParserBinding;
use dom::bindings::inheritance::Castable;
use dom::bindings::refcounted::Trusted;
use dom::bindings::reflector::{Reflector, reflect_dom_object};
use dom::bindings::root::{Dom, MutNullableDom, Root, RootedReference};
use dom::bindings::root::{Dom, DomRoot, MutNullableDom, RootedReference};
use dom::bindings::str::DOMString;
use dom::characterdata::CharacterData;
use dom::comment::Comment;
@ -119,7 +119,7 @@ impl ServoParser {
}
// https://html.spec.whatwg.org/multipage/#parsing-html-fragments
pub fn parse_html_fragment(context: &Element, input: DOMString) -> impl Iterator<Item=Root<Node>> {
pub fn parse_html_fragment(context: &Element, input: DOMString) -> impl Iterator<Item=DomRoot<Node>> {
let context_node = context.upcast::<Node>();
let context_document = context_node.owner_doc();
let window = context_document.window();
@ -337,7 +337,7 @@ impl ServoParser {
tokenizer: Tokenizer,
last_chunk_state: LastChunkState,
kind: ParserKind)
-> Root<Self> {
-> DomRoot<Self> {
reflect_dom_object(box ServoParser::new_inherited(document, tokenizer, last_chunk_state, kind),
document.window(),
ServoParserBinding::Wrap)
@ -422,7 +422,7 @@ impl ServoParser {
}
fn tokenize<F>(&self, mut feed: F)
where F: FnMut(&mut Tokenizer) -> Result<(), Root<HTMLScriptElement>>,
where F: FnMut(&mut Tokenizer) -> Result<(), DomRoot<HTMLScriptElement>>,
{
loop {
assert!(!self.suspended.get());
@ -469,17 +469,17 @@ impl ServoParser {
}
struct FragmentParsingResult<I>
where I: Iterator<Item=Root<Node>>
where I: Iterator<Item=DomRoot<Node>>
{
inner: I,
}
impl<I> Iterator for FragmentParsingResult<I>
where I: Iterator<Item=Root<Node>>
where I: Iterator<Item=DomRoot<Node>>
{
type Item = Root<Node>;
type Item = DomRoot<Node>;
fn next(&mut self) -> Option<Root<Node>> {
fn next(&mut self) -> Option<DomRoot<Node>> {
let next = match self.inner.next() {
Some(next) => next,
None => return None,
@ -508,7 +508,7 @@ enum Tokenizer {
}
impl Tokenizer {
fn feed(&mut self, input: &mut BufferQueue) -> Result<(), Root<HTMLScriptElement>> {
fn feed(&mut self, input: &mut BufferQueue) -> Result<(), DomRoot<HTMLScriptElement>> {
match *self {
Tokenizer::Html(ref mut tokenizer) => tokenizer.feed(input),
Tokenizer::AsyncHtml(ref mut tokenizer) => tokenizer.feed(input),
@ -624,10 +624,10 @@ impl FetchResponseListener for ParserContext {
parser.parse_sync();
let doc = &parser.document;
let doc_body = Root::upcast::<Node>(doc.GetBody().unwrap());
let doc_body = DomRoot::upcast::<Node>(doc.GetBody().unwrap());
let img = HTMLImageElement::new(local_name!("img"), None, doc);
img.SetSrc(DOMString::from(self.url.to_string()));
doc_body.AppendChild(&Root::upcast::<Node>(img)).expect("Appending failed");
doc_body.AppendChild(&DomRoot::upcast::<Node>(img)).expect("Appending failed");
},
Some(ContentType(Mime(TopLevel::Text, SubLevel::Plain, _))) => {
@ -730,7 +730,7 @@ fn insert(parent: &Node, reference_child: Option<&Node>, child: NodeOrText<Dom<N
let text = reference_child
.and_then(Node::GetPreviousSibling)
.or_else(|| parent.GetLastChild())
.and_then(Root::downcast::<Text>);
.and_then(DomRoot::downcast::<Text>);
if let Some(text) = text {
text.upcast::<CharacterData>().append_data(&t);
@ -834,7 +834,7 @@ impl TreeSink for Sink {
}
let node = target;
let form = Root::downcast::<HTMLFormElement>(Root::from_ref(&**form))
let form = DomRoot::downcast::<HTMLFormElement>(DomRoot::from_ref(&**form))
.expect("Owner must be a form element");
let elem = node.downcast::<Element>();
@ -945,7 +945,7 @@ impl TreeSink for Sink {
}
fn pop(&mut self, node: &Dom<Node>) {
let node = Root::from_ref(&**node);
let node = DomRoot::from_ref(&**node);
vtable_for(&node).pop();
}
}

4
components/script/dom/servoparser/xml.rs
View file

@ -4,7 +4,7 @@
#![allow(unrooted_must_root)]
use dom::bindings::root::{Dom, Root};
use dom::bindings::root::{Dom, DomRoot};
use dom::bindings::trace::JSTraceable;
use dom::document::Document;
use dom::htmlscriptelement::HTMLScriptElement;
@ -40,7 +40,7 @@ impl Tokenizer {
}
}
pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), Root<HTMLScriptElement>> {
pub fn feed(&mut self, input: &mut BufferQueue) -> Result<(), DomRoot<HTMLScriptElement>> {
if !input.is_empty() {
while let Some(chunk) = input.pop_front() {
self.inner.feed(chunk);