Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-23 07:13:52 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update to string-cache 0.3

Browse source
This commit is contained in:
Simon Sapin 2016-10-30 19:27:43 +01:00
parent 9fcc9d9d3f
commit 53b638c0e2
170 changed files with 1309 additions and 1050 deletions
Download patch file Download diff file Expand all files Collapse all files

16
components/atoms/Cargo.toml Normal file
View file

@ -0,0 +1,16 @@
[package]
name = "servo_atoms"
version = "0.0.1"
authors = ["The Servo Project Developers"]
license = "MPL-2.0"
publish = false
build = "build.rs"
[lib]
path = "lib.rs"
[dependencies]
string_cache = {version = "0.3", features = ["heap_size"]}
[build-dependencies]
string_cache_codegen = "0.3"

19
components/atoms/build.rs Normal file
View file

@ -0,0 +1,19 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* 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/. */
extern crate string_cache_codegen;
use std::env;
use std::fs::File;
use std::io::{BufReader, BufRead};
use std::path::Path;
fn main() {
let static_atoms = Path::new(&env::var("CARGO_MANIFEST_DIR").unwrap()).join("static_atoms.txt");
let static_atoms = BufReader::new(File::open(&static_atoms).unwrap());
string_cache_codegen::AtomType::new("Atom", "atom!")
.atoms(static_atoms.lines().map(Result::unwrap))
.write_to_file(&Path::new(&env::var("OUT_DIR").unwrap()).join("atom.rs"))
.unwrap();
}

7
components/atoms/lib.rs Normal file
View file

@ -0,0 +1,7 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* 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/. */
extern crate string_cache;
include!(concat!(env!("OUT_DIR"), "/atom.rs"));

73
components/atoms/static_atoms.txt Normal file
View file

@ -0,0 +1,73 @@
serif
sans-serif
cursive
fantasy
monospace
left
center
right
hidden
submit
button
reset
radio
checkbox
file
image
password
text
search
url
tel
email
datetime
date
month
week
time
datetime-local
number
dir
bottom
top
left
right
width
height
margin-bottom
margin-top
margin-left
margin-right
padding-bottom
padding-top
padding-left
padding-right
DOMContentLoaded
select
input
load
loadstart
loadend
progress
transitionend
error
readystatechange
message
close
storage
activate
webglcontextcreationerror
mouseover
beforeunload
message
click
keydown
abort
beforescriptexecute
afterscriptexecute

2
components/gfx/Cargo.toml
View file

@ -32,9 +32,9 @@ plugins = {path = "../plugins"}
range = {path = "../range"} range = {path = "../range"}
rustc-serialize = "0.3" rustc-serialize = "0.3"
serde = "0.8" serde = "0.8"
servo_atoms = {path = "../atoms"}
serde_derive = "0.8" serde_derive = "0.8"
smallvec = "0.1" smallvec = "0.1"
string_cache = {version = "0.2.26", features = ["heap_size"]}
style = {path = "../style"} style = {path = "../style"}
style_traits = {path = "../style_traits"} style_traits = {path = "../style_traits"}
time = "0.1.12" time = "0.1.12"

2
components/gfx/font_cache_thread.rs
View file

@ -14,13 +14,13 @@ use platform::font_list::for_each_variation;
use platform::font_list::last_resort_font_families; use platform::font_list::last_resort_font_families;
use platform::font_list::system_default_family; use platform::font_list::system_default_family;
use platform::font_template::FontTemplateData; use platform::font_template::FontTemplateData;
use servo_atoms::Atom;
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::collections::HashMap; use std::collections::HashMap;
use std::mem; use std::mem;
use std::ops::Deref; use std::ops::Deref;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use std::u32; use std::u32;
use string_cache::Atom;
use style::font_face::{EffectiveSources, Source}; use style::font_face::{EffectiveSources, Source};
use style::properties::longhands::font_family::computed_value::FontFamily; use style::properties::longhands::font_family::computed_value::FontFamily;
use url::Url; use url::Url;

2
components/gfx/font_template.rs
View file

@ -6,11 +6,11 @@ use font::FontHandleMethods;
use platform::font::FontHandle; use platform::font::FontHandle;
use platform::font_context::FontContextHandle; use platform::font_context::FontContextHandle;
use platform::font_template::FontTemplateData; use platform::font_template::FontTemplateData;
use servo_atoms::Atom;
use std::fmt::{Debug, Error, Formatter}; use std::fmt::{Debug, Error, Formatter};
use std::io::Error as IoError; use std::io::Error as IoError;
use std::sync::{Arc, Weak}; use std::sync::{Arc, Weak};
use std::u32; use std::u32;
use string_cache::Atom;
use style::computed_values::{font_stretch, font_weight}; use style::computed_values::{font_stretch, font_weight};
/// Describes how to select a font from a given family. This is very basic at the moment and needs /// Describes how to select a font from a given family. This is very basic at the moment and needs

3
components/gfx/lib.rs
View file

@ -71,9 +71,8 @@ extern crate serde_derive;
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
extern crate simd; extern crate simd;
#[macro_use] extern crate servo_atoms;
extern crate smallvec; extern crate smallvec;
#[macro_use]
extern crate string_cache;
extern crate style; extern crate style;
extern crate style_traits; extern crate style_traits;
extern crate time; extern crate time;

2
components/gfx/platform/dummy/font_template.rs
View file

@ -2,8 +2,8 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use servo_atoms::Atom;
use std::io::Error; use std::io::Error;
use string_cache::Atom;
use webrender_traits::NativeFontHandle; use webrender_traits::NativeFontHandle;
#[derive(Deserialize, Serialize, Debug)] #[derive(Deserialize, Serialize, Debug)]

2
components/gfx/platform/freetype/font_template.rs
View file

@ -2,9 +2,9 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use servo_atoms::Atom;
use std::fs::File; use std::fs::File;
use std::io::{Read, Error}; use std::io::{Read, Error};
use string_cache::Atom;
use webrender_traits::NativeFontHandle; use webrender_traits::NativeFontHandle;
/// Platform specific font representation for Linux. /// Platform specific font representation for Linux.

2
components/gfx/platform/macos/font_template.rs
View file

@ -9,13 +9,13 @@ use core_text;
use core_text::font::CTFont; use core_text::font::CTFont;
use serde::{Deserialize, Deserializer, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde::de::{Error, Visitor}; use serde::de::{Error, Visitor};
use servo_atoms::Atom;
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::collections::HashMap; use std::collections::HashMap;
use std::fs::File; use std::fs::File;
use std::io::{Read, Error as IoError}; use std::io::{Read, Error as IoError};
use std::ops::Deref; use std::ops::Deref;
use std::sync::Mutex; use std::sync::Mutex;
use string_cache::Atom;
use url::Url; use url::Url;
/// Platform specific font representation for mac. /// Platform specific font representation for mac.

2
components/gfx/platform/windows/font_template.rs
View file

@ -3,11 +3,11 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use gdi32; use gdi32;
use servo_atoms::Atom;
use std::ffi::OsString; use std::ffi::OsString;
use std::io::Error; use std::io::Error;
use std::os::windows::ffi::OsStrExt; use std::os::windows::ffi::OsStrExt;
use std::ptr; use std::ptr;
use string_cache::Atom;
use webrender_traits::NativeFontHandle; use webrender_traits::NativeFontHandle;
use winapi::{DWORD, LF_FACESIZE, LOGFONTW, OUT_TT_ONLY_PRECIS, WCHAR}; use winapi::{DWORD, LF_FACESIZE, LOGFONTW, OUT_TT_ONLY_PRECIS, WCHAR};

3
components/layout/Cargo.toml
View file

@ -21,6 +21,7 @@ gfx = {path = "../gfx"}
gfx_traits = {path = "../gfx_traits"} gfx_traits = {path = "../gfx_traits"}
heapsize = "0.3.0" heapsize = "0.3.0"
heapsize_derive = "0.1" heapsize_derive = "0.1"
html5ever-atoms = "0.1"
ipc-channel = "0.5" ipc-channel = "0.5"
libc = "0.2" libc = "0.2"
log = "0.3.5" log = "0.3.5"
@ -36,8 +37,8 @@ script_layout_interface = {path = "../script_layout_interface"}
script_traits = {path = "../script_traits"} script_traits = {path = "../script_traits"}
selectors = "0.14" selectors = "0.14"
serde_derive = "0.8" serde_derive = "0.8"
servo_atoms = {path = "../atoms"}
smallvec = "0.1" smallvec = "0.1"
string_cache = {version = "0.2.26", features = ["heap_size"]}
style = {path = "../style"} style = {path = "../style"}
style_traits = {path = "../style_traits"} style_traits = {path = "../style_traits"}
unicode-bidi = "0.2" unicode-bidi = "0.2"

10
components/layout/construct.rs
View file

@ -1660,7 +1660,10 @@ trait ObjectElement {
impl<N> ObjectElement for N where N: ThreadSafeLayoutNode { impl<N> ObjectElement for N where N: ThreadSafeLayoutNode {
fn has_object_data(&self) -> bool { fn has_object_data(&self) -> bool {
let elem = self.as_element().unwrap(); let elem = self.as_element().unwrap();
let type_and_data = (elem.get_attr(&ns!(), &atom!("type")), elem.get_attr(&ns!(), &atom!("data"))); let type_and_data = (
elem.get_attr(&ns!(), &local_name!("type")),
elem.get_attr(&ns!(), &local_name!("data")),
);
match type_and_data { match type_and_data {
(None, Some(uri)) => is_image_data(uri), (None, Some(uri)) => is_image_data(uri),
_ => false _ => false
@ -1669,7 +1672,10 @@ impl<N> ObjectElement for N where N: ThreadSafeLayoutNode {
fn object_data(&self) -> Option<Url> { fn object_data(&self) -> Option<Url> {
let elem = self.as_element().unwrap(); let elem = self.as_element().unwrap();
let type_and_data = (elem.get_attr(&ns!(), &atom!("type")), elem.get_attr(&ns!(), &atom!("data"))); let type_and_data = (
elem.get_attr(&ns!(), &local_name!("type")),
elem.get_attr(&ns!(), &local_name!("data")),
);
match type_and_data { match type_and_data {
(None, Some(uri)) if is_image_data(uri) => Url::parse(uri).ok(), (None, Some(uri)) if is_image_data(uri) => Url::parse(uri).ok(),
_ => None _ => None

2
components/layout/fragment.rs
View file

@ -886,7 +886,7 @@ impl TableColumnFragmentInfo {
/// Create the information specific to an table column fragment. /// Create the information specific to an table column fragment.
pub fn new<N: ThreadSafeLayoutNode>(node: &N) -> TableColumnFragmentInfo { pub fn new<N: ThreadSafeLayoutNode>(node: &N) -> TableColumnFragmentInfo {
let element = node.as_element().unwrap(); let element = node.as_element().unwrap();
let span = element.get_attr(&ns!(), &atom!("span")) let span = element.get_attr(&ns!(), &local_name!("span"))
.and_then(|string| string.parse().ok()) .and_then(|string| string.parse().ok())
.unwrap_or(0); .unwrap_or(0);
TableColumnFragmentInfo { TableColumnFragmentInfo {

3
components/layout/lib.rs
View file

@ -29,6 +29,7 @@ extern crate gfx;
extern crate gfx_traits; extern crate gfx_traits;
extern crate heapsize; extern crate heapsize;
#[macro_use] extern crate heapsize_derive; #[macro_use] extern crate heapsize_derive;
#[macro_use] extern crate html5ever_atoms;
extern crate ipc_channel; extern crate ipc_channel;
extern crate libc; extern crate libc;
#[macro_use] #[macro_use]
@ -47,8 +48,8 @@ extern crate range;
extern crate rustc_serialize; extern crate rustc_serialize;
extern crate script_layout_interface; extern crate script_layout_interface;
extern crate script_traits; extern crate script_traits;
#[macro_use] extern crate servo_atoms;
extern crate smallvec; extern crate smallvec;
#[macro_use(atom, ns)] extern crate string_cache;
extern crate style; extern crate style;
extern crate style_traits; extern crate style_traits;
extern crate unicode_bidi; extern crate unicode_bidi;

2
components/layout/query.rs
View file

@ -23,10 +23,10 @@ use script_layout_interface::wrapper_traits::{LayoutNode, ThreadSafeLayoutElemen
use script_traits::LayoutMsg as ConstellationMsg; use script_traits::LayoutMsg as ConstellationMsg;
use script_traits::UntrustedNodeAddress; use script_traits::UntrustedNodeAddress;
use sequential; use sequential;
use servo_atoms::Atom;
use std::cmp::{min, max}; use std::cmp::{min, max};
use std::ops::Deref; use std::ops::Deref;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use string_cache::Atom;
use style::computed_values; use style::computed_values;
use style::context::StyleContext; use style::context::StyleContext;
use style::logical_geometry::{WritingMode, BlockFlowDirection, InlineBaseDirection}; use style::logical_geometry::{WritingMode, BlockFlowDirection, InlineBaseDirection};

7
components/script/Cargo.toml
View file

@ -36,7 +36,8 @@ fnv = "1.0"
gfx_traits = {path = "../gfx_traits"} gfx_traits = {path = "../gfx_traits"}
heapsize = "0.3.6" heapsize = "0.3.6"
heapsize_derive = "0.1" heapsize_derive = "0.1"
html5ever = {version = "0.8.0", features = ["heap_size", "unstable"]} html5ever = {version = "0.9.0", features = ["heap_size", "unstable"]}
html5ever-atoms = {version = "0.1", features = ["heap_size"]}
hyper = "0.9.9" hyper = "0.9.9"
hyper_serde = "0.1.4" hyper_serde = "0.1.4"
image = "0.10" image = "0.10"
@ -66,8 +67,8 @@ script_layout_interface = {path = "../script_layout_interface"}
script_traits = {path = "../script_traits"} script_traits = {path = "../script_traits"}
selectors = "0.14" selectors = "0.14"
serde = "0.8" serde = "0.8"
servo_atoms = {path = "../atoms"}
smallvec = "0.1" smallvec = "0.1"
string_cache = {version = "0.2.26", features = ["heap_size", "unstable"]}
style = {path = "../style"} style = {path = "../style"}
style_traits = {path = "../style_traits"} style_traits = {path = "../style_traits"}
time = "0.1.12" time = "0.1.12"
@ -75,7 +76,7 @@ url = {version = "1.2", features = ["heap_size", "query_encoding"]}
util = {path = "../util"} util = {path = "../util"}
uuid = {version = "0.3.1", features = ["v4"]} uuid = {version = "0.3.1", features = ["v4"]}
websocket = "0.17" websocket = "0.17"
xml5ever = {version = "0.1.2", features = ["unstable"]} xml5ever = {version = "0.2", features = ["unstable"]}
[dependencies.webrender_traits] [dependencies.webrender_traits]
git = "https://github.com/servo/webrender" git = "https://github.com/servo/webrender"

41
components/script/dom/attr.rs
View file

@ -13,10 +13,11 @@ use dom::bindings::str::DOMString;
use dom::element::{AttributeMutation, Element}; use dom::element::{AttributeMutation, Element};
use dom::virtualmethods::vtable_for; use dom::virtualmethods::vtable_for;
use dom::window::Window; use dom::window::Window;
use html5ever_atoms::{Prefix, LocalName, Namespace};
use servo_atoms::Atom;
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::cell::Ref; use std::cell::Ref;
use std::mem; use std::mem;
use string_cache::{Atom, Namespace};
use style::attr::{AttrIdentifier, AttrValue}; use style::attr::{AttrIdentifier, AttrValue};
// https://dom.spec.whatwg.org/#interface-attr // https://dom.spec.whatwg.org/#interface-attr
@ -31,11 +32,11 @@ pub struct Attr {
} }
impl Attr { impl Attr {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
value: AttrValue, value: AttrValue,
name: Atom, name: LocalName,
namespace: Namespace, namespace: Namespace,
prefix: Option<Atom>, prefix: Option<Prefix>,
owner: Option<&Element>) owner: Option<&Element>)
-> Attr { -> Attr {
Attr { Attr {
@ -52,11 +53,11 @@ impl Attr {
} }
pub fn new(window: &Window, pub fn new(window: &Window,
local_name: Atom, local_name: LocalName,
value: AttrValue, value: AttrValue,
name: Atom, name: LocalName,
namespace: Namespace, namespace: Namespace,
prefix: Option<Atom>, prefix: Option<Prefix>,
owner: Option<&Element>) owner: Option<&Element>)
-> Root<Attr> { -> Root<Attr> {
reflect_dom_object(box Attr::new_inherited(local_name, reflect_dom_object(box Attr::new_inherited(local_name,
@ -70,7 +71,7 @@ impl Attr {
} }
#[inline] #[inline]
pub fn name(&self) -> &Atom { pub fn name(&self) -> &LocalName {
&self.identifier.name &self.identifier.name
} }
@ -80,7 +81,7 @@ impl Attr {
} }
#[inline] #[inline]
pub fn prefix(&self) -> &Option<Atom> { pub fn prefix(&self) -> &Option<Prefix> {
&self.identifier.prefix &self.identifier.prefix
} }
} }
@ -88,7 +89,7 @@ impl Attr {
impl AttrMethods for Attr { impl AttrMethods for Attr {
// https://dom.spec.whatwg.org/#dom-attr-localname // https://dom.spec.whatwg.org/#dom-attr-localname
fn LocalName(&self) -> DOMString { fn LocalName(&self) -> DOMString {
// FIXME(ajeffrey): convert directly from Atom to DOMString // FIXME(ajeffrey): convert directly from LocalName to DOMString
DOMString::from(&**self.local_name()) DOMString::from(&**self.local_name())
} }
@ -132,7 +133,7 @@ impl AttrMethods for Attr {
// https://dom.spec.whatwg.org/#dom-attr-name // https://dom.spec.whatwg.org/#dom-attr-name
fn Name(&self) -> DOMString { fn Name(&self) -> DOMString {
// FIXME(ajeffrey): convert directly from Atom to DOMString // FIXME(ajeffrey): convert directly from LocalName to DOMString
DOMString::from(&*self.identifier.name) DOMString::from(&*self.identifier.name)
} }
@ -143,16 +144,15 @@ impl AttrMethods for Attr {
// https://dom.spec.whatwg.org/#dom-attr-namespaceuri // https://dom.spec.whatwg.org/#dom-attr-namespaceuri
fn GetNamespaceURI(&self) -> Option<DOMString> { fn GetNamespaceURI(&self) -> Option<DOMString> {
let Namespace(ref atom) = self.identifier.namespace; match self.identifier.namespace {
match &**atom { ns!() => None,
"" => None, ref url => Some(DOMString::from(&**url)),
url => Some(DOMString::from(url)),
} }
} }
// https://dom.spec.whatwg.org/#dom-attr-prefix // https://dom.spec.whatwg.org/#dom-attr-prefix
fn GetPrefix(&self) -> Option<DOMString> { fn GetPrefix(&self) -> Option<DOMString> {
// FIXME(ajeffrey): convert directly from Atom to DOMString // FIXME(ajeffrey): convert directly from LocalName to DOMString
self.prefix().as_ref().map(|p| DOMString::from(&**p)) self.prefix().as_ref().map(|p| DOMString::from(&**p))
} }
@ -192,7 +192,7 @@ impl Attr {
self.value.borrow() self.value.borrow()
} }
pub fn local_name(&self) -> &Atom { pub fn local_name(&self) -> &LocalName {
&self.identifier.local_name &self.identifier.local_name
} }
@ -216,9 +216,8 @@ impl Attr {
} }
pub fn summarize(&self) -> AttrInfo { pub fn summarize(&self) -> AttrInfo {
let Namespace(ref ns) = self.identifier.namespace;
AttrInfo { AttrInfo {
namespace: (**ns).to_owned(), namespace: (*self.identifier.namespace).to_owned(),
name: String::from(self.Name()), name: String::from(self.Name()),
value: String::from(self.Value()), value: String::from(self.Value()),
} }
@ -231,7 +230,7 @@ pub trait AttrHelpersForLayout {
unsafe fn value_ref_forever(&self) -> &'static str; unsafe fn value_ref_forever(&self) -> &'static str;
unsafe fn value_atom_forever(&self) -> Option<Atom>; unsafe fn value_atom_forever(&self) -> Option<Atom>;
unsafe fn value_tokens_forever(&self) -> Option<&'static [Atom]>; unsafe fn value_tokens_forever(&self) -> Option<&'static [Atom]>;
unsafe fn local_name_atom_forever(&self) -> Atom; unsafe fn local_name_atom_forever(&self) -> LocalName;
unsafe fn value_for_layout(&self) -> &AttrValue; unsafe fn value_for_layout(&self) -> &AttrValue;
} }
@ -267,7 +266,7 @@ impl AttrHelpersForLayout for LayoutJS<Attr> {
} }
#[inline] #[inline]
unsafe fn local_name_atom_forever(&self) -> Atom { unsafe fn local_name_atom_forever(&self) -> LocalName {
(*self.unsafe_get()).identifier.local_name.clone() (*self.unsafe_get()).identifier.local_name.clone()
} }

2
components/script/dom/beforeunloadevent.rs
View file

@ -12,7 +12,7 @@ use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString; use dom::bindings::str::DOMString;
use dom::event::{Event, EventBubbles, EventCancelable}; use dom::event::{Event, EventBubbles, EventCancelable};
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use string_cache::Atom; use servo_atoms::Atom;
// https://html.spec.whatwg.org/multipage/#beforeunloadevent // https://html.spec.whatwg.org/multipage/#beforeunloadevent
#[dom_struct] #[dom_struct]

15
components/script/dom/bindings/str.rs
View file

@ -4,6 +4,8 @@
//! The `ByteString` struct. //! The `ByteString` struct.
use html5ever_atoms::{LocalName, Namespace};
use servo_atoms::Atom;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::borrow::{Borrow, Cow, ToOwned}; use std::borrow::{Borrow, Cow, ToOwned};
use std::fmt; use std::fmt;
@ -12,7 +14,6 @@ use std::ops;
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
use std::str; use std::str;
use std::str::{Bytes, FromStr}; use std::str::{Bytes, FromStr};
use string_cache::Atom;
/// Encapsulates the IDL `ByteString` type. /// Encapsulates the IDL `ByteString` type.
#[derive(JSTraceable, Clone, Eq, PartialEq, HeapSizeOf, Debug)] #[derive(JSTraceable, Clone, Eq, PartialEq, HeapSizeOf, Debug)]
@ -255,6 +256,18 @@ impl<'a> From<Cow<'a, str>> for DOMString {
} }
} }
impl From<DOMString> for LocalName {
fn from(contents: DOMString) -> LocalName {
LocalName::from(contents.0)
}
}
impl From<DOMString> for Namespace {
fn from(contents: DOMString) -> Namespace {
Namespace::from(contents.0)
}
}
impl From<DOMString> for Atom { impl From<DOMString> for Atom {
fn from(contents: DOMString) -> Atom { fn from(contents: DOMString) -> Atom {
Atom::from(contents.0) Atom::from(contents.0)

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

@ -47,6 +47,7 @@ use euclid::length::Length as EuclidLength;
use euclid::rect::Rect; use euclid::rect::Rect;
use euclid::size::Size2D; use euclid::size::Size2D;
use html5ever::tree_builder::QuirksMode; use html5ever::tree_builder::QuirksMode;
use html5ever_atoms::{Prefix, LocalName, Namespace, QualName};
use hyper::header::Headers; use hyper::header::Headers;
use hyper::method::Method; use hyper::method::Method;
use hyper::mime::Mime; use hyper::mime::Mime;
@ -76,6 +77,7 @@ use script_runtime::ScriptChan;
use script_traits::{TimerEventId, TimerSource, TouchpadPressurePhase}; use script_traits::{TimerEventId, TimerSource, TouchpadPressurePhase};
use script_traits::{UntrustedNodeAddress, WindowSizeData, WindowSizeType}; use script_traits::{UntrustedNodeAddress, WindowSizeData, WindowSizeType};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use servo_atoms::Atom;
use smallvec::SmallVec; use smallvec::SmallVec;
use std::boxed::FnBox; use std::boxed::FnBox;
use std::cell::{Cell, UnsafeCell}; use std::cell::{Cell, UnsafeCell};
@ -88,7 +90,6 @@ use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicUsize}; use std::sync::atomic::{AtomicBool, AtomicUsize};
use std::sync::mpsc::{Receiver, Sender}; use std::sync::mpsc::{Receiver, Sender};
use std::time::{SystemTime, Instant}; use std::time::{SystemTime, Instant};
use string_cache::{Atom, Namespace, QualName};
use style::attr::{AttrIdentifier, AttrValue, LengthOrPercentageOrAuto}; use style::attr::{AttrIdentifier, AttrValue, LengthOrPercentageOrAuto};
use style::element_state::*; use style::element_state::*;
use style::media_queries::MediaQueryList; use style::media_queries::MediaQueryList;
@ -311,7 +312,7 @@ no_jsmanaged_fields!(Arc<T>);
no_jsmanaged_fields!(Image, ImageMetadata, ImageCacheChan, ImageCacheThread); no_jsmanaged_fields!(Image, ImageMetadata, ImageCacheChan, ImageCacheThread);
no_jsmanaged_fields!(Metadata); no_jsmanaged_fields!(Metadata);
no_jsmanaged_fields!(NetworkError); no_jsmanaged_fields!(NetworkError);
no_jsmanaged_fields!(Atom, Namespace, QualName); no_jsmanaged_fields!(Atom, Prefix, LocalName, Namespace, QualName);
no_jsmanaged_fields!(Trusted<T: Reflectable>); no_jsmanaged_fields!(Trusted<T: Reflectable>);
no_jsmanaged_fields!(TrustedPromise); no_jsmanaged_fields!(TrustedPromise);
no_jsmanaged_fields!(PropertyDeclarationBlock); no_jsmanaged_fields!(PropertyDeclarationBlock);

8
components/script/dom/bindings/xmlname.rs
View file

@ -6,7 +6,7 @@
use dom::bindings::error::{Error, ErrorResult, Fallible}; use dom::bindings::error::{Error, ErrorResult, Fallible};
use dom::bindings::str::DOMString; use dom::bindings::str::DOMString;
use string_cache::{Atom, Namespace}; use html5ever_atoms::{Prefix, LocalName, Namespace};
/// Validate a qualified name. See https://dom.spec.whatwg.org/#validate for details. /// Validate a qualified name. See https://dom.spec.whatwg.org/#validate for details.
pub fn validate_qualified_name(qualified_name: &str) -> ErrorResult { pub fn validate_qualified_name(qualified_name: &str) -> ErrorResult {
@ -27,7 +27,7 @@ pub fn validate_qualified_name(qualified_name: &str) -> ErrorResult {
/// See https://dom.spec.whatwg.org/#validate-and-extract for details. /// See https://dom.spec.whatwg.org/#validate-and-extract for details.
pub fn validate_and_extract(namespace: Option<DOMString>, pub fn validate_and_extract(namespace: Option<DOMString>,
qualified_name: &str) qualified_name: &str)
-> Fallible<(Namespace, Option<Atom>, Atom)> { -> Fallible<(Namespace, Option<Prefix>, LocalName)> {
// Step 1. // Step 1.
let namespace = namespace_from_domstring(namespace); let namespace = namespace_from_domstring(namespace);
@ -75,7 +75,7 @@ pub fn validate_and_extract(namespace: Option<DOMString>,
}, },
(ns, p) => { (ns, p) => {
// Step 10. // Step 10.
Ok((ns, p.map(Atom::from), Atom::from(local_name))) Ok((ns, p.map(Prefix::from), LocalName::from(local_name)))
} }
} }
} }
@ -174,6 +174,6 @@ pub fn xml_name_type(name: &str) -> XMLName {
pub fn namespace_from_domstring(url: Option<DOMString>) -> Namespace { pub fn namespace_from_domstring(url: Option<DOMString>) -> Namespace {
match url { match url {
None => ns!(), None => ns!(),
Some(s) => Namespace(Atom::from(s)), Some(s) => Namespace::from(s),
} }
} }

2
components/script/dom/closeevent.rs
View file

@ -12,7 +12,7 @@ use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString; use dom::bindings::str::DOMString;
use dom::event::{Event, EventBubbles, EventCancelable}; use dom::event::{Event, EventBubbles, EventCancelable};
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use string_cache::Atom; use servo_atoms::Atom;
#[dom_struct] #[dom_struct]
pub struct CloseEvent { pub struct CloseEvent {

270
components/script/dom/create.rs
View file

@ -77,7 +77,7 @@ use dom::htmlulistelement::HTMLUListElement;
use dom::htmlunknownelement::HTMLUnknownElement; use dom::htmlunknownelement::HTMLUnknownElement;
use dom::htmlvideoelement::HTMLVideoElement; use dom::htmlvideoelement::HTMLVideoElement;
use dom::svgsvgelement::SVGSVGElement; use dom::svgsvgelement::SVGSVGElement;
use string_cache::{Atom, QualName}; use html5ever_atoms::{Prefix, QualName};
use util::prefs::PREFS; use util::prefs::PREFS;
fn create_svg_element(name: QualName, fn create_svg_element(name: QualName,
@ -102,7 +102,7 @@ fn create_svg_element(name: QualName,
} }
match name.local { match name.local {
atom!("svg") => make!(SVGSVGElement), local_name!("svg") => make!(SVGSVGElement),
_ => Element::new(name.local, name.ns, prefix, document), _ => Element::new(name.local, name.ns, prefix, document),
} }
} }
@ -128,157 +128,157 @@ fn create_html_element(name: QualName,
// This is a big match, and the IDs for inline-interned atoms are not very structured. // This is a big match, and the IDs for inline-interned atoms are not very structured.
// Perhaps we should build a perfect hash from those IDs instead. // Perhaps we should build a perfect hash from those IDs instead.
match name.local { match name.local {
atom!("a") => make!(HTMLAnchorElement), local_name!("a") => make!(HTMLAnchorElement),
atom!("abbr") => make!(HTMLElement), local_name!("abbr") => make!(HTMLElement),
atom!("acronym") => make!(HTMLElement), local_name!("acronym") => make!(HTMLElement),
atom!("address") => make!(HTMLElement), local_name!("address") => make!(HTMLElement),
atom!("applet") => make!(HTMLAppletElement), local_name!("applet") => make!(HTMLAppletElement),
atom!("area") => make!(HTMLAreaElement), local_name!("area") => make!(HTMLAreaElement),
atom!("article") => make!(HTMLElement), local_name!("article") => make!(HTMLElement),
atom!("aside") => make!(HTMLElement), local_name!("aside") => make!(HTMLElement),
atom!("audio") => make!(HTMLAudioElement), local_name!("audio") => make!(HTMLAudioElement),
atom!("b") => make!(HTMLElement), local_name!("b") => make!(HTMLElement),
atom!("base") => make!(HTMLBaseElement), local_name!("base") => make!(HTMLBaseElement),
atom!("bdi") => make!(HTMLElement), local_name!("bdi") => make!(HTMLElement),
atom!("bdo") => make!(HTMLElement), local_name!("bdo") => make!(HTMLElement),
// https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:bgsound // https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:bgsound
atom!("bgsound") => make!(HTMLUnknownElement), local_name!("bgsound") => make!(HTMLUnknownElement),
atom!("big") => make!(HTMLElement), local_name!("big") => make!(HTMLElement),
// https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:blink // https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:blink
atom!("blink") => make!(HTMLUnknownElement), local_name!("blink") => make!(HTMLUnknownElement),
// https://html.spec.whatwg.org/multipage/#the-blockquote-element // https://html.spec.whatwg.org/multipage/#the-blockquote-element
atom!("blockquote") => make!(HTMLQuoteElement), local_name!("blockquote") => make!(HTMLQuoteElement),
atom!("body") => make!(HTMLBodyElement), local_name!("body") => make!(HTMLBodyElement),
atom!("br") => make!(HTMLBRElement), local_name!("br") => make!(HTMLBRElement),
atom!("button") => make!(HTMLButtonElement), local_name!("button") => make!(HTMLButtonElement),
atom!("canvas") => make!(HTMLCanvasElement), local_name!("canvas") => make!(HTMLCanvasElement),
atom!("caption") => make!(HTMLTableCaptionElement), local_name!("caption") => make!(HTMLTableCaptionElement),
atom!("center") => make!(HTMLElement), local_name!("center") => make!(HTMLElement),
atom!("cite") => make!(HTMLElement), local_name!("cite") => make!(HTMLElement),
atom!("code") => make!(HTMLElement), local_name!("code") => make!(HTMLElement),
atom!("col") => make!(HTMLTableColElement), local_name!("col") => make!(HTMLTableColElement),
atom!("colgroup") => make!(HTMLTableColElement), local_name!("colgroup") => make!(HTMLTableColElement),
atom!("data") => make!(HTMLDataElement), local_name!("data") => make!(HTMLDataElement),
atom!("datalist") => make!(HTMLDataListElement), local_name!("datalist") => make!(HTMLDataListElement),
atom!("dd") => make!(HTMLElement), local_name!("dd") => make!(HTMLElement),
atom!("del") => make!(HTMLModElement), local_name!("del") => make!(HTMLModElement),
atom!("details") => make!(HTMLDetailsElement), local_name!("details") => make!(HTMLDetailsElement),
atom!("dfn") => make!(HTMLElement), local_name!("dfn") => make!(HTMLElement),
atom!("dialog") => make!(HTMLDialogElement), local_name!("dialog") => make!(HTMLDialogElement),
atom!("dir") => make!(HTMLDirectoryElement), local_name!("dir") => make!(HTMLDirectoryElement),
atom!("div") => make!(HTMLDivElement), local_name!("div") => make!(HTMLDivElement),
atom!("dl") => make!(HTMLDListElement), local_name!("dl") => make!(HTMLDListElement),
atom!("dt") => make!(HTMLElement), local_name!("dt") => make!(HTMLElement),
atom!("em") => make!(HTMLElement), local_name!("em") => make!(HTMLElement),
atom!("embed") => make!(HTMLEmbedElement), local_name!("embed") => make!(HTMLEmbedElement),
atom!("fieldset") => make!(HTMLFieldSetElement), local_name!("fieldset") => make!(HTMLFieldSetElement),
atom!("figcaption") => make!(HTMLElement), local_name!("figcaption") => make!(HTMLElement),
atom!("figure") => make!(HTMLElement), local_name!("figure") => make!(HTMLElement),
atom!("font") => make!(HTMLFontElement), local_name!("font") => make!(HTMLFontElement),
atom!("footer") => make!(HTMLElement), local_name!("footer") => make!(HTMLElement),
atom!("form") => make!(HTMLFormElement), local_name!("form") => make!(HTMLFormElement),
atom!("frame") => make!(HTMLFrameElement), local_name!("frame") => make!(HTMLFrameElement),
atom!("frameset") => make!(HTMLFrameSetElement), local_name!("frameset") => make!(HTMLFrameSetElement),
atom!("h1") => make!(HTMLHeadingElement, HeadingLevel::Heading1), local_name!("h1") => make!(HTMLHeadingElement, HeadingLevel::Heading1),
atom!("h2") => make!(HTMLHeadingElement, HeadingLevel::Heading2), local_name!("h2") => make!(HTMLHeadingElement, HeadingLevel::Heading2),
atom!("h3") => make!(HTMLHeadingElement, HeadingLevel::Heading3), local_name!("h3") => make!(HTMLHeadingElement, HeadingLevel::Heading3),
atom!("h4") => make!(HTMLHeadingElement, HeadingLevel::Heading4), local_name!("h4") => make!(HTMLHeadingElement, HeadingLevel::Heading4),
atom!("h5") => make!(HTMLHeadingElement, HeadingLevel::Heading5), local_name!("h5") => make!(HTMLHeadingElement, HeadingLevel::Heading5),
atom!("h6") => make!(HTMLHeadingElement, HeadingLevel::Heading6), local_name!("h6") => make!(HTMLHeadingElement, HeadingLevel::Heading6),
atom!("head") => make!(HTMLHeadElement), local_name!("head") => make!(HTMLHeadElement),
atom!("header") => make!(HTMLElement), local_name!("header") => make!(HTMLElement),
atom!("hgroup") => make!(HTMLElement), local_name!("hgroup") => make!(HTMLElement),
atom!("hr") => make!(HTMLHRElement), local_name!("hr") => make!(HTMLHRElement),
atom!("html") => make!(HTMLHtmlElement), local_name!("html") => make!(HTMLHtmlElement),
atom!("i") => make!(HTMLElement), local_name!("i") => make!(HTMLElement),
atom!("iframe") => make!(HTMLIFrameElement), local_name!("iframe") => make!(HTMLIFrameElement),
atom!("img") => make!(HTMLImageElement), local_name!("img") => make!(HTMLImageElement),
atom!("input") => make!(HTMLInputElement), local_name!("input") => make!(HTMLInputElement),
atom!("ins") => make!(HTMLModElement), local_name!("ins") => make!(HTMLModElement),
// https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:isindex-2 // https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:isindex-2
atom!("isindex") => make!(HTMLUnknownElement), local_name!("isindex") => make!(HTMLUnknownElement),
atom!("kbd") => make!(HTMLElement), local_name!("kbd") => make!(HTMLElement),
atom!("label") => make!(HTMLLabelElement), local_name!("label") => make!(HTMLLabelElement),
atom!("legend") => make!(HTMLLegendElement), local_name!("legend") => make!(HTMLLegendElement),
atom!("li") => make!(HTMLLIElement), local_name!("li") => make!(HTMLLIElement),
atom!("link") => make!(HTMLLinkElement, creator), local_name!("link") => make!(HTMLLinkElement, creator),
// https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:listing // https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:listing
atom!("listing") => make!(HTMLPreElement), local_name!("listing") => make!(HTMLPreElement),
atom!("main") => make!(HTMLElement), local_name!("main") => make!(HTMLElement),
atom!("map") => make!(HTMLMapElement), local_name!("map") => make!(HTMLMapElement),
atom!("mark") => make!(HTMLElement), local_name!("mark") => make!(HTMLElement),
atom!("marquee") => make!(HTMLElement), local_name!("marquee") => make!(HTMLElement),
atom!("meta") => make!(HTMLMetaElement), local_name!("meta") => make!(HTMLMetaElement),
atom!("meter") => make!(HTMLMeterElement), local_name!("meter") => make!(HTMLMeterElement),
// https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:multicol // https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:multicol
atom!("multicol") => make!(HTMLUnknownElement), local_name!("multicol") => make!(HTMLUnknownElement),
atom!("nav") => make!(HTMLElement), local_name!("nav") => make!(HTMLElement),
// https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:nextid // https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:nextid
atom!("nextid") => make!(HTMLUnknownElement), local_name!("nextid") => make!(HTMLUnknownElement),
atom!("nobr") => make!(HTMLElement), local_name!("nobr") => make!(HTMLElement),
atom!("noframes") => make!(HTMLElement), local_name!("noframes") => make!(HTMLElement),
atom!("noscript") => make!(HTMLElement), local_name!("noscript") => make!(HTMLElement),
atom!("object") => make!(HTMLObjectElement), local_name!("object") => make!(HTMLObjectElement),
atom!("ol") => make!(HTMLOListElement), local_name!("ol") => make!(HTMLOListElement),
atom!("optgroup") => make!(HTMLOptGroupElement), local_name!("optgroup") => make!(HTMLOptGroupElement),
atom!("option") => make!(HTMLOptionElement), local_name!("option") => make!(HTMLOptionElement),
atom!("output") => make!(HTMLOutputElement), local_name!("output") => make!(HTMLOutputElement),
atom!("p") => make!(HTMLParagraphElement), local_name!("p") => make!(HTMLParagraphElement),
atom!("param") => make!(HTMLParamElement), local_name!("param") => make!(HTMLParamElement),
atom!("plaintext") => make!(HTMLPreElement), local_name!("plaintext") => make!(HTMLPreElement),
atom!("pre") => make!(HTMLPreElement), local_name!("pre") => make!(HTMLPreElement),
atom!("progress") => make!(HTMLProgressElement), local_name!("progress") => make!(HTMLProgressElement),
atom!("q") => make!(HTMLQuoteElement), local_name!("q") => make!(HTMLQuoteElement),
atom!("rp") => make!(HTMLElement), local_name!("rp") => make!(HTMLElement),
atom!("rt") => make!(HTMLElement), local_name!("rt") => make!(HTMLElement),
atom!("ruby") => make!(HTMLElement), local_name!("ruby") => make!(HTMLElement),
atom!("s") => make!(HTMLElement), local_name!("s") => make!(HTMLElement),
atom!("samp") => make!(HTMLElement), local_name!("samp") => make!(HTMLElement),
atom!("script") => make!(HTMLScriptElement, creator), local_name!("script") => make!(HTMLScriptElement, creator),
atom!("section") => make!(HTMLElement), local_name!("section") => make!(HTMLElement),
atom!("select") => make!(HTMLSelectElement), local_name!("select") => make!(HTMLSelectElement),
atom!("small") => make!(HTMLElement), local_name!("small") => make!(HTMLElement),
atom!("source") => make!(HTMLSourceElement), local_name!("source") => make!(HTMLSourceElement),
// https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:spacer // https://html.spec.whatwg.org/multipage/#other-elements,-attributes-and-apis:spacer
atom!("spacer") => make!(HTMLUnknownElement), local_name!("spacer") => make!(HTMLUnknownElement),
atom!("span") => make!(HTMLSpanElement), local_name!("span") => make!(HTMLSpanElement),
atom!("strike") => make!(HTMLElement), local_name!("strike") => make!(HTMLElement),
atom!("strong") => make!(HTMLElement), local_name!("strong") => make!(HTMLElement),
atom!("style") => make!(HTMLStyleElement), local_name!("style") => make!(HTMLStyleElement),
atom!("sub") => make!(HTMLElement), local_name!("sub") => make!(HTMLElement),
atom!("summary") => make!(HTMLElement), local_name!("summary") => make!(HTMLElement),
atom!("sup") => make!(HTMLElement), local_name!("sup") => make!(HTMLElement),
atom!("table") => make!(HTMLTableElement), local_name!("table") => make!(HTMLTableElement),
atom!("tbody") => make!(HTMLTableSectionElement), local_name!("tbody") => make!(HTMLTableSectionElement),
atom!("td") => make!(HTMLTableDataCellElement), local_name!("td") => make!(HTMLTableDataCellElement),
atom!("template") => make!(HTMLTemplateElement), local_name!("template") => make!(HTMLTemplateElement),
atom!("textarea") => make!(HTMLTextAreaElement), local_name!("textarea") => make!(HTMLTextAreaElement),
// https://html.spec.whatwg.org/multipage/#the-tfoot-element:concept-element-dom // https://html.spec.whatwg.org/multipage/#the-tfoot-element:concept-element-dom
atom!("tfoot") => make!(HTMLTableSectionElement), local_name!("tfoot") => make!(HTMLTableSectionElement),
atom!("th") => make!(HTMLTableHeaderCellElement), local_name!("th") => make!(HTMLTableHeaderCellElement),
// https://html.spec.whatwg.org/multipage/#the-thead-element:concept-element-dom // https://html.spec.whatwg.org/multipage/#the-thead-element:concept-element-dom
atom!("thead") => make!(HTMLTableSectionElement), local_name!("thead") => make!(HTMLTableSectionElement),
atom!("time") => make!(HTMLTimeElement), local_name!("time") => make!(HTMLTimeElement),
atom!("title") => make!(HTMLTitleElement), local_name!("title") => make!(HTMLTitleElement),
atom!("tr") => make!(HTMLTableRowElement), local_name!("tr") => make!(HTMLTableRowElement),
atom!("tt") => make!(HTMLElement), local_name!("tt") => make!(HTMLElement),
atom!("track") => make!(HTMLTrackElement), local_name!("track") => make!(HTMLTrackElement),
atom!("u") => make!(HTMLElement), local_name!("u") => make!(HTMLElement),
atom!("ul") => make!(HTMLUListElement), local_name!("ul") => make!(HTMLUListElement),
atom!("var") => make!(HTMLElement), local_name!("var") => make!(HTMLElement),
atom!("video") => make!(HTMLVideoElement), local_name!("video") => make!(HTMLVideoElement),
atom!("wbr") => make!(HTMLElement), local_name!("wbr") => make!(HTMLElement),
atom!("xmp") => make!(HTMLPreElement), local_name!("xmp") => make!(HTMLPreElement),
_ => make!(HTMLUnknownElement), _ => make!(HTMLUnknownElement),
} }
} }
pub fn create_element(name: QualName, pub fn create_element(name: QualName,
prefix: Option<Atom>, prefix: Option<Prefix>,
document: &Document, document: &Document,
creator: ElementCreator) creator: ElementCreator)
-> Root<Element> { -> Root<Element> {
// FIXME(ajeffrey): Convert directly from Atom to DOMString. // FIXME(ajeffrey): Convert directly from Prefix to DOMString.
let prefix = prefix.map(|p| DOMString::from(&*p)); let prefix = prefix.map(|p| DOMString::from(&*p));

2
components/script/dom/cssstyledeclaration.rs
View file

@ -13,9 +13,9 @@ use dom::element::Element;
use dom::node::{Node, NodeDamage, window_from_node}; use dom::node::{Node, NodeDamage, window_from_node};
use dom::window::Window; use dom::window::Window;
use parking_lot::RwLock; use parking_lot::RwLock;
use servo_atoms::Atom;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::sync::Arc; use std::sync::Arc;
use string_cache::Atom;
use style::parser::ParserContextExtraData; use style::parser::ParserContextExtraData;
use style::properties::{Shorthand, Importance, PropertyDeclarationBlock}; use style::properties::{Shorthand, Importance, PropertyDeclarationBlock};
use style::properties::{is_supported_property, parse_one_declaration, parse_style_attribute}; use style::properties::{is_supported_property, parse_one_declaration, parse_style_attribute};

2
components/script/dom/customevent.rs
View file

@ -14,7 +14,7 @@ use dom::event::Event;
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use js::jsapi::{HandleValue, JSContext}; use js::jsapi::{HandleValue, JSContext};
use js::jsval::JSVal; use js::jsval::JSVal;
use string_cache::Atom; use servo_atoms::Atom;
// https://dom.spec.whatwg.org/#interface-customevent // https://dom.spec.whatwg.org/#interface-customevent
#[dom_struct] #[dom_struct]

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

@ -91,6 +91,7 @@ use encoding::EncodingRef;
use encoding::all::UTF_8; use encoding::all::UTF_8;
use euclid::point::Point2D; use euclid::point::Point2D;
use html5ever::tree_builder::{LimitedQuirks, NoQuirks, Quirks, QuirksMode}; use html5ever::tree_builder::{LimitedQuirks, NoQuirks, Quirks, QuirksMode};
use html5ever_atoms::{LocalName, QualName};
use ipc_channel::ipc::{self, IpcSender}; use ipc_channel::ipc::{self, IpcSender};
use js::jsapi::{JSContext, JSObject, JSRuntime}; use js::jsapi::{JSContext, JSObject, JSRuntime};
use js::jsapi::JS_GetRuntime; use js::jsapi::JS_GetRuntime;
@ -110,6 +111,7 @@ use script_traits::{AnimationState, CompositorEvent, MouseButton, MouseEventType
use script_traits::{ScriptMsg as ConstellationMsg, TouchpadPressurePhase}; use script_traits::{ScriptMsg as ConstellationMsg, TouchpadPressurePhase};
use script_traits::{TouchEventType, TouchId}; use script_traits::{TouchEventType, TouchId};
use script_traits::UntrustedNodeAddress; use script_traits::UntrustedNodeAddress;
use servo_atoms::Atom;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::boxed::FnBox; use std::boxed::FnBox;
@ -122,7 +124,6 @@ use std::mem;
use std::rc::Rc; use std::rc::Rc;
use std::sync::Arc; use std::sync::Arc;
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use string_cache::{Atom, QualName};
use style::attr::AttrValue; use style::attr::AttrValue;
use style::context::ReflowGoal; use style::context::ReflowGoal;
use style::selector_impl::ElementSnapshot; use style::selector_impl::ElementSnapshot;
@ -175,7 +176,7 @@ pub struct Document {
quirks_mode: Cell<QuirksMode>, quirks_mode: Cell<QuirksMode>,
/// Caches for the getElement methods /// Caches for the getElement methods
id_map: DOMRefCell<HashMap<Atom, Vec<JS<Element>>>>, id_map: DOMRefCell<HashMap<Atom, Vec<JS<Element>>>>,
tag_map: DOMRefCell<HashMap<Atom, JS<HTMLCollection>>>, tag_map: DOMRefCell<HashMap<LocalName, JS<HTMLCollection>>>,
tagns_map: DOMRefCell<HashMap<QualName, JS<HTMLCollection>>>, tagns_map: DOMRefCell<HashMap<QualName, JS<HTMLCollection>>>,
classes_map: DOMRefCell<HashMap<Vec<Atom>, JS<HTMLCollection>>>, classes_map: DOMRefCell<HashMap<Vec<Atom>, JS<HTMLCollection>>>,
images: MutNullableHeap<JS<HTMLCollection>>, images: MutNullableHeap<JS<HTMLCollection>>,
@ -288,7 +289,7 @@ struct LinksFilter;
impl CollectionFilter for LinksFilter { impl CollectionFilter for LinksFilter {
fn filter(&self, elem: &Element, _root: &Node) -> bool { fn filter(&self, elem: &Element, _root: &Node) -> bool {
(elem.is::<HTMLAnchorElement>() || elem.is::<HTMLAreaElement>()) && (elem.is::<HTMLAnchorElement>() || elem.is::<HTMLAreaElement>()) &&
elem.has_attribute(&atom!("href")) elem.has_attribute(&local_name!("href"))
} }
} }
@ -312,7 +313,7 @@ impl CollectionFilter for ScriptsFilter {
struct AnchorsFilter; struct AnchorsFilter;
impl CollectionFilter for AnchorsFilter { impl CollectionFilter for AnchorsFilter {
fn filter(&self, elem: &Element, _root: &Node) -> bool { fn filter(&self, elem: &Element, _root: &Node) -> bool {
elem.is::<HTMLAnchorElement>() && elem.has_attribute(&atom!("href")) elem.is::<HTMLAnchorElement>() && elem.has_attribute(&local_name!("href"))
} }
} }
@ -428,7 +429,7 @@ impl Document {
let base = self.upcast::<Node>() let base = self.upcast::<Node>()
.traverse_preorder() .traverse_preorder()
.filter_map(Root::downcast::<HTMLBaseElement>) .filter_map(Root::downcast::<HTMLBaseElement>)
.find(|element| element.upcast::<Element>().has_attribute(&atom!("href"))); .find(|element| element.upcast::<Element>().has_attribute(&local_name!("href")));
self.base_element.set(base.r()); self.base_element.set(base.r());
} }
@ -577,7 +578,7 @@ impl Document {
fn get_anchor_by_name(&self, name: &str) -> Option<Root<Element>> { fn get_anchor_by_name(&self, name: &str) -> Option<Root<Element>> {
let check_anchor = |node: &HTMLAnchorElement| { let check_anchor = |node: &HTMLAnchorElement| {
let elem = node.upcast::<Element>(); let elem = node.upcast::<Element>();
elem.get_attribute(&ns!(), &atom!("name")) elem.get_attribute(&ns!(), &local_name!("name"))
.map_or(false, |attr| &**attr.value() == name) .map_or(false, |attr| &**attr.value() == name)
}; };
let doc_node = self.upcast::<Node>(); let doc_node = self.upcast::<Node>();
@ -1322,7 +1323,7 @@ impl Document {
} }
} }
pub fn get_body_attribute(&self, local_name: &Atom) -> DOMString { pub fn get_body_attribute(&self, local_name: &LocalName) -> DOMString {
match self.GetBody().and_then(Root::downcast::<HTMLBodyElement>) { match self.GetBody().and_then(Root::downcast::<HTMLBodyElement>) {
Some(ref body) => { Some(ref body) => {
body.upcast::<Element>().get_string_attribute(local_name) body.upcast::<Element>().get_string_attribute(local_name)
@ -1331,7 +1332,7 @@ impl Document {
} }
} }
pub fn set_body_attribute(&self, local_name: &Atom, value: DOMString) { pub fn set_body_attribute(&self, local_name: &LocalName, value: DOMString) {
if let Some(ref body) = self.GetBody().and_then(Root::downcast::<HTMLBodyElement>) { if let Some(ref body) = self.GetBody().and_then(Root::downcast::<HTMLBodyElement>) {
let body = body.upcast::<Element>(); let body = body.upcast::<Element>();
let value = body.parse_attribute(&ns!(), &local_name, value); let value = body.parse_attribute(&ns!(), &local_name, value);
@ -2175,13 +2176,13 @@ impl DocumentMethods for Document {
// https://dom.spec.whatwg.org/#dom-document-getelementsbytagname // https://dom.spec.whatwg.org/#dom-document-getelementsbytagname
fn GetElementsByTagName(&self, tag_name: DOMString) -> Root<HTMLCollection> { fn GetElementsByTagName(&self, tag_name: DOMString) -> Root<HTMLCollection> {
let tag_atom = Atom::from(&*tag_name); let tag_atom = LocalName::from(&*tag_name);
match self.tag_map.borrow_mut().entry(tag_atom.clone()) { match self.tag_map.borrow_mut().entry(tag_atom.clone()) {
Occupied(entry) => Root::from_ref(entry.get()), Occupied(entry) => Root::from_ref(entry.get()),
Vacant(entry) => { Vacant(entry) => {
let mut tag_copy = tag_name; let mut tag_copy = tag_name;
tag_copy.make_ascii_lowercase(); tag_copy.make_ascii_lowercase();
let ascii_lower_tag = Atom::from(tag_copy); let ascii_lower_tag = LocalName::from(tag_copy);
let result = HTMLCollection::by_atomic_tag_name(&self.window, let result = HTMLCollection::by_atomic_tag_name(&self.window,
self.upcast(), self.upcast(),
tag_atom, tag_atom,
@ -2198,7 +2199,7 @@ impl DocumentMethods for Document {
tag_name: DOMString) tag_name: DOMString)
-> Root<HTMLCollection> { -> Root<HTMLCollection> {
let ns = namespace_from_domstring(maybe_ns); let ns = namespace_from_domstring(maybe_ns);
let local = Atom::from(tag_name); let local = LocalName::from(tag_name);
let qname = QualName::new(ns, local); let qname = QualName::new(ns, local);
match self.tagns_map.borrow_mut().entry(qname.clone()) { match self.tagns_map.borrow_mut().entry(qname.clone()) {
Occupied(entry) => Root::from_ref(entry.get()), Occupied(entry) => Root::from_ref(entry.get()),
@ -2241,7 +2242,7 @@ impl DocumentMethods for Document {
if self.is_html_document { if self.is_html_document {
local_name.make_ascii_lowercase(); local_name.make_ascii_lowercase();
} }
let name = QualName::new(ns!(html), Atom::from(local_name)); let name = QualName::new(ns!(html), LocalName::from(local_name));
Ok(Element::create(name, None, self, ElementCreator::ScriptCreated)) Ok(Element::create(name, None, self, ElementCreator::ScriptCreated))
} }
@ -2265,7 +2266,7 @@ impl DocumentMethods for Document {
if self.is_html_document { if self.is_html_document {
local_name.make_ascii_lowercase(); local_name.make_ascii_lowercase();
} }
let name = Atom::from(local_name); let name = LocalName::from(local_name);
let value = AttrValue::String("".to_owned()); let value = AttrValue::String("".to_owned());
Ok(Attr::new(&self.window, name.clone(), value, name, ns!(), None, None)) Ok(Attr::new(&self.window, name.clone(), value, name, ns!(), None, None))
@ -2279,7 +2280,7 @@ impl DocumentMethods for Document {
let (namespace, prefix, local_name) = try!(validate_and_extract(namespace, let (namespace, prefix, local_name) = try!(validate_and_extract(namespace,
&qualified_name)); &qualified_name));
let value = AttrValue::String("".to_owned()); let value = AttrValue::String("".to_owned());
let qualified_name = Atom::from(qualified_name); let qualified_name = LocalName::from(qualified_name);
Ok(Attr::new(&self.window, Ok(Attr::new(&self.window,
local_name, local_name,
value, value,
@ -2465,12 +2466,12 @@ impl DocumentMethods for Document {
// https://html.spec.whatwg.org/multipage/#document.title // https://html.spec.whatwg.org/multipage/#document.title
fn Title(&self) -> DOMString { fn Title(&self) -> DOMString {
let title = self.GetDocumentElement().and_then(|root| { let title = self.GetDocumentElement().and_then(|root| {
if root.namespace() == &ns!(svg) && root.local_name() == &atom!("svg") { if root.namespace() == &ns!(svg) && root.local_name() == &local_name!("svg") {
// Step 1. // Step 1.
root.upcast::<Node>() root.upcast::<Node>()
.child_elements() .child_elements()
.find(|node| { .find(|node| {
node.namespace() == &ns!(svg) && node.local_name() == &atom!("title") node.namespace() == &ns!(svg) && node.local_name() == &local_name!("title")
}) })
.map(Root::upcast::<Node>) .map(Root::upcast::<Node>)
} else { } else {
@ -2498,14 +2499,14 @@ impl DocumentMethods for Document {
None => return, None => return,
}; };
let elem = if root.namespace() == &ns!(svg) && root.local_name() == &atom!("svg") { let elem = if root.namespace() == &ns!(svg) && root.local_name() == &local_name!("svg") {
let elem = root.upcast::<Node>().child_elements().find(|node| { let elem = root.upcast::<Node>().child_elements().find(|node| {
node.namespace() == &ns!(svg) && node.local_name() == &atom!("title") node.namespace() == &ns!(svg) && node.local_name() == &local_name!("title")
}); });
match elem { match elem {
Some(elem) => Root::upcast::<Node>(elem), Some(elem) => Root::upcast::<Node>(elem),
None => { None => {
let name = QualName::new(ns!(svg), atom!("title")); let name = QualName::new(ns!(svg), local_name!("title"));
let elem = Element::create(name, None, self, ElementCreator::ScriptCreated); let elem = Element::create(name, None, self, ElementCreator::ScriptCreated);
let parent = root.upcast::<Node>(); let parent = root.upcast::<Node>();
let child = elem.upcast::<Node>(); let child = elem.upcast::<Node>();
@ -2522,7 +2523,7 @@ impl DocumentMethods for Document {
None => { None => {
match self.GetHead() { match self.GetHead() {
Some(head) => { Some(head) => {
let name = QualName::new(ns!(html), atom!("title")); let name = QualName::new(ns!(html), local_name!("title"));
let elem = Element::create(name, let elem = Element::create(name,
None, None,
self, self,
@ -2617,7 +2618,7 @@ impl DocumentMethods for Document {
if element.namespace() != &ns!(html) { if element.namespace() != &ns!(html) {
return false; return false;
} }
element.get_attribute(&ns!(), &atom!("name")) element.get_attribute(&ns!(), &local_name!("name"))
.map_or(false, |attr| &**attr.value() == &*name) .map_or(false, |attr| &**attr.value() == &*name)
}) })
} }
@ -2785,22 +2786,22 @@ impl DocumentMethods for Document {
// https://html.spec.whatwg.org/multipage/#dom-document-bgcolor // https://html.spec.whatwg.org/multipage/#dom-document-bgcolor
fn BgColor(&self) -> DOMString { fn BgColor(&self) -> DOMString {
self.get_body_attribute(&atom!("bgcolor")) self.get_body_attribute(&local_name!("bgcolor"))
} }
// https://html.spec.whatwg.org/multipage/#dom-document-bgcolor // https://html.spec.whatwg.org/multipage/#dom-document-bgcolor
fn SetBgColor(&self, value: DOMString) { fn SetBgColor(&self, value: DOMString) {
self.set_body_attribute(&atom!("bgcolor"), value) self.set_body_attribute(&local_name!("bgcolor"), value)
} }
// https://html.spec.whatwg.org/multipage/#dom-document-fgcolor // https://html.spec.whatwg.org/multipage/#dom-document-fgcolor
fn FgColor(&self) -> DOMString { fn FgColor(&self) -> DOMString {
self.get_body_attribute(&atom!("text")) self.get_body_attribute(&local_name!("text"))
} }
// https://html.spec.whatwg.org/multipage/#dom-document-fgcolor // https://html.spec.whatwg.org/multipage/#dom-document-fgcolor
fn SetFgColor(&self, value: DOMString) { fn SetFgColor(&self, value: DOMString) {
self.set_body_attribute(&atom!("text"), value) self.set_body_attribute(&local_name!("text"), value)
} }
#[allow(unsafe_code)] #[allow(unsafe_code)]
@ -2827,10 +2828,10 @@ impl DocumentMethods for Document {
}; };
match html_elem_type { match html_elem_type {
HTMLElementTypeId::HTMLAppletElement => { HTMLElementTypeId::HTMLAppletElement => {
match elem.get_attribute(&ns!(), &atom!("name")) { match elem.get_attribute(&ns!(), &local_name!("name")) {
Some(ref attr) if attr.value().as_atom() == name => true, Some(ref attr) if attr.value().as_atom() == name => true,
_ => { _ => {
match elem.get_attribute(&ns!(), &atom!("id")) { match elem.get_attribute(&ns!(), &local_name!("id")) {
Some(ref attr) => attr.value().as_atom() == name, Some(ref attr) => attr.value().as_atom() == name,
None => false, None => false,
} }
@ -2838,18 +2839,18 @@ impl DocumentMethods for Document {
} }
}, },
HTMLElementTypeId::HTMLFormElement => { HTMLElementTypeId::HTMLFormElement => {
match elem.get_attribute(&ns!(), &atom!("name")) { match elem.get_attribute(&ns!(), &local_name!("name")) {
Some(ref attr) => attr.value().as_atom() == name, Some(ref attr) => attr.value().as_atom() == name,
None => false, None => false,
} }
}, },
HTMLElementTypeId::HTMLImageElement => { HTMLElementTypeId::HTMLImageElement => {
match elem.get_attribute(&ns!(), &atom!("name")) { match elem.get_attribute(&ns!(), &local_name!("name")) {
Some(ref attr) => { Some(ref attr) => {
if attr.value().as_atom() == name { if attr.value().as_atom() == name {
true true
} else { } else {
match elem.get_attribute(&ns!(), &atom!("id")) { match elem.get_attribute(&ns!(), &local_name!("id")) {
Some(ref attr) => attr.value().as_atom() == name, Some(ref attr) => attr.value().as_atom() == name,
None => false, None => false,
} }

4
components/script/dom/documentfragment.rs
View file

@ -16,7 +16,7 @@ use dom::globalscope::GlobalScope;
use dom::htmlcollection::HTMLCollection; use dom::htmlcollection::HTMLCollection;
use dom::node::{Node, window_from_node}; use dom::node::{Node, window_from_node};
use dom::nodelist::NodeList; use dom::nodelist::NodeList;
use string_cache::Atom; use servo_atoms::Atom;
// https://dom.spec.whatwg.org/#documentfragment // https://dom.spec.whatwg.org/#documentfragment
#[dom_struct] #[dom_struct]
@ -57,7 +57,7 @@ impl DocumentFragmentMethods for DocumentFragment {
let node = self.upcast::<Node>(); let node = self.upcast::<Node>();
let id = Atom::from(id); let id = Atom::from(id);
node.traverse_preorder().filter_map(Root::downcast::<Element>).find(|descendant| { node.traverse_preorder().filter_map(Root::downcast::<Element>).find(|descendant| {
match descendant.get_attribute(&ns!(), &atom!("id")) { match descendant.get_attribute(&ns!(), &local_name!("id")) {
None => false, None => false,
Some(attr) => *attr.value().as_atom() == id, Some(attr) => *attr.value().as_atom() == id,
} }

8
components/script/dom/domimplementation.rs
View file

@ -142,14 +142,14 @@ impl DOMImplementationMethods for DOMImplementation {
{ {
// Step 4. // Step 4.
let doc_node = doc.upcast::<Node>(); let doc_node = doc.upcast::<Node>();
let doc_html = Root::upcast::<Node>(HTMLHtmlElement::new(atom!("html"), let doc_html = Root::upcast::<Node>(HTMLHtmlElement::new(local_name!("html"),
None, None,
&doc)); &doc));
doc_node.AppendChild(&doc_html).expect("Appending failed"); doc_node.AppendChild(&doc_html).expect("Appending failed");
{ {
// Step 5. // Step 5.
let doc_head = Root::upcast::<Node>(HTMLHeadElement::new(atom!("head"), let doc_head = Root::upcast::<Node>(HTMLHeadElement::new(local_name!("head"),
None, None,
&doc)); &doc));
doc_html.AppendChild(&doc_head).unwrap(); doc_html.AppendChild(&doc_head).unwrap();
@ -160,7 +160,7 @@ impl DOMImplementationMethods for DOMImplementation {
Some(title_str) => { Some(title_str) => {
// Step 6.1. // Step 6.1.
let doc_title = let doc_title =
Root::upcast::<Node>(HTMLTitleElement::new(atom!("title"), Root::upcast::<Node>(HTMLTitleElement::new(local_name!("title"),
None, None,
&doc)); &doc));
doc_head.AppendChild(&doc_title).unwrap(); doc_head.AppendChild(&doc_title).unwrap();
@ -173,7 +173,7 @@ impl DOMImplementationMethods for DOMImplementation {
} }
// Step 7. // Step 7.
let doc_body = HTMLBodyElement::new(atom!("body"), None, &doc); let doc_body = HTMLBodyElement::new(local_name!("body"), None, &doc);
doc_html.AppendChild(doc_body.upcast()).unwrap(); doc_html.AppendChild(doc_body.upcast()).unwrap();
} }

9
components/script/dom/domtokenlist.rs
View file

@ -11,18 +11,19 @@ use dom::bindings::reflector::{Reflector, reflect_dom_object};
use dom::bindings::str::DOMString; use dom::bindings::str::DOMString;
use dom::element::Element; use dom::element::Element;
use dom::node::window_from_node; use dom::node::window_from_node;
use string_cache::Atom; use html5ever_atoms::LocalName;
use servo_atoms::Atom;
use style::str::HTML_SPACE_CHARACTERS; use style::str::HTML_SPACE_CHARACTERS;
#[dom_struct] #[dom_struct]
pub struct DOMTokenList { pub struct DOMTokenList {
reflector_: Reflector, reflector_: Reflector,
element: JS<Element>, element: JS<Element>,
local_name: Atom, local_name: LocalName,
} }
impl DOMTokenList { impl DOMTokenList {
pub fn new_inherited(element: &Element, local_name: Atom) -> DOMTokenList { pub fn new_inherited(element: &Element, local_name: LocalName) -> DOMTokenList {
DOMTokenList { DOMTokenList {
reflector_: Reflector::new(), reflector_: Reflector::new(),
element: JS::from_ref(element), element: JS::from_ref(element),
@ -30,7 +31,7 @@ impl DOMTokenList {
} }
} }
pub fn new(element: &Element, local_name: &Atom) -> Root<DOMTokenList> { pub fn new(element: &Element, local_name: &LocalName) -> Root<DOMTokenList> {
let window = window_from_node(element); let window = window_from_node(element);
reflect_dom_object(box DOMTokenList::new_inherited(element, local_name.clone()), reflect_dom_object(box DOMTokenList::new_inherited(element, local_name.clone()),
&*window, &*window,

183
components/script/dom/element.rs
View file

@ -69,10 +69,12 @@ use html5ever::serialize::SerializeOpts;
use html5ever::serialize::TraversalScope; use html5ever::serialize::TraversalScope;
use html5ever::serialize::TraversalScope::{ChildrenOnly, IncludeNode}; use html5ever::serialize::TraversalScope::{ChildrenOnly, IncludeNode};
use html5ever::tree_builder::{LimitedQuirks, NoQuirks, Quirks}; use html5ever::tree_builder::{LimitedQuirks, NoQuirks, Quirks};
use html5ever_atoms::{Prefix, LocalName, Namespace, QualName};
use parking_lot::RwLock; use parking_lot::RwLock;
use selectors::matching::{ElementFlags, MatchingReason, matches}; use selectors::matching::{ElementFlags, MatchingReason, matches};
use selectors::matching::{HAS_EDGE_CHILD_SELECTOR, HAS_SLOW_SELECTOR, HAS_SLOW_SELECTOR_LATER_SIBLINGS}; use selectors::matching::{HAS_EDGE_CHILD_SELECTOR, HAS_SLOW_SELECTOR, HAS_SLOW_SELECTOR_LATER_SIBLINGS};
use selectors::parser::{AttrSelector, NamespaceConstraint, parse_author_origin_selector_list_from_str}; use selectors::parser::{AttrSelector, NamespaceConstraint, parse_author_origin_selector_list_from_str};
use servo_atoms::Atom;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::borrow::Cow; use std::borrow::Cow;
use std::cell::{Cell, Ref}; use std::cell::{Cell, Ref};
@ -81,7 +83,6 @@ use std::default::Default;
use std::fmt; use std::fmt;
use std::sync::Arc; use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::atomic::{AtomicUsize, Ordering};
use string_cache::{Atom, Namespace, QualName};
use style::attr::{AttrValue, LengthOrPercentageOrAuto}; use style::attr::{AttrValue, LengthOrPercentageOrAuto};
use style::element_state::*; use style::element_state::*;
use style::matching::{common_style_affecting_attributes, rare_style_affecting_attributes}; use style::matching::{common_style_affecting_attributes, rare_style_affecting_attributes};
@ -102,7 +103,7 @@ use style::values::specified::{self, CSSColor, CSSRGBA, LengthOrPercentage};
#[dom_struct] #[dom_struct]
pub struct Element { pub struct Element {
node: Node, node: Node,
local_name: Atom, local_name: LocalName,
tag_name: TagName, tag_name: TagName,
namespace: Namespace, namespace: Namespace,
prefix: Option<DOMString>, prefix: Option<DOMString>,
@ -157,20 +158,20 @@ impl<'a> TryFrom<&'a str> for AdjacentPosition {
// Element methods // Element methods
// //
impl Element { impl Element {
pub fn create(name: QualName, prefix: Option<Atom>, pub fn create(name: QualName, prefix: Option<Prefix>,
document: &Document, creator: ElementCreator) document: &Document, creator: ElementCreator)
-> Root<Element> { -> Root<Element> {
create_element(name, prefix, document, creator) create_element(name, prefix, document, creator)
} }
pub fn new_inherited(local_name: Atom, pub fn new_inherited(local_name: LocalName,
namespace: Namespace, prefix: Option<DOMString>, namespace: Namespace, prefix: Option<DOMString>,
document: &Document) -> Element { document: &Document) -> Element {
Element::new_inherited_with_state(ElementState::empty(), local_name, Element::new_inherited_with_state(ElementState::empty(), local_name,
namespace, prefix, document) namespace, prefix, document)
} }
pub fn new_inherited_with_state(state: ElementState, local_name: Atom, pub fn new_inherited_with_state(state: ElementState, local_name: LocalName,
namespace: Namespace, prefix: Option<DOMString>, namespace: Namespace, prefix: Option<DOMString>,
document: &Document) document: &Document)
-> Element { -> Element {
@ -190,7 +191,7 @@ impl Element {
} }
} }
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
namespace: Namespace, namespace: Namespace,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<Element> { document: &Document) -> Root<Element> {
@ -232,16 +233,16 @@ impl Element {
#[allow(unsafe_code)] #[allow(unsafe_code)]
pub trait RawLayoutElementHelpers { pub trait RawLayoutElementHelpers {
unsafe fn get_attr_for_layout<'a>(&'a self, namespace: &Namespace, name: &Atom) unsafe fn get_attr_for_layout<'a>(&'a self, namespace: &Namespace, name: &LocalName)
-> Option<&'a AttrValue>; -> Option<&'a AttrValue>;
unsafe fn get_attr_val_for_layout<'a>(&'a self, namespace: &Namespace, name: &Atom) unsafe fn get_attr_val_for_layout<'a>(&'a self, namespace: &Namespace, name: &LocalName)
-> Option<&'a str>; -> Option<&'a str>;
unsafe fn get_attr_vals_for_layout<'a>(&'a self, name: &Atom) -> Vec<&'a str>; unsafe fn get_attr_vals_for_layout<'a>(&'a self, name: &LocalName) -> Vec<&'a str>;
} }
#[inline] #[inline]
#[allow(unsafe_code)] #[allow(unsafe_code)]
pub unsafe fn get_attr_for_layout<'a>(elem: &'a Element, namespace: &Namespace, name: &Atom) pub unsafe fn get_attr_for_layout<'a>(elem: &'a Element, namespace: &Namespace, name: &LocalName)
-> Option<LayoutJS<Attr>> { -> Option<LayoutJS<Attr>> {
// cast to point to T in RefCell<T> directly // cast to point to T in RefCell<T> directly
let attrs = elem.attrs.borrow_for_layout(); let attrs = elem.attrs.borrow_for_layout();
@ -255,14 +256,14 @@ pub unsafe fn get_attr_for_layout<'a>(elem: &'a Element, namespace: &Namespace,
#[allow(unsafe_code)] #[allow(unsafe_code)]
impl RawLayoutElementHelpers for Element { impl RawLayoutElementHelpers for Element {
#[inline] #[inline]
unsafe fn get_attr_for_layout<'a>(&'a self, namespace: &Namespace, name: &Atom) unsafe fn get_attr_for_layout<'a>(&'a self, namespace: &Namespace, name: &LocalName)
-> Option<&'a AttrValue> { -> Option<&'a AttrValue> {
get_attr_for_layout(self, namespace, name).map(|attr| { get_attr_for_layout(self, namespace, name).map(|attr| {
attr.value_forever() attr.value_forever()
}) })
} }
unsafe fn get_attr_val_for_layout<'a>(&'a self, namespace: &Namespace, name: &Atom) unsafe fn get_attr_val_for_layout<'a>(&'a self, namespace: &Namespace, name: &LocalName)
-> Option<&'a str> { -> Option<&'a str> {
get_attr_for_layout(self, namespace, name).map(|attr| { get_attr_for_layout(self, namespace, name).map(|attr| {
attr.value_ref_forever() attr.value_ref_forever()
@ -270,7 +271,7 @@ impl RawLayoutElementHelpers for Element {
} }
#[inline] #[inline]
unsafe fn get_attr_vals_for_layout<'a>(&'a self, name: &Atom) -> Vec<&'a str> { unsafe fn get_attr_vals_for_layout<'a>(&'a self, name: &LocalName) -> Vec<&'a str> {
let attrs = self.attrs.borrow_for_layout(); let attrs = self.attrs.borrow_for_layout();
attrs.iter().filter_map(|attr| { attrs.iter().filter_map(|attr| {
let attr = attr.to_layout(); let attr = attr.to_layout();
@ -298,7 +299,7 @@ pub trait LayoutElementHelpers {
unsafe fn html_element_in_html_document_for_layout(&self) -> bool; unsafe fn html_element_in_html_document_for_layout(&self) -> bool;
fn id_attribute(&self) -> *const Option<Atom>; fn id_attribute(&self) -> *const Option<Atom>;
fn style_attribute(&self) -> *const Option<Arc<RwLock<PropertyDeclarationBlock>>>; fn style_attribute(&self) -> *const Option<Arc<RwLock<PropertyDeclarationBlock>>>;
fn local_name(&self) -> &Atom; fn local_name(&self) -> &LocalName;
fn namespace(&self) -> &Namespace; fn namespace(&self) -> &Namespace;
fn get_checked_state_for_layout(&self) -> bool; fn get_checked_state_for_layout(&self) -> bool;
fn get_indeterminate_state_for_layout(&self) -> bool; fn get_indeterminate_state_for_layout(&self) -> bool;
@ -310,7 +311,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
#[allow(unsafe_code)] #[allow(unsafe_code)]
#[inline] #[inline]
unsafe fn has_class_for_layout(&self, name: &Atom) -> bool { unsafe fn has_class_for_layout(&self, name: &Atom) -> bool {
get_attr_for_layout(&*self.unsafe_get(), &ns!(), &atom!("class")).map_or(false, |attr| { get_attr_for_layout(&*self.unsafe_get(), &ns!(), &local_name!("class")).map_or(false, |attr| {
attr.value_tokens_forever().unwrap().iter().any(|atom| atom == name) attr.value_tokens_forever().unwrap().iter().any(|atom| atom == name)
}) })
} }
@ -318,7 +319,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
#[allow(unsafe_code)] #[allow(unsafe_code)]
#[inline] #[inline]
unsafe fn get_classes_for_layout(&self) -> Option<&'static [Atom]> { unsafe fn get_classes_for_layout(&self) -> Option<&'static [Atom]> {
get_attr_for_layout(&*self.unsafe_get(), &ns!(), &atom!("class")) get_attr_for_layout(&*self.unsafe_get(), &ns!(), &local_name!("class"))
.map(|attr| attr.value_tokens_forever().unwrap()) .map(|attr| attr.value_tokens_forever().unwrap())
} }
@ -440,7 +441,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
let size = if let Some(this) = self.downcast::<HTMLInputElement>() { let size = if let Some(this) = self.downcast::<HTMLInputElement>() {
// FIXME(pcwalton): More use of atoms, please! // FIXME(pcwalton): More use of atoms, please!
match (*self.unsafe_get()).get_attr_val_for_layout(&ns!(), &atom!("type")) { match (*self.unsafe_get()).get_attr_val_for_layout(&ns!(), &local_name!("type")) {
// Not text entry widget // Not text entry widget
Some("hidden") | Some("date") | Some("month") | Some("week") | Some("hidden") | Some("date") | Some("month") | Some("week") |
Some("time") | Some("datetime-local") | Some("number") | Some("range") | Some("time") | Some("datetime-local") | Some("number") | Some("range") |
@ -622,7 +623,7 @@ impl LayoutElementHelpers for LayoutJS<Element> {
} }
#[allow(unsafe_code)] #[allow(unsafe_code)]
fn local_name(&self) -> &Atom { fn local_name(&self) -> &LocalName {
unsafe { unsafe {
&(*self.unsafe_get()).local_name &(*self.unsafe_get()).local_name
} }
@ -681,15 +682,15 @@ impl Element {
self.namespace == ns!(html) && self.upcast::<Node>().is_in_html_doc() self.namespace == ns!(html) && self.upcast::<Node>().is_in_html_doc()
} }
pub fn local_name(&self) -> &Atom { pub fn local_name(&self) -> &LocalName {
&self.local_name &self.local_name
} }
pub fn parsed_name(&self, mut name: DOMString) -> Atom { pub fn parsed_name(&self, mut name: DOMString) -> LocalName {
if self.html_element_in_html_document() { if self.html_element_in_html_document() {
name.make_ascii_lowercase(); name.make_ascii_lowercase();
} }
Atom::from(name) LocalName::from(name)
} }
pub fn namespace(&self) -> &Namespace { pub fn namespace(&self) -> &Namespace {
@ -722,10 +723,14 @@ impl Element {
/* List of void elements from /* List of void elements from
https://html.spec.whatwg.org/multipage/#html-fragment-serialisation-algorithm */ https://html.spec.whatwg.org/multipage/#html-fragment-serialisation-algorithm */
atom!("area") | atom!("base") | atom!("basefont") | atom!("bgsound") | atom!("br") | local_name!("area") | local_name!("base") | local_name!("basefont") |
atom!("col") | atom!("embed") | atom!("frame") | atom!("hr") | atom!("img") | local_name!("bgsound") | local_name!("br") |
atom!("input") | atom!("keygen") | atom!("link") | atom!("menuitem") | atom!("meta") | local_name!("col") | local_name!("embed") | local_name!("frame") |
atom!("param") | atom!("source") | atom!("track") | atom!("wbr") => true, local_name!("hr") | local_name!("img") |
local_name!("input") | local_name!("keygen") | local_name!("link") |
local_name!("menuitem") | local_name!("meta") |
local_name!("param") | local_name!("source") | local_name!("track") |
local_name!("wbr") => true,
_ => false _ => false
} }
} }
@ -735,7 +740,7 @@ impl Element {
pub fn set_style_attr(&self, new_value: String) { pub fn set_style_attr(&self, new_value: String) {
let mut new_style = AttrValue::String(new_value); let mut new_style = AttrValue::String(new_value);
if let Some(style_attr) = self.attrs.borrow().iter().find(|a| a.name() == &atom!("style")) { if let Some(style_attr) = self.attrs.borrow().iter().find(|a| a.name() == &local_name!("style")) {
style_attr.swap_value(&mut new_style); style_attr.swap_value(&mut new_style);
return; return;
} }
@ -744,11 +749,11 @@ impl Element {
// in order to avoid triggering mutation events // in order to avoid triggering mutation events
let window = window_from_node(self); let window = window_from_node(self);
let attr = Attr::new(&window, let attr = Attr::new(&window,
atom!("style"), local_name!("style"),
new_style, new_style,
atom!("style"), local_name!("style"),
ns!(), ns!(),
Some(atom!("style")), None,
Some(self)); Some(self));
assert!(attr.GetOwnerElement().r() == Some(self)); assert!(attr.GetOwnerElement().r() == Some(self));
@ -798,8 +803,8 @@ impl Element {
// Step 2. // Step 2.
for attr in element.attrs.borrow().iter() { for attr in element.attrs.borrow().iter() {
if *attr.prefix() == Some(atom!("xmlns")) && if *attr.prefix() == Some(namespace_prefix!("xmlns")) &&
**attr.value() == *namespace.0 { **attr.value() == *namespace {
return Some(attr.LocalName()); return Some(attr.LocalName());
} }
} }
@ -856,11 +861,11 @@ impl Element {
impl Element { impl Element {
pub fn push_new_attribute(&self, pub fn push_new_attribute(&self,
local_name: Atom, local_name: LocalName,
value: AttrValue, value: AttrValue,
name: Atom, name: LocalName,
namespace: Namespace, namespace: Namespace,
prefix: Option<Atom>) { prefix: Option<Prefix>) {
let window = window_from_node(self); let window = window_from_node(self);
let attr = Attr::new(&window, let attr = Attr::new(&window,
local_name, local_name,
@ -881,7 +886,7 @@ impl Element {
} }
} }
pub fn get_attribute(&self, namespace: &Namespace, local_name: &Atom) -> Option<Root<Attr>> { pub fn get_attribute(&self, namespace: &Namespace, local_name: &LocalName) -> Option<Root<Attr>> {
self.attrs self.attrs
.borrow() .borrow()
.iter() .iter()
@ -898,7 +903,7 @@ impl Element {
pub fn set_attribute_from_parser(&self, pub fn set_attribute_from_parser(&self,
qname: QualName, qname: QualName,
value: DOMString, value: DOMString,
prefix: Option<Atom>) { prefix: Option<Prefix>) {
// Don't set if the attribute already exists, so we can handle add_attrs_if_missing // Don't set if the attribute already exists, so we can handle add_attrs_if_missing
if self.attrs if self.attrs
.borrow() .borrow()
@ -911,14 +916,14 @@ impl Element {
None => qname.local.clone(), None => qname.local.clone(),
Some(ref prefix) => { Some(ref prefix) => {
let name = format!("{}:{}", &**prefix, &*qname.local); let name = format!("{}:{}", &**prefix, &*qname.local);
Atom::from(name) LocalName::from(name)
}, },
}; };
let value = self.parse_attribute(&qname.ns, &qname.local, value); let value = self.parse_attribute(&qname.ns, &qname.local, value);
self.push_new_attribute(qname.local, value, name, qname.ns, prefix); self.push_new_attribute(qname.local, value, name, qname.ns, prefix);
} }
pub fn set_attribute(&self, name: &Atom, value: AttrValue) { pub fn set_attribute(&self, name: &LocalName, value: AttrValue) {
assert!(name == &name.to_ascii_lowercase()); assert!(name == &name.to_ascii_lowercase());
assert!(!name.contains(":")); assert!(!name.contains(":"));
@ -938,7 +943,7 @@ impl Element {
} }
// Steps 2-5. // Steps 2-5.
let name = Atom::from(name); let name = LocalName::from(name);
let value = self.parse_attribute(&ns!(), &name, value); let value = self.parse_attribute(&ns!(), &name, value);
self.set_first_matching_attribute(name.clone(), self.set_first_matching_attribute(name.clone(),
value, value,
@ -952,11 +957,11 @@ impl Element {
} }
fn set_first_matching_attribute<F>(&self, fn set_first_matching_attribute<F>(&self,
local_name: Atom, local_name: LocalName,
value: AttrValue, value: AttrValue,
name: Atom, name: LocalName,
namespace: Namespace, namespace: Namespace,
prefix: Option<Atom>, prefix: Option<Prefix>,
find: F) find: F)
where F: Fn(&Attr) -> bool where F: Fn(&Attr) -> bool
{ {
@ -974,7 +979,7 @@ impl Element {
pub fn parse_attribute(&self, pub fn parse_attribute(&self,
namespace: &Namespace, namespace: &Namespace,
local_name: &Atom, local_name: &LocalName,
value: DOMString) value: DOMString)
-> AttrValue { -> AttrValue {
if *namespace == ns!() { if *namespace == ns!() {
@ -984,13 +989,13 @@ impl Element {
} }
} }
pub fn remove_attribute(&self, namespace: &Namespace, local_name: &Atom) -> Option<Root<Attr>> { pub fn remove_attribute(&self, namespace: &Namespace, local_name: &LocalName) -> Option<Root<Attr>> {
self.remove_first_matching_attribute(|attr| { self.remove_first_matching_attribute(|attr| {
attr.namespace() == namespace && attr.local_name() == local_name attr.namespace() == namespace && attr.local_name() == local_name
}) })
} }
pub fn remove_attribute_by_name(&self, name: &Atom) -> Option<Root<Attr>> { pub fn remove_attribute_by_name(&self, name: &LocalName) -> Option<Root<Attr>> {
self.remove_first_matching_attribute(|attr| attr.name() == name) self.remove_first_matching_attribute(|attr| attr.name() == name)
} }
@ -1019,17 +1024,17 @@ impl Element {
Quirks => lhs.eq_ignore_ascii_case(&rhs), Quirks => lhs.eq_ignore_ascii_case(&rhs),
} }
}; };
self.get_attribute(&ns!(), &atom!("class")) self.get_attribute(&ns!(), &local_name!("class"))
.map_or(false, |attr| attr.value().as_tokens().iter().any(|atom| is_equal(name, atom))) .map_or(false, |attr| attr.value().as_tokens().iter().any(|atom| is_equal(name, atom)))
} }
pub fn set_atomic_attribute(&self, local_name: &Atom, value: DOMString) { pub fn set_atomic_attribute(&self, local_name: &LocalName, value: DOMString) {
assert!(*local_name == local_name.to_ascii_lowercase()); assert!(*local_name == local_name.to_ascii_lowercase());
let value = AttrValue::from_atomic(value.into()); let value = AttrValue::from_atomic(value.into());
self.set_attribute(local_name, value); self.set_attribute(local_name, value);
} }
pub fn has_attribute(&self, local_name: &Atom) -> bool { pub fn has_attribute(&self, local_name: &LocalName) -> bool {
assert!(local_name.bytes().all(|b| b.to_ascii_lowercase() == b)); assert!(local_name.bytes().all(|b| b.to_ascii_lowercase() == b));
self.attrs self.attrs
.borrow() .borrow()
@ -1037,7 +1042,7 @@ impl Element {
.any(|attr| attr.local_name() == local_name && attr.namespace() == &ns!()) .any(|attr| attr.local_name() == local_name && attr.namespace() == &ns!())
} }
pub fn set_bool_attribute(&self, local_name: &Atom, value: bool) { pub fn set_bool_attribute(&self, local_name: &LocalName, value: bool) {
if self.has_attribute(local_name) == value { if self.has_attribute(local_name) == value {
return; return;
} }
@ -1048,7 +1053,7 @@ impl Element {
} }
} }
pub fn get_url_attribute(&self, local_name: &Atom) -> DOMString { pub fn get_url_attribute(&self, local_name: &LocalName) -> DOMString {
assert!(*local_name == local_name.to_ascii_lowercase()); assert!(*local_name == local_name.to_ascii_lowercase());
if !self.has_attribute(local_name) { if !self.has_attribute(local_name) {
return DOMString::new(); return DOMString::new();
@ -1063,22 +1068,22 @@ impl Element {
Err(_) => DOMString::from(""), Err(_) => DOMString::from(""),
} }
} }
pub fn set_url_attribute(&self, local_name: &Atom, value: DOMString) { pub fn set_url_attribute(&self, local_name: &LocalName, value: DOMString) {
self.set_string_attribute(local_name, value); self.set_string_attribute(local_name, value);
} }
pub fn get_string_attribute(&self, local_name: &Atom) -> DOMString { pub fn get_string_attribute(&self, local_name: &LocalName) -> DOMString {
match self.get_attribute(&ns!(), local_name) { match self.get_attribute(&ns!(), local_name) {
Some(x) => x.Value(), Some(x) => x.Value(),
None => DOMString::new(), None => DOMString::new(),
} }
} }
pub fn set_string_attribute(&self, local_name: &Atom, value: DOMString) { pub fn set_string_attribute(&self, local_name: &LocalName, value: DOMString) {
assert!(*local_name == local_name.to_ascii_lowercase()); assert!(*local_name == local_name.to_ascii_lowercase());
self.set_attribute(local_name, AttrValue::String(value.into())); self.set_attribute(local_name, AttrValue::String(value.into()));
} }
pub fn get_tokenlist_attribute(&self, local_name: &Atom) -> Vec<Atom> { pub fn get_tokenlist_attribute(&self, local_name: &LocalName) -> Vec<Atom> {
self.get_attribute(&ns!(), local_name).map(|attr| { self.get_attribute(&ns!(), local_name).map(|attr| {
attr.value() attr.value()
.as_tokens() .as_tokens()
@ -1086,18 +1091,18 @@ impl Element {
}).unwrap_or(vec!()) }).unwrap_or(vec!())
} }
pub fn set_tokenlist_attribute(&self, local_name: &Atom, value: DOMString) { pub fn set_tokenlist_attribute(&self, local_name: &LocalName, value: DOMString) {
assert!(*local_name == local_name.to_ascii_lowercase()); assert!(*local_name == local_name.to_ascii_lowercase());
self.set_attribute(local_name, self.set_attribute(local_name,
AttrValue::from_serialized_tokenlist(value.into())); AttrValue::from_serialized_tokenlist(value.into()));
} }
pub fn set_atomic_tokenlist_attribute(&self, local_name: &Atom, tokens: Vec<Atom>) { pub fn set_atomic_tokenlist_attribute(&self, local_name: &LocalName, tokens: Vec<Atom>) {
assert!(*local_name == local_name.to_ascii_lowercase()); assert!(*local_name == local_name.to_ascii_lowercase());
self.set_attribute(local_name, AttrValue::from_atomic_tokens(tokens)); self.set_attribute(local_name, AttrValue::from_atomic_tokens(tokens));
} }
pub fn get_int_attribute(&self, local_name: &Atom, default: i32) -> i32 { pub fn get_int_attribute(&self, local_name: &LocalName, default: i32) -> i32 {
// TODO: Is this assert necessary? // TODO: Is this assert necessary?
assert!(local_name.chars().all(|ch| { assert!(local_name.chars().all(|ch| {
!ch.is_ascii() || ch.to_ascii_lowercase() == ch !ch.is_ascii() || ch.to_ascii_lowercase() == ch
@ -1116,12 +1121,12 @@ impl Element {
} }
} }
pub fn set_int_attribute(&self, local_name: &Atom, value: i32) { pub fn set_int_attribute(&self, local_name: &LocalName, value: i32) {
assert!(*local_name == local_name.to_ascii_lowercase()); assert!(*local_name == local_name.to_ascii_lowercase());
self.set_attribute(local_name, AttrValue::Int(value.to_string(), value)); self.set_attribute(local_name, AttrValue::Int(value.to_string(), value));
} }
pub fn get_uint_attribute(&self, local_name: &Atom, default: u32) -> u32 { pub fn get_uint_attribute(&self, local_name: &LocalName, default: u32) -> u32 {
assert!(local_name.chars().all(|ch| !ch.is_ascii() || ch.to_ascii_lowercase() == ch)); assert!(local_name.chars().all(|ch| !ch.is_ascii() || ch.to_ascii_lowercase() == ch));
let attribute = self.get_attribute(&ns!(), local_name); let attribute = self.get_attribute(&ns!(), local_name);
match attribute { match attribute {
@ -1134,7 +1139,7 @@ impl Element {
None => default, None => default,
} }
} }
pub fn set_uint_attribute(&self, local_name: &Atom, value: u32) { pub fn set_uint_attribute(&self, local_name: &LocalName, value: u32) {
assert!(*local_name == local_name.to_ascii_lowercase()); assert!(*local_name == local_name.to_ascii_lowercase());
self.set_attribute(local_name, AttrValue::UInt(value.to_string(), value)); self.set_attribute(local_name, AttrValue::UInt(value.to_string(), value));
} }
@ -1226,7 +1231,7 @@ impl ElementMethods for Element {
// https://dom.spec.whatwg.org/#dom-element-localname // https://dom.spec.whatwg.org/#dom-element-localname
fn LocalName(&self) -> DOMString { fn LocalName(&self) -> DOMString {
// FIXME(ajeffrey): Convert directly from Atom to DOMString // FIXME(ajeffrey): Convert directly from LocalName to DOMString
DOMString::from(&*self.local_name) DOMString::from(&*self.local_name)
} }
@ -1245,9 +1250,9 @@ impl ElementMethods for Element {
None => Cow::Borrowed(&*self.local_name) None => Cow::Borrowed(&*self.local_name)
}; };
if self.html_element_in_html_document() { if self.html_element_in_html_document() {
Atom::from(qualified_name.to_ascii_uppercase()) LocalName::from(qualified_name.to_ascii_uppercase())
} else { } else {
Atom::from(qualified_name) LocalName::from(qualified_name)
} }
}); });
DOMString::from(&*name) DOMString::from(&*name)
@ -1255,27 +1260,27 @@ impl ElementMethods for Element {
// https://dom.spec.whatwg.org/#dom-element-id // https://dom.spec.whatwg.org/#dom-element-id
fn Id(&self) -> DOMString { fn Id(&self) -> DOMString {
self.get_string_attribute(&atom!("id")) self.get_string_attribute(&local_name!("id"))
} }
// https://dom.spec.whatwg.org/#dom-element-id // https://dom.spec.whatwg.org/#dom-element-id
fn SetId(&self, id: DOMString) { fn SetId(&self, id: DOMString) {
self.set_atomic_attribute(&atom!("id"), id); self.set_atomic_attribute(&local_name!("id"), id);
} }
// https://dom.spec.whatwg.org/#dom-element-classname // https://dom.spec.whatwg.org/#dom-element-classname
fn ClassName(&self) -> DOMString { fn ClassName(&self) -> DOMString {
self.get_string_attribute(&atom!("class")) self.get_string_attribute(&local_name!("class"))
} }
// https://dom.spec.whatwg.org/#dom-element-classname // https://dom.spec.whatwg.org/#dom-element-classname
fn SetClassName(&self, class: DOMString) { fn SetClassName(&self, class: DOMString) {
self.set_tokenlist_attribute(&atom!("class"), class); self.set_tokenlist_attribute(&local_name!("class"), class);
} }
// https://dom.spec.whatwg.org/#dom-element-classlist // https://dom.spec.whatwg.org/#dom-element-classlist
fn ClassList(&self) -> Root<DOMTokenList> { fn ClassList(&self) -> Root<DOMTokenList> {
self.class_list.or_init(|| DOMTokenList::new(self, &atom!("class"))) self.class_list.or_init(|| DOMTokenList::new(self, &local_name!("class")))
} }
// https://dom.spec.whatwg.org/#dom-element-attributes // https://dom.spec.whatwg.org/#dom-element-attributes
@ -1319,7 +1324,7 @@ impl ElementMethods for Element {
local_name: DOMString) local_name: DOMString)
-> Option<Root<Attr>> { -> Option<Root<Attr>> {
let namespace = &namespace_from_domstring(namespace); let namespace = &namespace_from_domstring(namespace);
self.get_attribute(namespace, &Atom::from(local_name)) self.get_attribute(namespace, &LocalName::from(local_name))
} }
// https://dom.spec.whatwg.org/#dom-element-setattribute // https://dom.spec.whatwg.org/#dom-element-setattribute
@ -1347,7 +1352,7 @@ impl ElementMethods for Element {
value: DOMString) -> ErrorResult { value: DOMString) -> ErrorResult {
let (namespace, prefix, local_name) = let (namespace, prefix, local_name) =
try!(validate_and_extract(namespace, &qualified_name)); try!(validate_and_extract(namespace, &qualified_name));
let qualified_name = Atom::from(qualified_name); let qualified_name = LocalName::from(qualified_name);
let value = self.parse_attribute(&namespace, &local_name, value); let value = self.parse_attribute(&namespace, &local_name, value);
self.set_first_matching_attribute( self.set_first_matching_attribute(
local_name.clone(), value, qualified_name, namespace.clone(), prefix, local_name.clone(), value, qualified_name, namespace.clone(), prefix,
@ -1413,7 +1418,7 @@ impl ElementMethods for Element {
// https://dom.spec.whatwg.org/#dom-element-removeattributens // https://dom.spec.whatwg.org/#dom-element-removeattributens
fn RemoveAttributeNS(&self, namespace: Option<DOMString>, local_name: DOMString) { fn RemoveAttributeNS(&self, namespace: Option<DOMString>, local_name: DOMString) {
let namespace = namespace_from_domstring(namespace); let namespace = namespace_from_domstring(namespace);
let local_name = Atom::from(local_name); let local_name = LocalName::from(local_name);
self.remove_attribute(&namespace, &local_name); self.remove_attribute(&namespace, &local_name);
} }
@ -1781,7 +1786,7 @@ impl ElementMethods for Element {
// Step 4. // Step 4.
NodeTypeId::DocumentFragment => { NodeTypeId::DocumentFragment => {
let body_elem = Element::create(QualName::new(ns!(html), atom!("body")), let body_elem = Element::create(QualName::new(ns!(html), local_name!("body")),
None, &context_document, None, &context_document,
ElementCreator::ScriptCreated); ElementCreator::ScriptCreated);
Root::upcast(body_elem) Root::upcast(body_elem)
@ -1944,9 +1949,9 @@ impl ElementMethods for Element {
// Step 2. // Step 2.
let context = match context.downcast::<Element>() { let context = match context.downcast::<Element>() {
Some(elem) if elem.local_name() != &atom!("html") || Some(elem) if elem.local_name() != &local_name!("html") ||
!elem.html_element_in_html_document() => Root::from_ref(elem), !elem.html_element_in_html_document() => Root::from_ref(elem),
_ => Root::upcast(HTMLBodyElement::new(atom!("body"), None, &*context.owner_doc())), _ => Root::upcast(HTMLBodyElement::new(local_name!("body"), None, &*context.owner_doc())),
}; };
// Step 3. // Step 3.
@ -1978,8 +1983,8 @@ impl ElementMethods for Element {
} }
} }
pub fn fragment_affecting_attributes() -> [Atom; 3] { pub fn fragment_affecting_attributes() -> [LocalName; 3] {
[atom!("width"), atom!("height"), atom!("src")] [local_name!("width"), local_name!("height"), local_name!("src")]
} }
impl VirtualMethods for Element { impl VirtualMethods for Element {
@ -1992,7 +1997,7 @@ impl VirtualMethods for Element {
let node = self.upcast::<Node>(); let node = self.upcast::<Node>();
let doc = node.owner_doc(); let doc = node.owner_doc();
match attr.local_name() { match attr.local_name() {
&atom!("style") => { &local_name!("style") => {
// Modifying the `style` attribute might change style. // Modifying the `style` attribute might change style.
*self.style_attribute.borrow_mut() = *self.style_attribute.borrow_mut() =
mutation.new_value(attr).map(|value| { mutation.new_value(attr).map(|value| {
@ -2007,7 +2012,7 @@ impl VirtualMethods for Element {
node.dirty(NodeDamage::NodeStyleDamaged); node.dirty(NodeDamage::NodeStyleDamaged);
} }
}, },
&atom!("id") => { &local_name!("id") => {
*self.id_attribute.borrow_mut() = *self.id_attribute.borrow_mut() =
mutation.new_value(attr).and_then(|value| { mutation.new_value(attr).and_then(|value| {
let value = value.as_atom(); let value = value.as_atom();
@ -2039,7 +2044,7 @@ impl VirtualMethods for Element {
}, },
_ if attr.namespace() == &ns!() => { _ if attr.namespace() == &ns!() => {
if fragment_affecting_attributes().iter().any(|a| a == attr.local_name()) || if fragment_affecting_attributes().iter().any(|a| a == attr.local_name()) ||
common_style_affecting_attributes().iter().any(|a| &a.atom == attr.local_name()) || common_style_affecting_attributes().iter().any(|a| &a.attr_name == attr.local_name()) ||
rare_style_affecting_attributes().iter().any(|a| a == attr.local_name()) rare_style_affecting_attributes().iter().any(|a| a == attr.local_name())
{ {
node.dirty(NodeDamage::OtherNodeDamage); node.dirty(NodeDamage::OtherNodeDamage);
@ -2054,10 +2059,10 @@ impl VirtualMethods for Element {
node.rev_version(); node.rev_version();
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("id") => AttrValue::from_atomic(value.into()), &local_name!("id") => AttrValue::from_atomic(value.into()),
&atom!("class") => AttrValue::from_serialized_tokenlist(value.into()), &local_name!("class") => AttrValue::from_serialized_tokenlist(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }
@ -2191,7 +2196,7 @@ impl<'a> ::selectors::Element for Root<Element> {
}) })
} }
fn get_local_name(&self) -> &Atom { fn get_local_name(&self) -> &LocalName {
self.local_name() self.local_name()
} }
@ -2246,7 +2251,7 @@ impl<'a> ::selectors::Element for Root<Element> {
fn each_class<F>(&self, mut callback: F) fn each_class<F>(&self, mut callback: F)
where F: FnMut(&Atom) where F: FnMut(&Atom)
{ {
if let Some(ref attr) = self.get_attribute(&ns!(), &atom!("class")) { if let Some(ref attr) = self.get_attribute(&ns!(), &local_name!("class")) {
let tokens = attr.value(); let tokens = attr.value();
let tokens = tokens.as_tokens(); let tokens = tokens.as_tokens();
for token in tokens { for token in tokens {
@ -2357,7 +2362,7 @@ impl Element {
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)) | NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)) |
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAreaElement)) | NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAreaElement)) |
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)) => { NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)) => {
self.has_attribute(&atom!("href")) self.has_attribute(&local_name!("href"))
}, },
_ => false, _ => false,
} }
@ -2551,7 +2556,7 @@ impl Element {
} }
pub fn check_disabled_attribute(&self) { pub fn check_disabled_attribute(&self) {
let has_disabled_attrib = self.has_attribute(&atom!("disabled")); let has_disabled_attrib = self.has_attribute(&local_name!("disabled"));
self.set_disabled_state(has_disabled_attrib); self.set_disabled_state(has_disabled_attrib);
self.set_enabled_state(!has_disabled_attrib); self.set_enabled_state(!has_disabled_attrib);
} }
@ -2600,7 +2605,7 @@ impl AtomicElementFlags {
/// owner changes. /// owner changes.
#[derive(JSTraceable, HeapSizeOf)] #[derive(JSTraceable, HeapSizeOf)]
struct TagName { struct TagName {
ptr: DOMRefCell<Option<Atom>>, ptr: DOMRefCell<Option<LocalName>>,
} }
impl TagName { impl TagName {
@ -2610,8 +2615,8 @@ impl TagName {
/// Retrieve a copy of the current inner value. If it is `None`, it is /// Retrieve a copy of the current inner value. If it is `None`, it is
/// initialized with the result of `cb` first. /// initialized with the result of `cb` first.
fn or_init<F>(&self, cb: F) -> Atom fn or_init<F>(&self, cb: F) -> LocalName
where F: FnOnce() -> Atom where F: FnOnce() -> LocalName
{ {
match &mut *self.ptr.borrow_mut() { match &mut *self.ptr.borrow_mut() {
&mut Some(ref name) => name.clone(), &mut Some(ref name) => name.clone(),

2
components/script/dom/errorevent.rs
View file

@ -15,8 +15,8 @@ use dom::event::{Event, EventBubbles, EventCancelable};
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use js::jsapi::{HandleValue, JSContext}; use js::jsapi::{HandleValue, JSContext};
use js::jsval::JSVal; use js::jsval::JSVal;
use servo_atoms::Atom;
use std::cell::Cell; use std::cell::Cell;
use string_cache::Atom;
#[dom_struct] #[dom_struct]
pub struct ErrorEvent { pub struct ErrorEvent {

2
components/script/dom/event.rs
View file

@ -14,9 +14,9 @@ use dom::eventdispatcher::EventStatus;
use dom::eventtarget::EventTarget; use dom::eventtarget::EventTarget;
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use script_thread::Runnable; use script_thread::Runnable;
use servo_atoms::Atom;
use std::cell::Cell; use std::cell::Cell;
use std::default::Default; use std::default::Default;
use string_cache::Atom;
use time; use time;
#[derive(JSTraceable, Copy, Clone, Debug, PartialEq, Eq)] #[derive(JSTraceable, Copy, Clone, Debug, PartialEq, Eq)]

2
components/script/dom/eventtarget.rs
View file

@ -32,6 +32,7 @@ use heapsize::HeapSizeOf;
use js::jsapi::{CompileFunction, JS_GetFunctionObject, JSAutoCompartment}; use js::jsapi::{CompileFunction, JS_GetFunctionObject, JSAutoCompartment};
use js::rust::{AutoObjectVectorWrapper, CompileOptionsWrapper}; use js::rust::{AutoObjectVectorWrapper, CompileOptionsWrapper};
use libc::{c_char, size_t}; use libc::{c_char, size_t};
use servo_atoms::Atom;
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::default::Default; use std::default::Default;
@ -41,7 +42,6 @@ use std::mem;
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
use std::ptr; use std::ptr;
use std::rc::Rc; use std::rc::Rc;
use string_cache::Atom;
use url::Url; use url::Url;
#[derive(PartialEq, Clone, JSTraceable)] #[derive(PartialEq, Clone, JSTraceable)]

2
components/script/dom/extendableevent.rs
View file

@ -12,7 +12,7 @@ use dom::bindings::str::DOMString;
use dom::event::Event; use dom::event::Event;
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use js::jsapi::{HandleValue, JSContext}; use js::jsapi::{HandleValue, JSContext};
use string_cache::Atom; use servo_atoms::Atom;
// https://w3c.github.io/ServiceWorker/#extendable-event // https://w3c.github.io/ServiceWorker/#extendable-event
#[dom_struct] #[dom_struct]

2
components/script/dom/extendablemessageevent.rs
View file

@ -15,8 +15,8 @@ use dom::extendableevent::ExtendableEvent;
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use js::jsapi::{HandleValue, Heap, JSContext}; use js::jsapi::{HandleValue, Heap, JSContext};
use js::jsval::JSVal; use js::jsval::JSVal;
use servo_atoms::Atom;
use std::default::Default; use std::default::Default;
use string_cache::Atom;
#[dom_struct] #[dom_struct]
pub struct ExtendableMessageEvent { pub struct ExtendableMessageEvent {

2
components/script/dom/filereader.rs
View file

@ -30,10 +30,10 @@ use js::jsval::{self, JSVal};
use js::typedarray::Uint8Array; use js::typedarray::Uint8Array;
use rustc_serialize::base64::{CharacterSet, Config, Newline, ToBase64}; use rustc_serialize::base64::{CharacterSet, Config, Newline, ToBase64};
use script_thread::RunnableWrapper; use script_thread::RunnableWrapper;
use servo_atoms::Atom;
use std::cell::Cell; use std::cell::Cell;
use std::ptr; use std::ptr;
use std::sync::Arc; use std::sync::Arc;
use string_cache::Atom;
use task_source::TaskSource; use task_source::TaskSource;
use task_source::file_reading::{FileReadingTaskSource, FileReadingRunnable, FileReadingTask}; use task_source::file_reading::{FileReadingTaskSource, FileReadingRunnable, FileReadingTask};
use util::thread::spawn_named; use util::thread::spawn_named;

24
components/script/dom/formdata.rs
View file

@ -15,24 +15,24 @@ use dom::blob::{Blob, BlobImpl};
use dom::file::File; use dom::file::File;
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use dom::htmlformelement::{HTMLFormElement, FormDatumValue, FormDatum}; use dom::htmlformelement::{HTMLFormElement, FormDatumValue, FormDatum};
use html5ever_atoms::LocalName;
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::iter; use std::iter;
use string_cache::Atom;
#[dom_struct] #[dom_struct]
pub struct FormData { pub struct FormData {
reflector_: Reflector, reflector_: Reflector,
data: DOMRefCell<HashMap<Atom, Vec<FormDatum>>>, data: DOMRefCell<HashMap<LocalName, Vec<FormDatum>>>,
} }
impl FormData { impl FormData {
fn new_inherited(opt_form: Option<&HTMLFormElement>) -> FormData { fn new_inherited(opt_form: Option<&HTMLFormElement>) -> FormData {
let mut hashmap: HashMap<Atom, Vec<FormDatum>> = HashMap::new(); let mut hashmap: HashMap<LocalName, Vec<FormDatum>> = HashMap::new();
if let Some(form) = opt_form { if let Some(form) = opt_form {
for datum in form.get_form_dataset(None) { for datum in form.get_form_dataset(None) {
match hashmap.entry(Atom::from(datum.name.as_ref())) { match hashmap.entry(LocalName::from(datum.name.as_ref())) {
Occupied(entry) => entry.into_mut().push(datum), Occupied(entry) => entry.into_mut().push(datum),
Vacant(entry) => { entry.insert(vec!(datum)); } Vacant(entry) => { entry.insert(vec!(datum)); }
} }
@ -66,7 +66,7 @@ impl FormDataMethods for FormData {
}; };
let mut data = self.data.borrow_mut(); let mut data = self.data.borrow_mut();
match data.entry(Atom::from(name.0)) { match data.entry(LocalName::from(name.0)) {
Occupied(entry) => entry.into_mut().push(datum), Occupied(entry) => entry.into_mut().push(datum),
Vacant(entry) => { entry.insert(vec!(datum)); } Vacant(entry) => { entry.insert(vec!(datum)); }
} }
@ -83,7 +83,7 @@ impl FormDataMethods for FormData {
let mut data = self.data.borrow_mut(); let mut data = self.data.borrow_mut();
match data.entry(Atom::from(name.0)) { match data.entry(LocalName::from(name.0)) {
Occupied(entry) => entry.into_mut().push(datum), Occupied(entry) => entry.into_mut().push(datum),
Vacant(entry) => { entry.insert(vec!(datum)); }, Vacant(entry) => { entry.insert(vec!(datum)); },
} }
@ -91,13 +91,13 @@ impl FormDataMethods for FormData {
// https://xhr.spec.whatwg.org/#dom-formdata-delete // https://xhr.spec.whatwg.org/#dom-formdata-delete
fn Delete(&self, name: USVString) { fn Delete(&self, name: USVString) {
self.data.borrow_mut().remove(&Atom::from(name.0)); self.data.borrow_mut().remove(&LocalName::from(name.0));
} }
// https://xhr.spec.whatwg.org/#dom-formdata-get // https://xhr.spec.whatwg.org/#dom-formdata-get
fn Get(&self, name: USVString) -> Option<FileOrUSVString> { fn Get(&self, name: USVString) -> Option<FileOrUSVString> {
self.data.borrow() self.data.borrow()
.get(&Atom::from(name.0)) .get(&LocalName::from(name.0))
.map(|entry| match entry[0].value { .map(|entry| match entry[0].value {
FormDatumValue::String(ref s) => FileOrUSVString::USVString(USVString(s.to_string())), FormDatumValue::String(ref s) => FileOrUSVString::USVString(USVString(s.to_string())),
FormDatumValue::File(ref b) => FileOrUSVString::File(Root::from_ref(&*b)), FormDatumValue::File(ref b) => FileOrUSVString::File(Root::from_ref(&*b)),
@ -107,7 +107,7 @@ impl FormDataMethods for FormData {
// https://xhr.spec.whatwg.org/#dom-formdata-getall // https://xhr.spec.whatwg.org/#dom-formdata-getall
fn GetAll(&self, name: USVString) -> Vec<FileOrUSVString> { fn GetAll(&self, name: USVString) -> Vec<FileOrUSVString> {
self.data.borrow() self.data.borrow()
.get(&Atom::from(name.0)) .get(&LocalName::from(name.0))
.map_or(vec![], |data| .map_or(vec![], |data|
data.iter().map(|item| match item.value { data.iter().map(|item| match item.value {
FormDatumValue::String(ref s) => FileOrUSVString::USVString(USVString(s.to_string())), FormDatumValue::String(ref s) => FileOrUSVString::USVString(USVString(s.to_string())),
@ -118,12 +118,12 @@ impl FormDataMethods for FormData {
// https://xhr.spec.whatwg.org/#dom-formdata-has // https://xhr.spec.whatwg.org/#dom-formdata-has
fn Has(&self, name: USVString) -> bool { fn Has(&self, name: USVString) -> bool {
self.data.borrow().contains_key(&Atom::from(name.0)) self.data.borrow().contains_key(&LocalName::from(name.0))
} }
// https://xhr.spec.whatwg.org/#dom-formdata-set // https://xhr.spec.whatwg.org/#dom-formdata-set
fn Set(&self, name: USVString, str_value: USVString) { fn Set(&self, name: USVString, str_value: USVString) {
self.data.borrow_mut().insert(Atom::from(name.0.clone()), vec![FormDatum { self.data.borrow_mut().insert(LocalName::from(name.0.clone()), vec![FormDatum {
ty: DOMString::from("string"), ty: DOMString::from("string"),
name: DOMString::from(name.0), name: DOMString::from(name.0),
value: FormDatumValue::String(DOMString::from(str_value.0)), value: FormDatumValue::String(DOMString::from(str_value.0)),
@ -133,7 +133,7 @@ impl FormDataMethods for FormData {
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
// https://xhr.spec.whatwg.org/#dom-formdata-set // https://xhr.spec.whatwg.org/#dom-formdata-set
fn Set_(&self, name: USVString, blob: &Blob, filename: Option<USVString>) { fn Set_(&self, name: USVString, blob: &Blob, filename: Option<USVString>) {
self.data.borrow_mut().insert(Atom::from(name.0.clone()), vec![FormDatum { self.data.borrow_mut().insert(LocalName::from(name.0.clone()), vec![FormDatum {
ty: DOMString::from("file"), ty: DOMString::from("file"),
name: DOMString::from(name.0), name: DOMString::from(name.0),
value: FormDatumValue::File(Root::from_ref(&*self.get_file(blob, filename))), value: FormDatumValue::File(Root::from_ref(&*self.get_file(blob, filename))),

2
components/script/dom/hashchangeevent.rs
View file

@ -12,7 +12,7 @@ use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::{DOMString, USVString}; use dom::bindings::str::{DOMString, USVString};
use dom::event::Event; use dom::event::Event;
use dom::globalscope::GlobalScope; use dom::globalscope::GlobalScope;
use string_cache::Atom; use servo_atoms::Atom;
// https://html.spec.whatwg.org/multipage/#hashchangeevent // https://html.spec.whatwg.org/multipage/#hashchangeevent
#[dom_struct] #[dom_struct]

28
components/script/dom/htmlanchorelement.rs
View file

@ -24,11 +24,11 @@ use dom::mouseevent::MouseEvent;
use dom::node::{Node, document_from_node, window_from_node}; use dom::node::{Node, document_from_node, window_from_node};
use dom::urlhelper::UrlHelper; use dom::urlhelper::UrlHelper;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use msg::constellation_msg::ReferrerPolicy; use msg::constellation_msg::ReferrerPolicy;
use num_traits::ToPrimitive; use num_traits::ToPrimitive;
use script_traits::MozBrowserEvent; use script_traits::MozBrowserEvent;
use std::default::Default; use std::default::Default;
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
use url::Url; use url::Url;
use util::prefs::PREFS; use util::prefs::PREFS;
@ -41,7 +41,7 @@ pub struct HTMLAnchorElement {
} }
impl HTMLAnchorElement { impl HTMLAnchorElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLAnchorElement { document: &Document) -> HTMLAnchorElement {
HTMLAnchorElement { HTMLAnchorElement {
@ -53,7 +53,7 @@ impl HTMLAnchorElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLAnchorElement> { document: &Document) -> Root<HTMLAnchorElement> {
Node::reflect_node(box HTMLAnchorElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLAnchorElement::new_inherited(local_name, prefix, document),
@ -63,7 +63,7 @@ impl HTMLAnchorElement {
// https://html.spec.whatwg.org/multipage/#concept-hyperlink-url-set // https://html.spec.whatwg.org/multipage/#concept-hyperlink-url-set
fn set_url(&self) { fn set_url(&self) {
let attribute = self.upcast::<Element>().get_attribute(&ns!(), &atom!("href")); let attribute = self.upcast::<Element>().get_attribute(&ns!(), &local_name!("href"));
*self.url.borrow_mut() = attribute.and_then(|attribute| { *self.url.borrow_mut() = attribute.and_then(|attribute| {
let document = document_from_node(self); let document = document_from_node(self);
document.base_url().join(&attribute.value()).ok() document.base_url().join(&attribute.value()).ok()
@ -84,7 +84,7 @@ impl HTMLAnchorElement {
// https://html.spec.whatwg.org/multipage/#update-href // https://html.spec.whatwg.org/multipage/#update-href
fn update_href(&self, url: DOMString) { fn update_href(&self, url: DOMString) {
self.upcast::<Element>().set_string_attribute(&atom!("href"), url); self.upcast::<Element>().set_string_attribute(&local_name!("href"), url);
} }
} }
@ -93,9 +93,9 @@ impl VirtualMethods for HTMLAnchorElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("rel") => AttrValue::from_serialized_tokenlist(value.into()), &local_name!("rel") => AttrValue::from_serialized_tokenlist(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }
@ -115,7 +115,7 @@ impl HTMLAnchorElementMethods for HTMLAnchorElement {
// https://html.spec.whatwg.org/multipage/#dom-a-rellist // https://html.spec.whatwg.org/multipage/#dom-a-rellist
fn RelList(&self) -> Root<DOMTokenList> { fn RelList(&self) -> Root<DOMTokenList> {
self.rel_list.or_init(|| { self.rel_list.or_init(|| {
DOMTokenList::new(self.upcast(), &atom!("rel")) DOMTokenList::new(self.upcast(), &local_name!("rel"))
}) })
} }
@ -265,7 +265,7 @@ impl HTMLAnchorElementMethods for HTMLAnchorElement {
USVString(match *self.url.borrow() { USVString(match *self.url.borrow() {
None => { None => {
match self.upcast::<Element>().get_attribute(&ns!(), &atom!("href")) { match self.upcast::<Element>().get_attribute(&ns!(), &local_name!("href")) {
// Step 3. // Step 3.
None => String::new(), None => String::new(),
// Step 4. // Step 4.
@ -279,7 +279,7 @@ impl HTMLAnchorElementMethods for HTMLAnchorElement {
// https://html.spec.whatwg.org/multipage/#dom-hyperlink-href // https://html.spec.whatwg.org/multipage/#dom-hyperlink-href
fn SetHref(&self, value: USVString) { fn SetHref(&self, value: USVString) {
self.upcast::<Element>().set_string_attribute(&atom!("href"), self.upcast::<Element>().set_string_attribute(&local_name!("href"),
DOMString::from_string(value.0)); DOMString::from_string(value.0));
self.set_url(); self.set_url();
} }
@ -499,7 +499,7 @@ impl Activatable for HTMLAnchorElement {
// hyperlink" // hyperlink"
// https://html.spec.whatwg.org/multipage/#the-a-element // https://html.spec.whatwg.org/multipage/#the-a-element
// "The activation behaviour of a elements *that create hyperlinks*" // "The activation behaviour of a elements *that create hyperlinks*"
self.upcast::<Element>().has_attribute(&atom!("href")) self.upcast::<Element>().has_attribute(&local_name!("href"))
} }
@ -525,7 +525,7 @@ impl Activatable for HTMLAnchorElement {
let mouse_event = event.downcast::<MouseEvent>().unwrap(); let mouse_event = event.downcast::<MouseEvent>().unwrap();
let mut ismap_suffix = None; let mut ismap_suffix = None;
if let Some(element) = target.downcast::<Element>() { if let Some(element) = target.downcast::<Element>() {
if target.is::<HTMLImageElement>() && element.has_attribute(&atom!("ismap")) { if target.is::<HTMLImageElement>() && element.has_attribute(&local_name!("ismap")) {
let target_node = element.upcast::<Node>(); let target_node = element.upcast::<Node>();
let rect = window_from_node(target_node).content_box_query( let rect = window_from_node(target_node).content_box_query(
target_node.to_trusted_node_address()); target_node.to_trusted_node_address());
@ -563,10 +563,10 @@ fn follow_hyperlink(subject: &Element, hyperlink_suffix: Option<String>, referre
// Step 1: replace. // Step 1: replace.
// Step 2: source browsing context. // Step 2: source browsing context.
// Step 3: target browsing context. // Step 3: target browsing context.
let target = subject.get_attribute(&ns!(), &atom!("target")); let target = subject.get_attribute(&ns!(), &local_name!("target"));
// Step 4: disown target's opener if needed. // Step 4: disown target's opener if needed.
let attribute = subject.get_attribute(&ns!(), &atom!("href")).unwrap(); let attribute = subject.get_attribute(&ns!(), &local_name!("href")).unwrap();
let mut href = attribute.Value(); let mut href = attribute.Value();
// Step 7: append a hyperlink suffix. // Step 7: append a hyperlink suffix.

10
components/script/dom/htmlappletelement.rs
View file

@ -11,7 +11,7 @@ use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::attr::AttrValue; use style::attr::AttrValue;
#[dom_struct] #[dom_struct]
@ -20,7 +20,7 @@ pub struct HTMLAppletElement {
} }
impl HTMLAppletElement { impl HTMLAppletElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLAppletElement { document: &Document) -> HTMLAppletElement {
HTMLAppletElement { HTMLAppletElement {
@ -30,7 +30,7 @@ impl HTMLAppletElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLAppletElement> { document: &Document) -> Root<HTMLAppletElement> {
Node::reflect_node(box HTMLAppletElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLAppletElement::new_inherited(local_name, prefix, document),
@ -52,9 +52,9 @@ impl VirtualMethods for HTMLAppletElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("name") => AttrValue::from_atomic(value.into()), &local_name!("name") => AttrValue::from_atomic(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

12
components/script/dom/htmlareaelement.rs
View file

@ -12,8 +12,8 @@ use dom::domtokenlist::DOMTokenList;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use std::default::Default; use std::default::Default;
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
#[dom_struct] #[dom_struct]
@ -23,7 +23,7 @@ pub struct HTMLAreaElement {
} }
impl HTMLAreaElement { impl HTMLAreaElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLAreaElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLAreaElement {
HTMLAreaElement { HTMLAreaElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document), htmlelement: HTMLElement::new_inherited(local_name, prefix, document),
rel_list: Default::default(), rel_list: Default::default(),
@ -31,7 +31,7 @@ impl HTMLAreaElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLAreaElement> { document: &Document) -> Root<HTMLAreaElement> {
Node::reflect_node(box HTMLAreaElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLAreaElement::new_inherited(local_name, prefix, document),
@ -45,9 +45,9 @@ impl VirtualMethods for HTMLAreaElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("rel") => AttrValue::from_serialized_tokenlist(value.into()), &local_name!("rel") => AttrValue::from_serialized_tokenlist(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }
@ -57,7 +57,7 @@ impl HTMLAreaElementMethods for HTMLAreaElement {
// https://html.spec.whatwg.org/multipage/#dom-area-rellist // https://html.spec.whatwg.org/multipage/#dom-area-rellist
fn RelList(&self) -> Root<DOMTokenList> { fn RelList(&self) -> Root<DOMTokenList> {
self.rel_list.or_init(|| { self.rel_list.or_init(|| {
DOMTokenList::new(self.upcast(), &atom!("rel")) DOMTokenList::new(self.upcast(), &local_name!("rel"))
}) })
} }
} }

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlmediaelement::HTMLMediaElement; use dom::htmlmediaelement::HTMLMediaElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLAudioElement { pub struct HTMLAudioElement {
@ -16,7 +16,7 @@ pub struct HTMLAudioElement {
} }
impl HTMLAudioElement { impl HTMLAudioElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLAudioElement { document: &Document) -> HTMLAudioElement {
HTMLAudioElement { HTMLAudioElement {
@ -26,7 +26,7 @@ impl HTMLAudioElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLAudioElement> { document: &Document) -> Root<HTMLAudioElement> {
Node::reflect_node(box HTMLAudioElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLAudioElement::new_inherited(local_name, prefix, document),

16
components/script/dom/htmlbaseelement.rs
View file

@ -13,7 +13,7 @@ use dom::element::{AttributeMutation, Element};
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{Node, UnbindContext, document_from_node}; use dom::node::{Node, UnbindContext, document_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::attr::AttrValue; use style::attr::AttrValue;
use url::Url; use url::Url;
@ -23,14 +23,14 @@ pub struct HTMLBaseElement {
} }
impl HTMLBaseElement { impl HTMLBaseElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLBaseElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLBaseElement {
HTMLBaseElement { HTMLBaseElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document) htmlelement: HTMLElement::new_inherited(local_name, prefix, document)
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLBaseElement> { document: &Document) -> Root<HTMLBaseElement> {
Node::reflect_node(box HTMLBaseElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLBaseElement::new_inherited(local_name, prefix, document),
@ -40,7 +40,7 @@ impl HTMLBaseElement {
/// https://html.spec.whatwg.org/multipage/#frozen-base-url /// https://html.spec.whatwg.org/multipage/#frozen-base-url
pub fn frozen_base_url(&self) -> Url { pub fn frozen_base_url(&self) -> Url {
let href = self.upcast::<Element>().get_attribute(&ns!(), &atom!("href")) let href = self.upcast::<Element>().get_attribute(&ns!(), &local_name!("href"))
.expect("The frozen base url is only defined for base elements \ .expect("The frozen base url is only defined for base elements \
that have a base url."); that have a base url.");
let document = document_from_node(self); let document = document_from_node(self);
@ -56,7 +56,7 @@ impl HTMLBaseElement {
return; return;
} }
if self.upcast::<Element>().has_attribute(&atom!("href")) { if self.upcast::<Element>().has_attribute(&local_name!("href")) {
let document = document_from_node(self); let document = document_from_node(self);
document.refresh_base_element(); document.refresh_base_element();
} }
@ -69,7 +69,7 @@ impl HTMLBaseElementMethods for HTMLBaseElement {
let document = document_from_node(self); let document = document_from_node(self);
// Step 1. // Step 1.
if !self.upcast::<Element>().has_attribute(&atom!("href")) { if !self.upcast::<Element>().has_attribute(&local_name!("href")) {
return DOMString::from(document.base_url().as_str()); return DOMString::from(document.base_url().as_str());
} }
@ -77,7 +77,7 @@ impl HTMLBaseElementMethods for HTMLBaseElement {
let fallback_base_url = document.fallback_base_url(); let fallback_base_url = document.fallback_base_url();
// Step 3. // Step 3.
let url = self.upcast::<Element>().get_url_attribute(&atom!("href")); let url = self.upcast::<Element>().get_url_attribute(&local_name!("href"));
// Step 4. // Step 4.
let url_record = fallback_base_url.join(&*url); let url_record = fallback_base_url.join(&*url);
@ -97,7 +97,7 @@ impl VirtualMethods for HTMLBaseElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
if *attr.local_name() == atom!("href") { if *attr.local_name() == local_name!("href") {
document_from_node(self).refresh_base_element(); document_from_node(self).refresh_base_element();
} }
} }

33
components/script/dom/htmlbodyelement.rs
View file

@ -17,8 +17,8 @@ use dom::globalscope::GlobalScope;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{Node, document_from_node, window_from_node}; use dom::node::{Node, document_from_node, window_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use script_traits::ScriptMsg as ConstellationMsg; use script_traits::ScriptMsg as ConstellationMsg;
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
use time; use time;
use url::Url; use url::Url;
@ -33,7 +33,7 @@ pub struct HTMLBodyElement {
} }
impl HTMLBodyElement { impl HTMLBodyElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document)
-> HTMLBodyElement { -> HTMLBodyElement {
HTMLBodyElement { HTMLBodyElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document), htmlelement: HTMLElement::new_inherited(local_name, prefix, document),
@ -41,7 +41,7 @@ impl HTMLBodyElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, prefix: Option<DOMString>, document: &Document) pub fn new(local_name: LocalName, prefix: Option<DOMString>, document: &Document)
-> Root<HTMLBodyElement> { -> Root<HTMLBodyElement> {
Node::reflect_node(box HTMLBodyElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLBodyElement::new_inherited(local_name, prefix, document),
document, document,
@ -93,7 +93,7 @@ impl HTMLBodyElementLayoutHelpers for LayoutJS<HTMLBodyElement> {
fn get_background_color(&self) -> Option<RGBA> { fn get_background_color(&self) -> Option<RGBA> {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("bgcolor")) .get_attr_for_layout(&ns!(), &local_name!("bgcolor"))
.and_then(AttrValue::as_color) .and_then(AttrValue::as_color)
.cloned() .cloned()
} }
@ -103,7 +103,7 @@ impl HTMLBodyElementLayoutHelpers for LayoutJS<HTMLBodyElement> {
fn get_color(&self) -> Option<RGBA> { fn get_color(&self) -> Option<RGBA> {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("text")) .get_attr_for_layout(&ns!(), &local_name!("text"))
.and_then(AttrValue::as_color) .and_then(AttrValue::as_color)
.cloned() .cloned()
} }
@ -113,7 +113,7 @@ impl HTMLBodyElementLayoutHelpers for LayoutJS<HTMLBodyElement> {
fn get_background(&self) -> Option<Url> { fn get_background(&self) -> Option<Url> {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("background")) .get_attr_for_layout(&ns!(), &local_name!("background"))
.and_then(AttrValue::as_url) .and_then(AttrValue::as_url)
.cloned() .cloned()
} }
@ -141,11 +141,11 @@ impl VirtualMethods for HTMLBodyElement {
window.upcast::<GlobalScope>().constellation_chan().send(event).unwrap(); window.upcast::<GlobalScope>().constellation_chan().send(event).unwrap();
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match *name { match *name {
atom!("bgcolor") | local_name!("bgcolor") |
atom!("text") => AttrValue::from_legacy_color(value.into()), local_name!("text") => AttrValue::from_legacy_color(value.into()),
atom!("background") => { local_name!("background") => {
AttrValue::from_url(document_from_node(self).url(), value.into()) AttrValue::from_url(document_from_node(self).url(), value.into())
}, },
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
@ -159,11 +159,14 @@ impl VirtualMethods for HTMLBodyElement {
// https://html.spec.whatwg.org/multipage/ // https://html.spec.whatwg.org/multipage/
// #event-handlers-on-elements,-document-objects,-and-window-objects:event-handlers-3 // #event-handlers-on-elements,-document-objects,-and-window-objects:event-handlers-3
match name { match name {
&atom!("onfocus") | &atom!("onload") | &atom!("onscroll") | &atom!("onafterprint") | &local_name!("onfocus") | &local_name!("onload") | &local_name!("onscroll") |
&atom!("onbeforeprint") | &atom!("onbeforeunload") | &atom!("onhashchange") | &local_name!("onafterprint") | &local_name!("onbeforeprint") |
&atom!("onlanguagechange") | &atom!("onmessage") | &atom!("onoffline") | &atom!("ononline") | &local_name!("onbeforeunload") | &local_name!("onhashchange") |
&atom!("onpagehide") | &atom!("onpageshow") | &atom!("onpopstate") | &atom!("onstorage") | &local_name!("onlanguagechange") | &local_name!("onmessage") |
&atom!("onresize") | &atom!("onunload") | &atom!("onerror") &local_name!("onoffline") | &local_name!("ononline") |
&local_name!("onpagehide") | &local_name!("onpageshow") |
&local_name!("onpopstate") | &local_name!("onstorage") |
&local_name!("onresize") | &local_name!("onunload") | &local_name!("onerror")
=> { => {
let evtarget = window.upcast::<EventTarget>(); // forwarded event let evtarget = window.upcast::<EventTarget>(); // forwarded event
let source_line = 1; //TODO(#9604) obtain current JS execution line let source_line = 1; //TODO(#9604) obtain current JS execution line

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLBRElement { pub struct HTMLBRElement {
@ -16,14 +16,14 @@ pub struct HTMLBRElement {
} }
impl HTMLBRElement { impl HTMLBRElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLBRElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLBRElement {
HTMLBRElement { HTMLBRElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document) htmlelement: HTMLElement::new_inherited(local_name, prefix, document)
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLBRElement> { document: &Document) -> Root<HTMLBRElement> {
Node::reflect_node(box HTMLBRElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLBRElement::new_inherited(local_name, prefix, document),

10
components/script/dom/htmlbuttonelement.rs
View file

@ -23,8 +23,8 @@ use dom::nodelist::NodeList;
use dom::validation::Validatable; use dom::validation::Validatable;
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use std::cell::Cell; use std::cell::Cell;
use string_cache::Atom;
use style::element_state::*; use style::element_state::*;
#[derive(JSTraceable, PartialEq, Copy, Clone)] #[derive(JSTraceable, PartialEq, Copy, Clone)]
@ -43,7 +43,7 @@ pub struct HTMLButtonElement {
} }
impl HTMLButtonElement { impl HTMLButtonElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLButtonElement { document: &Document) -> HTMLButtonElement {
HTMLButtonElement { HTMLButtonElement {
@ -55,7 +55,7 @@ impl HTMLButtonElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLButtonElement> { document: &Document) -> Root<HTMLButtonElement> {
Node::reflect_node(box HTMLButtonElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLButtonElement::new_inherited(local_name, prefix, document),
@ -180,7 +180,7 @@ impl VirtualMethods for HTMLButtonElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("disabled") => { &local_name!("disabled") => {
let el = self.upcast::<Element>(); let el = self.upcast::<Element>();
match mutation { match mutation {
AttributeMutation::Set(Some(_)) => {} AttributeMutation::Set(Some(_)) => {}
@ -195,7 +195,7 @@ impl VirtualMethods for HTMLButtonElement {
} }
} }
}, },
&atom!("type") => { &local_name!("type") => {
match mutation { match mutation {
AttributeMutation::Set(_) => { AttributeMutation::Set(_) => {
let value = match &**attr.value() { let value = match &**attr.value() {

18
components/script/dom/htmlcanvaselement.rs
View file

@ -25,6 +25,7 @@ use dom::node::{Node, window_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use dom::webglrenderingcontext::{LayoutCanvasWebGLRenderingContextHelpers, WebGLRenderingContext}; use dom::webglrenderingcontext::{LayoutCanvasWebGLRenderingContextHelpers, WebGLRenderingContext};
use euclid::size::Size2D; use euclid::size::Size2D;
use html5ever_atoms::LocalName;
use image::ColorType; use image::ColorType;
use image::png::PNGEncoder; use image::png::PNGEncoder;
use ipc_channel::ipc::{self, IpcSender}; use ipc_channel::ipc::{self, IpcSender};
@ -34,7 +35,6 @@ use offscreen_gl_context::GLContextAttributes;
use rustc_serialize::base64::{STANDARD, ToBase64}; use rustc_serialize::base64::{STANDARD, ToBase64};
use script_layout_interface::HTMLCanvasData; use script_layout_interface::HTMLCanvasData;
use std::iter::repeat; use std::iter::repeat;
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
const DEFAULT_WIDTH: u32 = 300; const DEFAULT_WIDTH: u32 = 300;
@ -56,7 +56,7 @@ pub struct HTMLCanvasElement {
} }
impl HTMLCanvasElement { impl HTMLCanvasElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLCanvasElement { document: &Document) -> HTMLCanvasElement {
HTMLCanvasElement { HTMLCanvasElement {
@ -66,7 +66,7 @@ impl HTMLCanvasElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLCanvasElement> { document: &Document) -> Root<HTMLCanvasElement> {
Node::reflect_node(box HTMLCanvasElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLCanvasElement::new_inherited(local_name, prefix, document),
@ -116,8 +116,8 @@ impl LayoutHTMLCanvasElementHelpers for LayoutJS<HTMLCanvasElement> {
} }
}); });
let width_attr = canvas.upcast::<Element>().get_attr_for_layout(&ns!(), &atom!("width")); let width_attr = canvas.upcast::<Element>().get_attr_for_layout(&ns!(), &local_name!("width"));
let height_attr = canvas.upcast::<Element>().get_attr_for_layout(&ns!(), &atom!("height")); let height_attr = canvas.upcast::<Element>().get_attr_for_layout(&ns!(), &local_name!("height"));
HTMLCanvasData { HTMLCanvasData {
ipc_renderer: ipc_renderer, ipc_renderer: ipc_renderer,
width: width_attr.map_or(DEFAULT_WIDTH, |val| val.as_uint()), width: width_attr.map_or(DEFAULT_WIDTH, |val| val.as_uint()),
@ -307,15 +307,15 @@ impl VirtualMethods for HTMLCanvasElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("width") | &atom!("height") => self.recreate_contexts(), &local_name!("width") | &local_name!("height") => self.recreate_contexts(),
_ => (), _ => (),
}; };
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("width") => AttrValue::from_u32(value.into(), DEFAULT_WIDTH), &local_name!("width") => AttrValue::from_u32(value.into(), DEFAULT_WIDTH),
&atom!("height") => AttrValue::from_u32(value.into(), DEFAULT_HEIGHT), &local_name!("height") => AttrValue::from_u32(value.into(), DEFAULT_HEIGHT),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

29
components/script/dom/htmlcollection.rs
View file

@ -13,9 +13,10 @@ use dom::bindings::xmlname::namespace_from_domstring;
use dom::element::Element; use dom::element::Element;
use dom::node::Node; use dom::node::Node;
use dom::window::Window; use dom::window::Window;
use html5ever_atoms::{LocalName, QualName};
use servo_atoms::Atom;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::cell::Cell; use std::cell::Cell;
use string_cache::{Atom, Namespace, QualName};
use style::str::split_html_space_chars; use style::str::split_html_space_chars;
pub trait CollectionFilter : JSTraceable { pub trait CollectionFilter : JSTraceable {
@ -115,22 +116,22 @@ impl HTMLCollection {
pub fn by_tag_name(window: &Window, root: &Node, mut tag: DOMString) pub fn by_tag_name(window: &Window, root: &Node, mut tag: DOMString)
-> Root<HTMLCollection> { -> Root<HTMLCollection> {
let tag_atom = Atom::from(&*tag); let tag_atom = LocalName::from(&*tag);
tag.make_ascii_lowercase(); tag.make_ascii_lowercase();
let ascii_lower_tag = Atom::from(tag); // FIXME(ajeffrey): don't clone atom if it was already lowercased. let ascii_lower_tag = LocalName::from(tag); // FIXME(ajeffrey): don't clone atom if it was already lowercased.
HTMLCollection::by_atomic_tag_name(window, root, tag_atom, ascii_lower_tag) HTMLCollection::by_atomic_tag_name(window, root, tag_atom, ascii_lower_tag)
} }
pub fn by_atomic_tag_name(window: &Window, root: &Node, tag_atom: Atom, ascii_lower_tag: Atom) pub fn by_atomic_tag_name(window: &Window, root: &Node, tag_atom: LocalName, ascii_lower_tag: LocalName)
-> Root<HTMLCollection> { -> Root<HTMLCollection> {
#[derive(JSTraceable, HeapSizeOf)] #[derive(JSTraceable, HeapSizeOf)]
struct TagNameFilter { struct TagNameFilter {
tag: Atom, tag: LocalName,
ascii_lower_tag: Atom, ascii_lower_tag: LocalName,
} }
impl CollectionFilter for TagNameFilter { impl CollectionFilter for TagNameFilter {
fn filter(&self, elem: &Element, _root: &Node) -> bool { fn filter(&self, elem: &Element, _root: &Node) -> bool {
if self.tag == atom!("*") { if self.tag == local_name!("*") {
true true
} else if elem.html_element_in_html_document() { } else if elem.html_element_in_html_document() {
*elem.local_name() == self.ascii_lower_tag *elem.local_name() == self.ascii_lower_tag
@ -148,7 +149,7 @@ impl HTMLCollection {
pub fn by_tag_name_ns(window: &Window, root: &Node, tag: DOMString, pub fn by_tag_name_ns(window: &Window, root: &Node, tag: DOMString,
maybe_ns: Option<DOMString>) -> Root<HTMLCollection> { maybe_ns: Option<DOMString>) -> Root<HTMLCollection> {
let local = Atom::from(tag); let local = LocalName::from(tag);
let ns = namespace_from_domstring(maybe_ns); let ns = namespace_from_domstring(maybe_ns);
let qname = QualName::new(ns, local); let qname = QualName::new(ns, local);
HTMLCollection::by_qual_tag_name(window, root, qname) HTMLCollection::by_qual_tag_name(window, root, qname)
@ -161,8 +162,8 @@ impl HTMLCollection {
} }
impl CollectionFilter for TagNameNSFilter { impl CollectionFilter for TagNameNSFilter {
fn filter(&self, elem: &Element, _root: &Node) -> bool { fn filter(&self, elem: &Element, _root: &Node) -> bool {
((self.qname.ns == Namespace(atom!("*"))) || (self.qname.ns == *elem.namespace())) && ((self.qname.ns == namespace_url!("*")) || (self.qname.ns == *elem.namespace())) &&
((self.qname.local == atom!("*")) || (self.qname.local == *elem.local_name())) ((self.qname.local == local_name!("*")) || (self.qname.local == *elem.local_name()))
} }
} }
let filter = TagNameNSFilter { let filter = TagNameNSFilter {
@ -313,8 +314,8 @@ impl HTMLCollectionMethods for HTMLCollection {
// Step 2. // Step 2.
self.elements_iter().find(|elem| { self.elements_iter().find(|elem| {
elem.get_string_attribute(&atom!("id")) == key || elem.get_string_attribute(&local_name!("id")) == key ||
(elem.namespace() == &ns!(html) && elem.get_string_attribute(&atom!("name")) == key) (elem.namespace() == &ns!(html) && elem.get_string_attribute(&local_name!("name")) == key)
}) })
} }
@ -336,12 +337,12 @@ impl HTMLCollectionMethods for HTMLCollection {
// Step 2 // Step 2
for elem in self.elements_iter() { for elem in self.elements_iter() {
// Step 2.1 // Step 2.1
let id_attr = elem.get_string_attribute(&atom!("id")); let id_attr = elem.get_string_attribute(&local_name!("id"));
if !id_attr.is_empty() && !result.contains(&id_attr) { if !id_attr.is_empty() && !result.contains(&id_attr) {
result.push(id_attr) result.push(id_attr)
} }
// Step 2.2 // Step 2.2
let name_attr = elem.get_string_attribute(&atom!("name")); let name_attr = elem.get_string_attribute(&local_name!("name"));
if !name_attr.is_empty() && !result.contains(&name_attr) && *elem.namespace() == ns!(html) { if !name_attr.is_empty() && !result.contains(&name_attr) && *elem.namespace() == ns!(html) {
result.push(name_attr) result.push(name_attr)
} }

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

@ -9,7 +9,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLDataElement { pub struct HTMLDataElement {
@ -17,7 +17,7 @@ pub struct HTMLDataElement {
} }
impl HTMLDataElement { impl HTMLDataElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLDataElement { document: &Document) -> HTMLDataElement {
HTMLDataElement { HTMLDataElement {
@ -26,7 +26,7 @@ impl HTMLDataElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLDataElement> { document: &Document) -> Root<HTMLDataElement> {
Node::reflect_node(box HTMLDataElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLDataElement::new_inherited(local_name, prefix, document),

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

@ -13,7 +13,7 @@ use dom::htmlcollection::{CollectionFilter, HTMLCollection};
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::htmloptionelement::HTMLOptionElement; use dom::htmloptionelement::HTMLOptionElement;
use dom::node::{Node, window_from_node}; use dom::node::{Node, window_from_node};
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLDataListElement { pub struct HTMLDataListElement {
@ -21,7 +21,7 @@ pub struct HTMLDataListElement {
} }
impl HTMLDataListElement { impl HTMLDataListElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLDataListElement { document: &Document) -> HTMLDataListElement {
HTMLDataListElement { HTMLDataListElement {
@ -31,7 +31,7 @@ impl HTMLDataListElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLDataListElement> { document: &Document) -> Root<HTMLDataListElement> {
Node::reflect_node(box HTMLDataListElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLDataListElement::new_inherited(local_name, prefix, document),

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

@ -15,9 +15,9 @@ use dom::eventtarget::EventTarget;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{Node, window_from_node}; use dom::node::{Node, window_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use script_thread::Runnable; use script_thread::Runnable;
use std::cell::Cell; use std::cell::Cell;
use string_cache::Atom;
use task_source::TaskSource; use task_source::TaskSource;
#[dom_struct] #[dom_struct]
@ -27,7 +27,7 @@ pub struct HTMLDetailsElement {
} }
impl HTMLDetailsElement { impl HTMLDetailsElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLDetailsElement { document: &Document) -> HTMLDetailsElement {
HTMLDetailsElement { HTMLDetailsElement {
@ -38,7 +38,7 @@ impl HTMLDetailsElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLDetailsElement> { document: &Document) -> Root<HTMLDetailsElement> {
Node::reflect_node(box HTMLDetailsElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLDetailsElement::new_inherited(local_name, prefix, document),
@ -67,7 +67,7 @@ impl VirtualMethods for HTMLDetailsElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
if attr.local_name() == &atom!("open") { if attr.local_name() == &local_name!("open") {
let counter = self.toggle_counter.get() + 1; let counter = self.toggle_counter.get() + 1;
self.toggle_counter.set(counter); self.toggle_counter.set(counter);

8
components/script/dom/htmldialogelement.rs
View file

@ -13,7 +13,7 @@ use dom::element::Element;
use dom::eventtarget::EventTarget; use dom::eventtarget::EventTarget;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{Node, window_from_node}; use dom::node::{Node, window_from_node};
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLDialogElement { pub struct HTMLDialogElement {
@ -22,7 +22,7 @@ pub struct HTMLDialogElement {
} }
impl HTMLDialogElement { impl HTMLDialogElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLDialogElement { document: &Document) -> HTMLDialogElement {
HTMLDialogElement { HTMLDialogElement {
@ -33,7 +33,7 @@ impl HTMLDialogElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLDialogElement> { document: &Document) -> Root<HTMLDialogElement> {
Node::reflect_node(box HTMLDialogElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLDialogElement::new_inherited(local_name, prefix, document),
@ -67,7 +67,7 @@ impl HTMLDialogElementMethods for HTMLDialogElement {
let win = window_from_node(self); let win = window_from_node(self);
// Step 1 & 2 // Step 1 & 2
if element.remove_attribute(&ns!(), &atom!("open")).is_none() { if element.remove_attribute(&ns!(), &local_name!("open")).is_none() {
return; return;
} }

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLDirectoryElement { pub struct HTMLDirectoryElement {
@ -16,7 +16,7 @@ pub struct HTMLDirectoryElement {
} }
impl HTMLDirectoryElement { impl HTMLDirectoryElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLDirectoryElement { document: &Document) -> HTMLDirectoryElement {
HTMLDirectoryElement { HTMLDirectoryElement {
@ -26,7 +26,7 @@ impl HTMLDirectoryElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLDirectoryElement> { document: &Document) -> Root<HTMLDirectoryElement> {
Node::reflect_node(box HTMLDirectoryElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLDirectoryElement::new_inherited(local_name, prefix, document),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLDivElement { pub struct HTMLDivElement {
@ -16,7 +16,7 @@ pub struct HTMLDivElement {
} }
impl HTMLDivElement { impl HTMLDivElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLDivElement { document: &Document) -> HTMLDivElement {
HTMLDivElement { HTMLDivElement {
@ -25,7 +25,7 @@ impl HTMLDivElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLDivElement> { document: &Document) -> Root<HTMLDivElement> {
Node::reflect_node(box HTMLDivElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLDivElement::new_inherited(local_name, prefix, document),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLDListElement { pub struct HTMLDListElement {
@ -16,7 +16,7 @@ pub struct HTMLDListElement {
} }
impl HTMLDListElement { impl HTMLDListElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLDListElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLDListElement {
HTMLDListElement { HTMLDListElement {
htmlelement: htmlelement:
HTMLElement::new_inherited(local_name, prefix, document) HTMLElement::new_inherited(local_name, prefix, document)
@ -24,7 +24,7 @@ impl HTMLDListElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLDListElement> { document: &Document) -> Root<HTMLDListElement> {
Node::reflect_node(box HTMLDListElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLDListElement::new_inherited(local_name, prefix, document),

28
components/script/dom/htmlelement.rs
View file

@ -29,11 +29,11 @@ use dom::node::{Node, SEQUENTIALLY_FOCUSABLE};
use dom::node::{document_from_node, window_from_node}; use dom::node::{document_from_node, window_from_node};
use dom::nodelist::NodeList; use dom::nodelist::NodeList;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::default::Default; use std::default::Default;
use std::rc::Rc; use std::rc::Rc;
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
use style::element_state::*; use style::element_state::*;
@ -45,12 +45,12 @@ pub struct HTMLElement {
} }
impl HTMLElement { impl HTMLElement {
pub fn new_inherited(tag_name: Atom, prefix: Option<DOMString>, pub fn new_inherited(tag_name: LocalName, prefix: Option<DOMString>,
document: &Document) -> HTMLElement { document: &Document) -> HTMLElement {
HTMLElement::new_inherited_with_state(ElementState::empty(), tag_name, prefix, document) HTMLElement::new_inherited_with_state(ElementState::empty(), tag_name, prefix, document)
} }
pub fn new_inherited_with_state(state: ElementState, tag_name: Atom, pub fn new_inherited_with_state(state: ElementState, tag_name: LocalName,
prefix: Option<DOMString>, document: &Document) prefix: Option<DOMString>, document: &Document)
-> HTMLElement { -> HTMLElement {
HTMLElement { HTMLElement {
@ -62,7 +62,7 @@ impl HTMLElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> Root<HTMLElement> { pub fn new(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> Root<HTMLElement> {
Node::reflect_node(box HTMLElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLElement::new_inherited(local_name, prefix, document),
document, document,
HTMLElementBinding::Wrap) HTMLElementBinding::Wrap)
@ -76,7 +76,7 @@ impl HTMLElement {
fn update_sequentially_focusable_status(&self) { fn update_sequentially_focusable_status(&self) {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
let node = self.upcast::<Node>(); let node = self.upcast::<Node>();
if element.has_attribute(&atom!("tabindex")) { if element.has_attribute(&local_name!("tabindex")) {
node.set_flag(SEQUENTIALLY_FOCUSABLE, true); node.set_flag(SEQUENTIALLY_FOCUSABLE, true);
} else { } else {
match node.type_id() { match node.type_id() {
@ -87,12 +87,12 @@ impl HTMLElement {
=> node.set_flag(SEQUENTIALLY_FOCUSABLE, true), => node.set_flag(SEQUENTIALLY_FOCUSABLE, true),
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)) | NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLLinkElement)) |
NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)) => { NodeTypeId::Element(ElementTypeId::HTMLElement(HTMLElementTypeId::HTMLAnchorElement)) => {
if element.has_attribute(&atom!("href")) { if element.has_attribute(&local_name!("href")) {
node.set_flag(SEQUENTIALLY_FOCUSABLE, true); node.set_flag(SEQUENTIALLY_FOCUSABLE, true);
} }
}, },
_ => { _ => {
if let Some(attr) = element.get_attribute(&ns!(), &atom!("draggable")) { if let Some(attr) = element.get_attribute(&ns!(), &local_name!("draggable")) {
let value = attr.value(); let value = attr.value();
let is_true = match *value { let is_true = match *value {
AttrValue::String(ref string) => string == "true", AttrValue::String(ref string) => string == "true",
@ -393,16 +393,16 @@ impl HTMLElement {
} }
pub fn get_custom_attr(&self, local_name: DOMString) -> Option<DOMString> { pub fn get_custom_attr(&self, local_name: DOMString) -> Option<DOMString> {
// FIXME(ajeffrey): Convert directly from DOMString to Atom // FIXME(ajeffrey): Convert directly from DOMString to LocalName
let local_name = Atom::from(to_snake_case(local_name)); let local_name = LocalName::from(to_snake_case(local_name));
self.upcast::<Element>().get_attribute(&ns!(), &local_name).map(|attr| { self.upcast::<Element>().get_attribute(&ns!(), &local_name).map(|attr| {
DOMString::from(&**attr.value()) // FIXME(ajeffrey): Convert directly from AttrValue to DOMString DOMString::from(&**attr.value()) // FIXME(ajeffrey): Convert directly from AttrValue to DOMString
}) })
} }
pub fn delete_custom_attr(&self, local_name: DOMString) { pub fn delete_custom_attr(&self, local_name: DOMString) {
// FIXME(ajeffrey): Convert directly from DOMString to Atom // FIXME(ajeffrey): Convert directly from DOMString to LocalName
let local_name = Atom::from(to_snake_case(local_name)); let local_name = LocalName::from(to_snake_case(local_name));
self.upcast::<Element>().remove_attribute(&ns!(), &local_name); self.upcast::<Element>().remove_attribute(&ns!(), &local_name);
} }
@ -430,7 +430,7 @@ impl HTMLElement {
pub fn is_listed_element(&self) -> bool { pub fn is_listed_element(&self) -> bool {
// Servo does not implement HTMLKeygenElement // Servo does not implement HTMLKeygenElement
// https://github.com/servo/servo/issues/2782 // https://github.com/servo/servo/issues/2782
if self.upcast::<Element>().local_name() == &atom!("keygen") { if self.upcast::<Element>().local_name() == &local_name!("keygen") {
return true; return true;
} }
@ -475,7 +475,7 @@ impl HTMLElement {
// will be a label for this HTMLElement // will be a label for this HTMLElement
.take_while(|elem| !elem.is_labelable_element()) .take_while(|elem| !elem.is_labelable_element())
.filter_map(Root::downcast::<HTMLLabelElement>) .filter_map(Root::downcast::<HTMLLabelElement>)
.filter(|elem| !elem.upcast::<Element>().has_attribute(&atom!("for"))) .filter(|elem| !elem.upcast::<Element>().has_attribute(&local_name!("for")))
.filter(|elem| elem.first_labelable_descendant().r() == Some(self)) .filter(|elem| elem.first_labelable_descendant().r() == Some(self))
.map(Root::upcast::<Node>); .map(Root::upcast::<Node>);
@ -491,7 +491,7 @@ impl HTMLElement {
let children = root_node.traverse_preorder() let children = root_node.traverse_preorder()
.filter_map(Root::downcast::<Element>) .filter_map(Root::downcast::<Element>)
.filter(|elem| elem.is::<HTMLLabelElement>()) .filter(|elem| elem.is::<HTMLLabelElement>())
.filter(|elem| elem.get_string_attribute(&atom!("for")) == id) .filter(|elem| elem.get_string_attribute(&local_name!("for")) == id)
.map(Root::upcast::<Node>); .map(Root::upcast::<Node>);
NodeList::new_simple_list(&window, children.chain(ancestors)) NodeList::new_simple_list(&window, children.chain(ancestors))

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLEmbedElement { pub struct HTMLEmbedElement {
@ -16,14 +16,14 @@ pub struct HTMLEmbedElement {
} }
impl HTMLEmbedElement { impl HTMLEmbedElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLEmbedElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLEmbedElement {
HTMLEmbedElement { HTMLEmbedElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document) htmlelement: HTMLElement::new_inherited(local_name, prefix, document)
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLEmbedElement> { document: &Document) -> Root<HTMLEmbedElement> {
Node::reflect_node(box HTMLEmbedElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLEmbedElement::new_inherited(local_name, prefix, document),

8
components/script/dom/htmlfieldsetelement.rs
View file

@ -17,7 +17,7 @@ use dom::htmllegendelement::HTMLLegendElement;
use dom::node::{Node, window_from_node}; use dom::node::{Node, window_from_node};
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::element_state::*; use style::element_state::*;
#[dom_struct] #[dom_struct]
@ -26,7 +26,7 @@ pub struct HTMLFieldSetElement {
} }
impl HTMLFieldSetElement { impl HTMLFieldSetElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLFieldSetElement { document: &Document) -> HTMLFieldSetElement {
HTMLFieldSetElement { HTMLFieldSetElement {
@ -37,7 +37,7 @@ impl HTMLFieldSetElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLFieldSetElement> { document: &Document) -> Root<HTMLFieldSetElement> {
Node::reflect_node(box HTMLFieldSetElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLFieldSetElement::new_inherited(local_name, prefix, document),
@ -88,7 +88,7 @@ impl VirtualMethods for HTMLFieldSetElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("disabled") => { &local_name!("disabled") => {
let disabled_state = match mutation { let disabled_state = match mutation {
AttributeMutation::Set(None) => true, AttributeMutation::Set(None) => true,
AttributeMutation::Set(Some(_)) => { AttributeMutation::Set(Some(_)) => {

23
components/script/dom/htmlfontelement.rs
View file

@ -13,7 +13,8 @@ use dom::element::{Element, RawLayoutElementHelpers};
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use servo_atoms::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
use style::str::{HTML_SPACE_CHARACTERS, read_numbers}; use style::str::{HTML_SPACE_CHARACTERS, read_numbers};
use style::values::specified; use style::values::specified;
@ -25,14 +26,14 @@ pub struct HTMLFontElement {
impl HTMLFontElement { impl HTMLFontElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLFontElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLFontElement {
HTMLFontElement { HTMLFontElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document), htmlelement: HTMLElement::new_inherited(local_name, prefix, document),
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLFontElement> { document: &Document) -> Root<HTMLFontElement> {
Node::reflect_node(box HTMLFontElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLFontElement::new_inherited(local_name, prefix, document),
@ -61,7 +62,7 @@ impl HTMLFontElementMethods for HTMLFontElement {
fn SetSize(&self, value: DOMString) { fn SetSize(&self, value: DOMString) {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
let length = parse_length(&value); let length = parse_length(&value);
element.set_attribute(&atom!("size"), AttrValue::Length(value.into(), length)); element.set_attribute(&local_name!("size"), AttrValue::Length(value.into(), length));
} }
} }
@ -70,11 +71,11 @@ impl VirtualMethods for HTMLFontElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("face") => AttrValue::from_atomic(value.into()), &local_name!("face") => AttrValue::from_atomic(value.into()),
&atom!("color") => AttrValue::from_legacy_color(value.into()), &local_name!("color") => AttrValue::from_legacy_color(value.into()),
&atom!("size") => { &local_name!("size") => {
let length = parse_length(&value); let length = parse_length(&value);
AttrValue::Length(value.into(), length) AttrValue::Length(value.into(), length)
}, },
@ -94,7 +95,7 @@ impl HTMLFontElementLayoutHelpers for LayoutJS<HTMLFontElement> {
fn get_color(&self) -> Option<RGBA> { fn get_color(&self) -> Option<RGBA> {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("color")) .get_attr_for_layout(&ns!(), &local_name!("color"))
.and_then(AttrValue::as_color) .and_then(AttrValue::as_color)
.cloned() .cloned()
} }
@ -104,7 +105,7 @@ impl HTMLFontElementLayoutHelpers for LayoutJS<HTMLFontElement> {
fn get_face(&self) -> Option<Atom> { fn get_face(&self) -> Option<Atom> {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("face")) .get_attr_for_layout(&ns!(), &local_name!("face"))
.map(AttrValue::as_atom) .map(AttrValue::as_atom)
.cloned() .cloned()
} }
@ -114,7 +115,7 @@ impl HTMLFontElementLayoutHelpers for LayoutJS<HTMLFontElement> {
fn get_size(&self) -> Option<specified::Length> { fn get_size(&self) -> Option<specified::Length> {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("size")) .get_attr_for_layout(&ns!(), &local_name!("size"))
.and_then(AttrValue::as_length) .and_then(AttrValue::as_length)
.cloned() .cloned()
} }

4
components/script/dom/htmlformcontrolscollection.rs
View file

@ -50,8 +50,8 @@ impl HTMLFormControlsCollectionMethods for HTMLFormControlsCollection {
if name.is_empty() { return None; } if name.is_empty() { return None; }
let mut filter_map = self.collection.elements_iter().filter_map(|elem| { let mut filter_map = self.collection.elements_iter().filter_map(|elem| {
if elem.get_string_attribute(&atom!("name")) == name if elem.get_string_attribute(&local_name!("name")) == name
|| elem.get_string_attribute(&atom!("id")) == name { || elem.get_string_attribute(&local_name!("id")) == name {
Some(elem) Some(elem)
} else { None } } else { None }
}); });

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

@ -40,6 +40,7 @@ use dom::virtualmethods::VirtualMethods;
use encoding::EncodingRef; use encoding::EncodingRef;
use encoding::all::UTF_8; use encoding::all::UTF_8;
use encoding::label::encoding_from_whatwg_label; use encoding::label::encoding_from_whatwg_label;
use html5ever_atoms::LocalName;
use hyper::header::{Charset, ContentDisposition, ContentType, DispositionParam, DispositionType}; use hyper::header::{Charset, ContentDisposition, ContentType, DispositionParam, DispositionType};
use hyper::method::Method; use hyper::method::Method;
use msg::constellation_msg::PipelineId; use msg::constellation_msg::PipelineId;
@ -49,7 +50,6 @@ use script_traits::LoadData;
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::cell::Cell; use std::cell::Cell;
use std::sync::mpsc::Sender; use std::sync::mpsc::Sender;
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
use style::str::split_html_space_chars; use style::str::split_html_space_chars;
use task_source::TaskSource; use task_source::TaskSource;
@ -66,7 +66,7 @@ pub struct HTMLFormElement {
} }
impl HTMLFormElement { impl HTMLFormElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLFormElement { document: &Document) -> HTMLFormElement {
HTMLFormElement { HTMLFormElement {
@ -78,7 +78,7 @@ impl HTMLFormElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLFormElement> { document: &Document) -> Root<HTMLFormElement> {
Node::reflect_node(box HTMLFormElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLFormElement::new_inherited(local_name, prefix, document),
@ -205,7 +205,7 @@ impl HTMLFormElementMethods for HTMLFormElement {
} }
_ => { _ => {
debug_assert!(!elem.downcast::<HTMLElement>().unwrap().is_listed_element() || debug_assert!(!elem.downcast::<HTMLElement>().unwrap().is_listed_element() ||
elem.local_name() == &atom!("keygen")); elem.local_name() == &local_name!("keygen"));
return false; return false;
} }
} }
@ -255,9 +255,9 @@ impl HTMLFormElement {
// https://html.spec.whatwg.org/multipage/#picking-an-encoding-for-the-form // https://html.spec.whatwg.org/multipage/#picking-an-encoding-for-the-form
fn pick_encoding(&self) -> EncodingRef { fn pick_encoding(&self) -> EncodingRef {
// Step 2 // Step 2
if self.upcast::<Element>().has_attribute(&atom!("accept-charset")) { if self.upcast::<Element>().has_attribute(&local_name!("accept-charset")) {
// Substep 1 // Substep 1
let input = self.upcast::<Element>().get_string_attribute(&atom!("accept-charset")); let input = self.upcast::<Element>().get_string_attribute(&local_name!("accept-charset"));
// Substep 2, 3, 4 // Substep 2, 3, 4
let mut candidate_encodings = split_html_space_chars(&*input).filter_map(encoding_from_whatwg_label); let mut candidate_encodings = split_html_space_chars(&*input).filter_map(encoding_from_whatwg_label);
@ -728,12 +728,12 @@ impl<'a> FormSubmitter<'a> {
match *self { match *self {
FormSubmitter::FormElement(form) => form.Action(), FormSubmitter::FormElement(form) => form.Action(),
FormSubmitter::InputElement(input_element) => { FormSubmitter::InputElement(input_element) => {
input_element.get_form_attribute(&atom!("formaction"), input_element.get_form_attribute(&local_name!("formaction"),
|i| i.FormAction(), |i| i.FormAction(),
|f| f.Action()) |f| f.Action())
}, },
FormSubmitter::ButtonElement(button_element) => { FormSubmitter::ButtonElement(button_element) => {
button_element.get_form_attribute(&atom!("formaction"), button_element.get_form_attribute(&local_name!("formaction"),
|i| i.FormAction(), |i| i.FormAction(),
|f| f.Action()) |f| f.Action())
} }
@ -744,12 +744,12 @@ impl<'a> FormSubmitter<'a> {
let attr = match *self { let attr = match *self {
FormSubmitter::FormElement(form) => form.Enctype(), FormSubmitter::FormElement(form) => form.Enctype(),
FormSubmitter::InputElement(input_element) => { FormSubmitter::InputElement(input_element) => {
input_element.get_form_attribute(&atom!("formenctype"), input_element.get_form_attribute(&local_name!("formenctype"),
|i| i.FormEnctype(), |i| i.FormEnctype(),
|f| f.Enctype()) |f| f.Enctype())
}, },
FormSubmitter::ButtonElement(button_element) => { FormSubmitter::ButtonElement(button_element) => {
button_element.get_form_attribute(&atom!("formenctype"), button_element.get_form_attribute(&local_name!("formenctype"),
|i| i.FormEnctype(), |i| i.FormEnctype(),
|f| f.Enctype()) |f| f.Enctype())
} }
@ -767,12 +767,12 @@ impl<'a> FormSubmitter<'a> {
let attr = match *self { let attr = match *self {
FormSubmitter::FormElement(form) => form.Method(), FormSubmitter::FormElement(form) => form.Method(),
FormSubmitter::InputElement(input_element) => { FormSubmitter::InputElement(input_element) => {
input_element.get_form_attribute(&atom!("formmethod"), input_element.get_form_attribute(&local_name!("formmethod"),
|i| i.FormMethod(), |i| i.FormMethod(),
|f| f.Method()) |f| f.Method())
}, },
FormSubmitter::ButtonElement(button_element) => { FormSubmitter::ButtonElement(button_element) => {
button_element.get_form_attribute(&atom!("formmethod"), button_element.get_form_attribute(&local_name!("formmethod"),
|i| i.FormMethod(), |i| i.FormMethod(),
|f| f.Method()) |f| f.Method())
} }
@ -788,12 +788,12 @@ impl<'a> FormSubmitter<'a> {
match *self { match *self {
FormSubmitter::FormElement(form) => form.Target(), FormSubmitter::FormElement(form) => form.Target(),
FormSubmitter::InputElement(input_element) => { FormSubmitter::InputElement(input_element) => {
input_element.get_form_attribute(&atom!("formtarget"), input_element.get_form_attribute(&local_name!("formtarget"),
|i| i.FormTarget(), |i| i.FormTarget(),
|f| f.Target()) |f| f.Target())
}, },
FormSubmitter::ButtonElement(button_element) => { FormSubmitter::ButtonElement(button_element) => {
button_element.get_form_attribute(&atom!("formtarget"), button_element.get_form_attribute(&local_name!("formtarget"),
|i| i.FormTarget(), |i| i.FormTarget(),
|f| f.Target()) |f| f.Target())
} }
@ -804,12 +804,12 @@ impl<'a> FormSubmitter<'a> {
match *self { match *self {
FormSubmitter::FormElement(form) => form.NoValidate(), FormSubmitter::FormElement(form) => form.NoValidate(),
FormSubmitter::InputElement(input_element) => { FormSubmitter::InputElement(input_element) => {
input_element.get_form_boolean_attribute(&atom!("formnovalidate"), input_element.get_form_boolean_attribute(&local_name!("formnovalidate"),
|i| i.FormNoValidate(), |i| i.FormNoValidate(),
|f| f.NoValidate()) |f| f.NoValidate())
} }
FormSubmitter::ButtonElement(button_element) => { FormSubmitter::ButtonElement(button_element) => {
button_element.get_form_boolean_attribute(&atom!("formnovalidate"), button_element.get_form_boolean_attribute(&local_name!("formnovalidate"),
|i| i.FormNoValidate(), |i| i.FormNoValidate(),
|f| f.NoValidate()) |f| f.NoValidate())
} }
@ -823,7 +823,7 @@ pub trait FormControl: DerivedFrom<Element> + Reflectable {
fn form_owner(&self) -> Option<Root<HTMLFormElement>> { fn form_owner(&self) -> Option<Root<HTMLFormElement>> {
// https://html.spec.whatwg.org/multipage/#reset-the-form-owner // https://html.spec.whatwg.org/multipage/#reset-the-form-owner
let elem = self.to_element(); let elem = self.to_element();
let owner = elem.get_string_attribute(&atom!("form")); let owner = elem.get_string_attribute(&local_name!("form"));
if !owner.is_empty() { if !owner.is_empty() {
let doc = document_from_node(elem); let doc = document_from_node(elem);
let owner = doc.GetElementById(owner); let owner = doc.GetElementById(owner);
@ -838,7 +838,7 @@ pub trait FormControl: DerivedFrom<Element> + Reflectable {
} }
fn get_form_attribute<InputFn, OwnerFn>(&self, fn get_form_attribute<InputFn, OwnerFn>(&self,
attr: &Atom, attr: &LocalName,
input: InputFn, input: InputFn,
owner: OwnerFn) owner: OwnerFn)
-> DOMString -> DOMString
@ -853,7 +853,7 @@ pub trait FormControl: DerivedFrom<Element> + Reflectable {
} }
fn get_form_boolean_attribute<InputFn, OwnerFn>(&self, fn get_form_boolean_attribute<InputFn, OwnerFn>(&self,
attr: &Atom, attr: &LocalName,
input: InputFn, input: InputFn,
owner: OwnerFn) owner: OwnerFn)
-> bool -> bool
@ -881,9 +881,9 @@ impl VirtualMethods for HTMLFormElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("name") => AttrValue::from_atomic(value.into()), &local_name!("name") => AttrValue::from_atomic(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLFrameElement { pub struct HTMLFrameElement {
@ -16,14 +16,14 @@ pub struct HTMLFrameElement {
} }
impl HTMLFrameElement { impl HTMLFrameElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLFrameElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLFrameElement {
HTMLFrameElement { HTMLFrameElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document) htmlelement: HTMLElement::new_inherited(local_name, prefix, document)
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLFrameElement> { document: &Document) -> Root<HTMLFrameElement> {
Node::reflect_node(box HTMLFrameElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLFrameElement::new_inherited(local_name, prefix, document),

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

@ -11,7 +11,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{Node, window_from_node}; use dom::node::{Node, window_from_node};
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLFrameSetElement { pub struct HTMLFrameSetElement {
@ -19,7 +19,7 @@ pub struct HTMLFrameSetElement {
} }
impl HTMLFrameSetElement { impl HTMLFrameSetElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLFrameSetElement { document: &Document) -> HTMLFrameSetElement {
HTMLFrameSetElement { HTMLFrameSetElement {
@ -29,7 +29,7 @@ impl HTMLFrameSetElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLFrameSetElement> { document: &Document) -> Root<HTMLFrameSetElement> {
Node::reflect_node(box HTMLFrameSetElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLFrameSetElement::new_inherited(local_name, prefix, document),

12
components/script/dom/htmlheadelement.rs
View file

@ -14,7 +14,7 @@ use dom::htmlmetaelement::HTMLMetaElement;
use dom::node::{Node, document_from_node}; use dom::node::{Node, document_from_node};
use dom::userscripts::load_script; use dom::userscripts::load_script;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLHeadElement { pub struct HTMLHeadElement {
@ -22,7 +22,7 @@ pub struct HTMLHeadElement {
} }
impl HTMLHeadElement { impl HTMLHeadElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLHeadElement { document: &Document) -> HTMLHeadElement {
HTMLHeadElement { HTMLHeadElement {
@ -31,7 +31,7 @@ impl HTMLHeadElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLHeadElement> { document: &Document) -> Root<HTMLHeadElement> {
Node::reflect_node(box HTMLHeadElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLHeadElement::new_inherited(local_name, prefix, document),
@ -51,11 +51,11 @@ impl HTMLHeadElement {
let candidates = node.traverse_preorder() let candidates = node.traverse_preorder()
.filter_map(Root::downcast::<Element>) .filter_map(Root::downcast::<Element>)
.filter(|elem| elem.is::<HTMLMetaElement>()) .filter(|elem| elem.is::<HTMLMetaElement>())
.filter(|elem| elem.get_string_attribute(&atom!("name")) == "referrer") .filter(|elem| elem.get_string_attribute(&local_name!("name")) == "referrer")
.filter(|elem| elem.get_attribute(&ns!(), &atom!("content")).is_some()); .filter(|elem| elem.get_attribute(&ns!(), &local_name!("content")).is_some());
for meta in candidates { for meta in candidates {
if let Some(content) = meta.get_attribute(&ns!(), &atom!("content")).r() { if let Some(content) = meta.get_attribute(&ns!(), &local_name!("content")).r() {
let content = content.value(); let content = content.value();
let content_val = content.trim(); let content_val = content.trim();
if !content_val.is_empty() { if !content_val.is_empty() {

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[derive(JSTraceable, HeapSizeOf)] #[derive(JSTraceable, HeapSizeOf)]
pub enum HeadingLevel { pub enum HeadingLevel {
@ -27,7 +27,7 @@ pub struct HTMLHeadingElement {
} }
impl HTMLHeadingElement { impl HTMLHeadingElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document, document: &Document,
level: HeadingLevel) -> HTMLHeadingElement { level: HeadingLevel) -> HTMLHeadingElement {
@ -39,7 +39,7 @@ impl HTMLHeadingElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document, document: &Document,
level: HeadingLevel) -> Root<HTMLHeadingElement> { level: HeadingLevel) -> Root<HTMLHeadingElement> {

18
components/script/dom/htmlhrelement.rs
View file

@ -12,7 +12,7 @@ use dom::element::{Element, RawLayoutElementHelpers};
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::attr::{AttrValue, LengthOrPercentageOrAuto}; use style::attr::{AttrValue, LengthOrPercentageOrAuto};
#[dom_struct] #[dom_struct]
@ -21,14 +21,14 @@ pub struct HTMLHRElement {
} }
impl HTMLHRElement { impl HTMLHRElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLHRElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLHRElement {
HTMLHRElement { HTMLHRElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document) htmlelement: HTMLElement::new_inherited(local_name, prefix, document)
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLHRElement> { document: &Document) -> Root<HTMLHRElement> {
Node::reflect_node(box HTMLHRElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLHRElement::new_inherited(local_name, prefix, document),
@ -67,7 +67,7 @@ impl HTMLHRLayoutHelpers for LayoutJS<HTMLHRElement> {
fn get_color(&self) -> Option<RGBA> { fn get_color(&self) -> Option<RGBA> {
unsafe { unsafe {
(&*self.upcast::<Element>().unsafe_get()) (&*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("color")) .get_attr_for_layout(&ns!(), &local_name!("color"))
.and_then(AttrValue::as_color) .and_then(AttrValue::as_color)
.cloned() .cloned()
} }
@ -77,7 +77,7 @@ impl HTMLHRLayoutHelpers for LayoutJS<HTMLHRElement> {
fn get_width(&self) -> LengthOrPercentageOrAuto { fn get_width(&self) -> LengthOrPercentageOrAuto {
unsafe { unsafe {
(&*self.upcast::<Element>().unsafe_get()) (&*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("width")) .get_attr_for_layout(&ns!(), &local_name!("width"))
.map(AttrValue::as_dimension) .map(AttrValue::as_dimension)
.cloned() .cloned()
.unwrap_or(LengthOrPercentageOrAuto::Auto) .unwrap_or(LengthOrPercentageOrAuto::Auto)
@ -91,11 +91,11 @@ impl VirtualMethods for HTMLHRElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("align") => AttrValue::from_dimension(value.into()), &local_name!("align") => AttrValue::from_dimension(value.into()),
&atom!("color") => AttrValue::from_legacy_color(value.into()), &local_name!("color") => AttrValue::from_legacy_color(value.into()),
&atom!("width") => AttrValue::from_dimension(value.into()), &local_name!("width") => AttrValue::from_dimension(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLHtmlElement { pub struct HTMLHtmlElement {
@ -16,14 +16,14 @@ pub struct HTMLHtmlElement {
} }
impl HTMLHtmlElement { impl HTMLHtmlElement {
fn new_inherited(localName: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLHtmlElement { fn new_inherited(localName: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLHtmlElement {
HTMLHtmlElement { HTMLHtmlElement {
htmlelement: HTMLElement::new_inherited(localName, prefix, document) htmlelement: HTMLElement::new_inherited(localName, prefix, document)
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(localName: Atom, pub fn new(localName: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLHtmlElement> { document: &Document) -> Root<HTMLHtmlElement> {
Node::reflect_node(box HTMLHtmlElement::new_inherited(localName, prefix, document), Node::reflect_node(box HTMLHtmlElement::new_inherited(localName, prefix, document),

41
components/script/dom/htmliframeelement.rs
View file

@ -35,6 +35,7 @@ use dom::node::{Node, NodeDamage, UnbindContext, document_from_node, window_from
use dom::urlhelper::UrlHelper; use dom::urlhelper::UrlHelper;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use dom::window::{ReflowReason, Window}; use dom::window::{ReflowReason, Window};
use html5ever_atoms::LocalName;
use ipc_channel::ipc; use ipc_channel::ipc;
use js::jsapi::{JSAutoCompartment, JSContext, MutableHandleValue}; use js::jsapi::{JSAutoCompartment, JSContext, MutableHandleValue};
use js::jsval::{NullValue, UndefinedValue}; use js::jsval::{NullValue, UndefinedValue};
@ -43,8 +44,8 @@ use net_traits::response::HttpsState;
use script_layout_interface::message::ReflowQueryType; use script_layout_interface::message::ReflowQueryType;
use script_traits::{IFrameLoadInfo, LoadData, MozBrowserEvent, ScriptMsg as ConstellationMsg}; use script_traits::{IFrameLoadInfo, LoadData, MozBrowserEvent, ScriptMsg as ConstellationMsg};
use script_traits::IFrameSandboxState::{IFrameSandboxed, IFrameUnsandboxed}; use script_traits::IFrameSandboxState::{IFrameSandboxed, IFrameUnsandboxed};
use servo_atoms::Atom;
use std::cell::Cell; use std::cell::Cell;
use string_cache::Atom;
use style::attr::{AttrValue, LengthOrPercentageOrAuto}; use style::attr::{AttrValue, LengthOrPercentageOrAuto};
use style::context::ReflowGoal; use style::context::ReflowGoal;
use url::Url; use url::Url;
@ -84,7 +85,7 @@ impl HTMLIFrameElement {
/// step 1. /// step 1.
fn get_url(&self) -> Url { fn get_url(&self) -> Url {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
element.get_attribute(&ns!(), &atom!("src")).and_then(|src| { element.get_attribute(&ns!(), &local_name!("src")).and_then(|src| {
let url = src.value(); let url = src.value();
if url.is_empty() { if url.is_empty() {
None None
@ -178,7 +179,7 @@ impl HTMLIFrameElement {
self.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage); self.upcast::<Node>().dirty(NodeDamage::OtherNodeDamage);
} }
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLIFrameElement { document: &Document) -> HTMLIFrameElement {
HTMLIFrameElement { HTMLIFrameElement {
@ -193,7 +194,7 @@ impl HTMLIFrameElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLIFrameElement> { document: &Document) -> Root<HTMLIFrameElement> {
Node::reflect_node(box HTMLIFrameElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLIFrameElement::new_inherited(local_name, prefix, document),
@ -255,7 +256,7 @@ impl HTMLIFrameElement {
pub fn privatebrowsing(&self) -> bool { pub fn privatebrowsing(&self) -> bool {
if self.Mozbrowser() { if self.Mozbrowser() {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
element.has_attribute(&Atom::from("mozprivatebrowsing")) element.has_attribute(&LocalName::from("mozprivatebrowsing"))
} else { } else {
false false
} }
@ -290,7 +291,7 @@ impl HTMLIFrameElementLayoutMethods for LayoutJS<HTMLIFrameElement> {
fn get_width(&self) -> LengthOrPercentageOrAuto { fn get_width(&self) -> LengthOrPercentageOrAuto {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("width")) .get_attr_for_layout(&ns!(), &local_name!("width"))
.map(AttrValue::as_dimension) .map(AttrValue::as_dimension)
.cloned() .cloned()
.unwrap_or(LengthOrPercentageOrAuto::Auto) .unwrap_or(LengthOrPercentageOrAuto::Auto)
@ -301,7 +302,7 @@ impl HTMLIFrameElementLayoutMethods for LayoutJS<HTMLIFrameElement> {
fn get_height(&self) -> LengthOrPercentageOrAuto { fn get_height(&self) -> LengthOrPercentageOrAuto {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("height")) .get_attr_for_layout(&ns!(), &local_name!("height"))
.map(AttrValue::as_dimension) .map(AttrValue::as_dimension)
.cloned() .cloned()
.unwrap_or(LengthOrPercentageOrAuto::Auto) .unwrap_or(LengthOrPercentageOrAuto::Auto)
@ -425,17 +426,17 @@ pub fn Navigate(iframe: &HTMLIFrameElement, direction: TraversalDirection) -> Er
impl HTMLIFrameElementMethods for HTMLIFrameElement { impl HTMLIFrameElementMethods for HTMLIFrameElement {
// https://html.spec.whatwg.org/multipage/#dom-iframe-src // https://html.spec.whatwg.org/multipage/#dom-iframe-src
fn Src(&self) -> DOMString { fn Src(&self) -> DOMString {
self.upcast::<Element>().get_string_attribute(&atom!("src")) self.upcast::<Element>().get_string_attribute(&local_name!("src"))
} }
// https://html.spec.whatwg.org/multipage/#dom-iframe-src // https://html.spec.whatwg.org/multipage/#dom-iframe-src
fn SetSrc(&self, src: DOMString) { fn SetSrc(&self, src: DOMString) {
self.upcast::<Element>().set_url_attribute(&atom!("src"), src) self.upcast::<Element>().set_url_attribute(&local_name!("src"), src)
} }
// https://html.spec.whatwg.org/multipage/#dom-iframe-sandbox // https://html.spec.whatwg.org/multipage/#dom-iframe-sandbox
fn Sandbox(&self) -> Root<DOMTokenList> { fn Sandbox(&self) -> Root<DOMTokenList> {
self.sandbox.or_init(|| DOMTokenList::new(self.upcast::<Element>(), &atom!("sandbox"))) self.sandbox.or_init(|| DOMTokenList::new(self.upcast::<Element>(), &local_name!("sandbox")))
} }
// https://html.spec.whatwg.org/multipage/#dom-iframe-contentwindow // https://html.spec.whatwg.org/multipage/#dom-iframe-contentwindow
@ -469,7 +470,7 @@ impl HTMLIFrameElementMethods for HTMLIFrameElement {
fn Mozbrowser(&self) -> bool { fn Mozbrowser(&self) -> bool {
if window_from_node(self).is_mozbrowser() { if window_from_node(self).is_mozbrowser() {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
element.has_attribute(&atom!("mozbrowser")) element.has_attribute(&local_name!("mozbrowser"))
} else { } else {
false false
} }
@ -478,7 +479,7 @@ impl HTMLIFrameElementMethods for HTMLIFrameElement {
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-mozbrowser // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-mozbrowser
fn SetMozbrowser(&self, value: bool) { fn SetMozbrowser(&self, value: bool) {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
element.set_bool_attribute(&atom!("mozbrowser"), value); element.set_bool_attribute(&local_name!("mozbrowser"), value);
} }
// https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement/goBack // https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement/goBack
@ -552,13 +553,13 @@ impl HTMLIFrameElementMethods for HTMLIFrameElement {
// check-tidy: no specs after this line // check-tidy: no specs after this line
fn SetMozprivatebrowsing(&self, value: bool) { fn SetMozprivatebrowsing(&self, value: bool) {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
element.set_bool_attribute(&Atom::from("mozprivatebrowsing"), value); element.set_bool_attribute(&LocalName::from("mozprivatebrowsing"), value);
} }
fn Mozprivatebrowsing(&self) -> bool { fn Mozprivatebrowsing(&self) -> bool {
if window_from_node(self).is_mozbrowser() { if window_from_node(self).is_mozbrowser() {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
element.has_attribute(&Atom::from("mozprivatebrowsing")) element.has_attribute(&LocalName::from("mozprivatebrowsing"))
} else { } else {
false false
} }
@ -573,7 +574,7 @@ impl VirtualMethods for HTMLIFrameElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("sandbox") => { &local_name!("sandbox") => {
self.sandbox_allowance.set(mutation.new_value(attr).map(|value| { self.sandbox_allowance.set(mutation.new_value(attr).map(|value| {
let mut modes = ALLOW_NOTHING; let mut modes = ALLOW_NOTHING;
for token in value.as_tokens() { for token in value.as_tokens() {
@ -590,7 +591,7 @@ impl VirtualMethods for HTMLIFrameElement {
modes modes
})); }));
}, },
&atom!("src") => { &local_name!("src") => {
if let AttributeMutation::Set(_) = mutation { if let AttributeMutation::Set(_) = mutation {
if self.upcast::<Node>().is_in_doc() { if self.upcast::<Node>().is_in_doc() {
self.process_the_iframe_attributes(); self.process_the_iframe_attributes();
@ -601,11 +602,11 @@ impl VirtualMethods for HTMLIFrameElement {
} }
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("sandbox") => AttrValue::from_serialized_tokenlist(value.into()), &local_name!("sandbox") => AttrValue::from_serialized_tokenlist(value.into()),
&atom!("width") => AttrValue::from_dimension(value.into()), &local_name!("width") => AttrValue::from_dimension(value.into()),
&atom!("height") => AttrValue::from_dimension(value.into()), &local_name!("height") => AttrValue::from_dimension(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

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

@ -21,6 +21,7 @@ use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeDamage, document_from_node, window_from_node}; use dom::node::{Node, NodeDamage, document_from_node, window_from_node};
use dom::values::UNSIGNED_LONG_MAX; use dom::values::UNSIGNED_LONG_MAX;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use ipc_channel::ipc; use ipc_channel::ipc;
use ipc_channel::router::ROUTER; use ipc_channel::router::ROUTER;
use net_traits::image::base::{Image, ImageMetadata}; use net_traits::image::base::{Image, ImageMetadata};
@ -30,7 +31,6 @@ use script_runtime::ScriptThreadEventCategory::UpdateReplacedElement;
use script_thread::Runnable; use script_thread::Runnable;
use std::i32; use std::i32;
use std::sync::Arc; use std::sync::Arc;
use string_cache::Atom;
use style::attr::{AttrValue, LengthOrPercentageOrAuto}; use style::attr::{AttrValue, LengthOrPercentageOrAuto};
use task_source::TaskSource; use task_source::TaskSource;
use url::Url; use url::Url;
@ -195,7 +195,7 @@ impl HTMLImageElement {
} }
} }
} }
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLImageElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLImageElement {
HTMLImageElement { HTMLImageElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document), htmlelement: HTMLElement::new_inherited(local_name, prefix, document),
current_request: DOMRefCell::new(ImageRequest { current_request: DOMRefCell::new(ImageRequest {
@ -216,7 +216,7 @@ impl HTMLImageElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLImageElement> { document: &Document) -> Root<HTMLImageElement> {
Node::reflect_node(box HTMLImageElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLImageElement::new_inherited(local_name, prefix, document),
@ -228,7 +228,7 @@ impl HTMLImageElement {
width: Option<u32>, width: Option<u32>,
height: Option<u32>) -> Fallible<Root<HTMLImageElement>> { height: Option<u32>) -> Fallible<Root<HTMLImageElement>> {
let document = global.as_window().Document(); let document = global.as_window().Document();
let image = HTMLImageElement::new(atom!("img"), None, &document); let image = HTMLImageElement::new(local_name!("img"), None, &document);
if let Some(w) = width { if let Some(w) = width {
image.SetWidth(w); image.SetWidth(w);
} }
@ -266,7 +266,7 @@ impl LayoutHTMLImageElementHelpers for LayoutJS<HTMLImageElement> {
fn get_width(&self) -> LengthOrPercentageOrAuto { fn get_width(&self) -> LengthOrPercentageOrAuto {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("width")) .get_attr_for_layout(&ns!(), &local_name!("width"))
.map(AttrValue::as_dimension) .map(AttrValue::as_dimension)
.cloned() .cloned()
.unwrap_or(LengthOrPercentageOrAuto::Auto) .unwrap_or(LengthOrPercentageOrAuto::Auto)
@ -277,7 +277,7 @@ impl LayoutHTMLImageElementHelpers for LayoutJS<HTMLImageElement> {
fn get_height(&self) -> LengthOrPercentageOrAuto { fn get_height(&self) -> LengthOrPercentageOrAuto {
unsafe { unsafe {
(*self.upcast::<Element>().unsafe_get()) (*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("height")) .get_attr_for_layout(&ns!(), &local_name!("height"))
.map(AttrValue::as_dimension) .map(AttrValue::as_dimension)
.cloned() .cloned()
.unwrap_or(LengthOrPercentageOrAuto::Auto) .unwrap_or(LengthOrPercentageOrAuto::Auto)
@ -320,7 +320,7 @@ impl HTMLImageElementMethods for HTMLImageElement {
// https://html.spec.whatwg.org/multipage/#dom-img-width // https://html.spec.whatwg.org/multipage/#dom-img-width
fn SetWidth(&self, value: u32) { fn SetWidth(&self, value: u32) {
image_dimension_setter(self.upcast(), atom!("width"), value); image_dimension_setter(self.upcast(), local_name!("width"), value);
} }
// https://html.spec.whatwg.org/multipage/#dom-img-height // https://html.spec.whatwg.org/multipage/#dom-img-height
@ -332,7 +332,7 @@ impl HTMLImageElementMethods for HTMLImageElement {
// https://html.spec.whatwg.org/multipage/#dom-img-height // https://html.spec.whatwg.org/multipage/#dom-img-height
fn SetHeight(&self, value: u32) { fn SetHeight(&self, value: u32) {
image_dimension_setter(self.upcast(), atom!("height"), value); image_dimension_setter(self.upcast(), local_name!("height"), value);
} }
// https://html.spec.whatwg.org/multipage/#dom-img-naturalwidth // https://html.spec.whatwg.org/multipage/#dom-img-naturalwidth
@ -415,7 +415,7 @@ impl VirtualMethods for HTMLImageElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("src") => { &local_name!("src") => {
self.update_image(mutation.new_value(attr).map(|value| { self.update_image(mutation.new_value(attr).map(|value| {
// FIXME(ajeffrey): convert directly from AttrValue to DOMString // FIXME(ajeffrey): convert directly from AttrValue to DOMString
(DOMString::from(&**value), document_from_node(self).base_url()) (DOMString::from(&**value), document_from_node(self).base_url())
@ -425,17 +425,17 @@ impl VirtualMethods for HTMLImageElement {
} }
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("name") => AttrValue::from_atomic(value.into()), &local_name!("name") => AttrValue::from_atomic(value.into()),
&atom!("width") | &atom!("height") => AttrValue::from_dimension(value.into()), &local_name!("width") | &local_name!("height") => AttrValue::from_dimension(value.into()),
&atom!("hspace") | &atom!("vspace") => AttrValue::from_u32(value.into(), 0), &local_name!("hspace") | &local_name!("vspace") => AttrValue::from_u32(value.into(), 0),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }
} }
fn image_dimension_setter(element: &Element, attr: Atom, value: u32) { fn image_dimension_setter(element: &Element, attr: LocalName, value: u32) {
// This setter is a bit weird: the IDL type is unsigned long, but it's parsed as // This setter is a bit weird: the IDL type is unsigned long, but it's parsed as
// a dimension for rendering. // a dimension for rendering.
let value = if value > UNSIGNED_LONG_MAX { let value = if value > UNSIGNED_LONG_MAX {

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

@ -32,6 +32,7 @@ use dom::node::{document_from_node, window_from_node};
use dom::nodelist::NodeList; use dom::nodelist::NodeList;
use dom::validation::Validatable; use dom::validation::Validatable;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use ipc_channel::ipc::{self, IpcSender}; use ipc_channel::ipc::{self, IpcSender};
use mime_guess; use mime_guess;
use msg::constellation_msg::Key; use msg::constellation_msg::Key;
@ -39,10 +40,10 @@ use net_traits::{CoreResourceMsg, IpcSend};
use net_traits::blob_url_store::get_blob_origin; use net_traits::blob_url_store::get_blob_origin;
use net_traits::filemanager_thread::{FileManagerThreadMsg, FilterPattern}; use net_traits::filemanager_thread::{FileManagerThreadMsg, FilterPattern};
use script_traits::ScriptMsg as ConstellationMsg; use script_traits::ScriptMsg as ConstellationMsg;
use servo_atoms::Atom;
use std::borrow::ToOwned; use std::borrow::ToOwned;
use std::cell::Cell; use std::cell::Cell;
use std::ops::Range; use std::ops::Range;
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
use style::element_state::*; use style::element_state::*;
use style::str::split_commas; use style::str::split_commas;
@ -128,7 +129,7 @@ static DEFAULT_MAX_LENGTH: i32 = -1;
static DEFAULT_MIN_LENGTH: i32 = -1; static DEFAULT_MIN_LENGTH: i32 = -1;
impl HTMLInputElement { impl HTMLInputElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLInputElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLInputElement {
let chan = document.window().upcast::<GlobalScope>().constellation_chan().clone(); let chan = document.window().upcast::<GlobalScope>().constellation_chan().clone();
HTMLInputElement { HTMLInputElement {
htmlelement: htmlelement:
@ -154,7 +155,7 @@ impl HTMLInputElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLInputElement> { document: &Document) -> Root<HTMLInputElement> {
Node::reflect_node(box HTMLInputElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLInputElement::new_inherited(local_name, prefix, document),
@ -164,7 +165,7 @@ impl HTMLInputElement {
pub fn type_(&self) -> Atom { pub fn type_(&self) -> Atom {
self.upcast::<Element>() self.upcast::<Element>()
.get_attribute(&ns!(), &atom!("type")) .get_attribute(&ns!(), &local_name!("type"))
.map_or_else(|| atom!(""), |a| a.value().as_atom().to_owned()) .map_or_else(|| atom!(""), |a| a.value().as_atom().to_owned())
} }
@ -209,7 +210,7 @@ impl LayoutHTMLInputElementHelpers for LayoutJS<HTMLInputElement> {
unsafe fn get_raw_attr_value(input: LayoutJS<HTMLInputElement>, default: &str) -> String { unsafe fn get_raw_attr_value(input: LayoutJS<HTMLInputElement>, default: &str) -> String {
let elem = input.upcast::<Element>(); let elem = input.upcast::<Element>();
let value = (*elem.unsafe_get()) let value = (*elem.unsafe_get())
.get_attr_val_for_layout(&ns!(), &atom!("value")) .get_attr_val_for_layout(&ns!(), &local_name!("value"))
.unwrap_or(default); .unwrap_or(default);
String::from(value) String::from(value)
} }
@ -371,13 +372,13 @@ impl HTMLInputElementMethods for HTMLInputElement {
ValueMode::Value => self.textinput.borrow().get_content(), ValueMode::Value => self.textinput.borrow().get_content(),
ValueMode::Default => { ValueMode::Default => {
self.upcast::<Element>() self.upcast::<Element>()
.get_attribute(&ns!(), &atom!("value")) .get_attribute(&ns!(), &local_name!("value"))
.map_or(DOMString::from(""), .map_or(DOMString::from(""),
|a| DOMString::from(a.summarize().value)) |a| DOMString::from(a.summarize().value))
} }
ValueMode::DefaultOn => { ValueMode::DefaultOn => {
self.upcast::<Element>() self.upcast::<Element>()
.get_attribute(&ns!(), &atom!("value")) .get_attribute(&ns!(), &local_name!("value"))
.map_or(DOMString::from("on"), .map_or(DOMString::from("on"),
|a| DOMString::from(a.summarize().value)) |a| DOMString::from(a.summarize().value))
} }
@ -407,7 +408,7 @@ impl HTMLInputElementMethods for HTMLInputElement {
} }
ValueMode::Default | ValueMode::Default |
ValueMode::DefaultOn => { ValueMode::DefaultOn => {
self.upcast::<Element>().set_string_attribute(&atom!("value"), value); self.upcast::<Element>().set_string_attribute(&local_name!("value"), value);
} }
ValueMode::Filename => { ValueMode::Filename => {
if value.is_empty() { if value.is_empty() {
@ -734,7 +735,7 @@ impl HTMLInputElement {
fn radio_group_name(&self) -> Option<Atom> { fn radio_group_name(&self) -> Option<Atom> {
//TODO: determine form owner //TODO: determine form owner
self.upcast::<Element>() self.upcast::<Element>()
.get_attribute(&ns!(), &atom!("name")) .get_attribute(&ns!(), &local_name!("name"))
.map(|name| name.value().as_atom().clone()) .map(|name| name.value().as_atom().clone())
} }
@ -867,7 +868,7 @@ impl VirtualMethods for HTMLInputElement {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("disabled") => { &local_name!("disabled") => {
let disabled_state = match mutation { let disabled_state = match mutation {
AttributeMutation::Set(None) => true, AttributeMutation::Set(None) => true,
AttributeMutation::Set(Some(_)) => { AttributeMutation::Set(Some(_)) => {
@ -886,7 +887,7 @@ impl VirtualMethods for HTMLInputElement {
el.set_read_write_state(read_write); el.set_read_write_state(read_write);
} }
}, },
&atom!("checked") if !self.checked_changed.get() => { &local_name!("checked") if !self.checked_changed.get() => {
let checked_state = match mutation { let checked_state = match mutation {
AttributeMutation::Set(None) => true, AttributeMutation::Set(None) => true,
AttributeMutation::Set(Some(_)) => { AttributeMutation::Set(Some(_)) => {
@ -897,13 +898,13 @@ impl VirtualMethods for HTMLInputElement {
}; };
self.update_checked_state(checked_state, false); self.update_checked_state(checked_state, false);
}, },
&atom!("size") => { &local_name!("size") => {
let size = mutation.new_value(attr).map(|value| { let size = mutation.new_value(attr).map(|value| {
value.as_uint() value.as_uint()
}); });
self.size.set(size.unwrap_or(DEFAULT_INPUT_SIZE)); self.size.set(size.unwrap_or(DEFAULT_INPUT_SIZE));
} }
&atom!("type") => { &local_name!("type") => {
let el = self.upcast::<Element>(); let el = self.upcast::<Element>();
match mutation { match mutation {
AttributeMutation::Set(_) => { AttributeMutation::Set(_) => {
@ -948,7 +949,7 @@ impl VirtualMethods for HTMLInputElement {
// Step 2 // Step 2
(_, _, ValueMode::Value) if old_value_mode != ValueMode::Value => { (_, _, ValueMode::Value) if old_value_mode != ValueMode::Value => {
self.SetValue(self.upcast::<Element>() self.SetValue(self.upcast::<Element>()
.get_attribute(&ns!(), &atom!("value")) .get_attribute(&ns!(), &local_name!("value"))
.map_or(DOMString::from(""), .map_or(DOMString::from(""),
|a| DOMString::from(a.summarize().value))) |a| DOMString::from(a.summarize().value)))
.expect("Failed to set input value on type change to ValueMode::Value."); .expect("Failed to set input value on type change to ValueMode::Value.");
@ -987,17 +988,17 @@ impl VirtualMethods for HTMLInputElement {
self.update_placeholder_shown_state(); self.update_placeholder_shown_state();
}, },
&atom!("value") if !self.value_changed.get() => { &local_name!("value") if !self.value_changed.get() => {
let value = mutation.new_value(attr).map(|value| (**value).to_owned()); let value = mutation.new_value(attr).map(|value| (**value).to_owned());
self.textinput.borrow_mut().set_content( self.textinput.borrow_mut().set_content(
value.map_or(DOMString::new(), DOMString::from)); value.map_or(DOMString::new(), DOMString::from));
self.update_placeholder_shown_state(); self.update_placeholder_shown_state();
}, },
&atom!("name") if self.input_type.get() == InputType::InputRadio => { &local_name!("name") if self.input_type.get() == InputType::InputRadio => {
self.radio_group_updated( self.radio_group_updated(
mutation.new_value(attr).as_ref().map(|name| name.as_atom())); mutation.new_value(attr).as_ref().map(|name| name.as_atom()));
}, },
&atom!("maxlength") => { &local_name!("maxlength") => {
match *attr.value() { match *attr.value() {
AttrValue::Int(_, value) => { AttrValue::Int(_, value) => {
if value < 0 { if value < 0 {
@ -1009,7 +1010,7 @@ impl VirtualMethods for HTMLInputElement {
_ => panic!("Expected an AttrValue::Int"), _ => panic!("Expected an AttrValue::Int"),
} }
}, },
&atom!("minlength") => { &local_name!("minlength") => {
match *attr.value() { match *attr.value() {
AttrValue::Int(_, value) => { AttrValue::Int(_, value) => {
if value < 0 { if value < 0 {
@ -1021,7 +1022,7 @@ impl VirtualMethods for HTMLInputElement {
_ => panic!("Expected an AttrValue::Int"), _ => panic!("Expected an AttrValue::Int"),
} }
}, },
&atom!("placeholder") => { &local_name!("placeholder") => {
{ {
let mut placeholder = self.placeholder.borrow_mut(); let mut placeholder = self.placeholder.borrow_mut();
placeholder.clear(); placeholder.clear();
@ -1032,7 +1033,7 @@ impl VirtualMethods for HTMLInputElement {
} }
self.update_placeholder_shown_state(); self.update_placeholder_shown_state();
}, },
&atom!("readonly") if self.input_type.get() == InputType::InputText => { &local_name!("readonly") if self.input_type.get() == InputType::InputText => {
let el = self.upcast::<Element>(); let el = self.upcast::<Element>();
match mutation { match mutation {
AttributeMutation::Set(_) => { AttributeMutation::Set(_) => {
@ -1047,14 +1048,14 @@ impl VirtualMethods for HTMLInputElement {
} }
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("accept") => AttrValue::from_comma_separated_tokenlist(value.into()), &local_name!("accept") => AttrValue::from_comma_separated_tokenlist(value.into()),
&atom!("name") => AttrValue::from_atomic(value.into()), &local_name!("name") => AttrValue::from_atomic(value.into()),
&atom!("size") => AttrValue::from_limited_u32(value.into(), DEFAULT_INPUT_SIZE), &local_name!("size") => AttrValue::from_limited_u32(value.into(), DEFAULT_INPUT_SIZE),
&atom!("type") => AttrValue::from_atomic(value.into()), &local_name!("type") => AttrValue::from_atomic(value.into()),
&atom!("maxlength") => AttrValue::from_limited_i32(value.into(), DEFAULT_MAX_LENGTH), &local_name!("maxlength") => AttrValue::from_limited_i32(value.into(), DEFAULT_MAX_LENGTH),
&atom!("minlength") => AttrValue::from_limited_i32(value.into(), DEFAULT_MIN_LENGTH), &local_name!("minlength") => AttrValue::from_limited_i32(value.into(), DEFAULT_MIN_LENGTH),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

12
components/script/dom/htmllabelelement.rs
View file

@ -16,7 +16,7 @@ use dom::htmlelement::HTMLElement;
use dom::htmlformelement::{FormControl, HTMLFormElement}; use dom::htmlformelement::{FormControl, HTMLFormElement};
use dom::node::{document_from_node, Node}; use dom::node::{document_from_node, Node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::attr::AttrValue; use style::attr::AttrValue;
#[dom_struct] #[dom_struct]
@ -25,7 +25,7 @@ pub struct HTMLLabelElement {
} }
impl HTMLLabelElement { impl HTMLLabelElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLLabelElement { document: &Document) -> HTMLLabelElement {
HTMLLabelElement { HTMLLabelElement {
@ -35,7 +35,7 @@ impl HTMLLabelElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLLabelElement> { document: &Document) -> Root<HTMLLabelElement> {
Node::reflect_node(box HTMLLabelElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLLabelElement::new_inherited(local_name, prefix, document),
@ -102,7 +102,7 @@ impl HTMLLabelElementMethods for HTMLLabelElement {
return None; return None;
} }
let for_attr = match self.upcast::<Element>().get_attribute(&ns!(), &atom!("for")) { let for_attr = match self.upcast::<Element>().get_attribute(&ns!(), &local_name!("for")) {
Some(for_attr) => for_attr, Some(for_attr) => for_attr,
None => return self.first_labelable_descendant(), None => return self.first_labelable_descendant(),
}; };
@ -121,9 +121,9 @@ impl VirtualMethods for HTMLLabelElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("for") => AttrValue::from_atomic(value.into()), &local_name!("for") => AttrValue::from_atomic(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

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

@ -15,7 +15,7 @@ use dom::htmlfieldsetelement::HTMLFieldSetElement;
use dom::htmlformelement::{HTMLFormElement, FormControl}; use dom::htmlformelement::{HTMLFormElement, FormControl};
use dom::node::{Node, UnbindContext}; use dom::node::{Node, UnbindContext};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLLegendElement { pub struct HTMLLegendElement {
@ -23,7 +23,7 @@ pub struct HTMLLegendElement {
} }
impl HTMLLegendElement { impl HTMLLegendElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) document: &Document)
-> HTMLLegendElement { -> HTMLLegendElement {
@ -31,7 +31,7 @@ impl HTMLLegendElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) document: &Document)
-> Root<HTMLLegendElement> { -> Root<HTMLLegendElement> {

10
components/script/dom/htmllielement.rs
View file

@ -11,7 +11,7 @@ use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::attr::AttrValue; use style::attr::AttrValue;
#[dom_struct] #[dom_struct]
@ -20,14 +20,14 @@ pub struct HTMLLIElement {
} }
impl HTMLLIElement { impl HTMLLIElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLLIElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLLIElement {
HTMLLIElement { HTMLLIElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document) htmlelement: HTMLElement::new_inherited(local_name, prefix, document)
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLLIElement> { document: &Document) -> Root<HTMLLIElement> {
Node::reflect_node(box HTMLLIElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLLIElement::new_inherited(local_name, prefix, document),
@ -49,9 +49,9 @@ impl VirtualMethods for HTMLLIElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("value") => AttrValue::from_i32(value.into(), 0), &local_name!("value") => AttrValue::from_i32(value.into(), 0),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

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

@ -24,6 +24,7 @@ use dom::node::{Node, document_from_node, window_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use encoding::EncodingRef; use encoding::EncodingRef;
use encoding::all::UTF_8; use encoding::all::UTF_8;
use html5ever_atoms::LocalName;
use hyper::header::ContentType; use hyper::header::ContentType;
use hyper::mime::{Mime, TopLevel, SubLevel}; use hyper::mime::{Mime, TopLevel, SubLevel};
use hyper_serde::Serde; use hyper_serde::Serde;
@ -41,7 +42,6 @@ use std::cell::Cell;
use std::default::Default; use std::default::Default;
use std::mem; use std::mem;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
use style::media_queries::{MediaQueryList, parse_media_query_list}; use style::media_queries::{MediaQueryList, parse_media_query_list};
use style::parser::ParserContextExtraData; use style::parser::ParserContextExtraData;
@ -63,7 +63,7 @@ pub struct HTMLLinkElement {
} }
impl HTMLLinkElement { impl HTMLLinkElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document, fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document,
creator: ElementCreator) -> HTMLLinkElement { creator: ElementCreator) -> HTMLLinkElement {
HTMLLinkElement { HTMLLinkElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document), htmlelement: HTMLElement::new_inherited(local_name, prefix, document),
@ -74,7 +74,7 @@ impl HTMLLinkElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document, document: &Document,
creator: ElementCreator) -> Root<HTMLLinkElement> { creator: ElementCreator) -> Root<HTMLLinkElement> {
@ -88,7 +88,7 @@ impl HTMLLinkElement {
} }
} }
fn get_attr(element: &Element, local_name: &Atom) -> Option<String> { fn get_attr(element: &Element, local_name: &LocalName) -> Option<String> {
let elem = element.get_attribute(&ns!(), local_name); let elem = element.get_attribute(&ns!(), local_name);
elem.map(|e| { elem.map(|e| {
let value = e.value(); let value = e.value();
@ -139,26 +139,26 @@ impl VirtualMethods for HTMLLinkElement {
return; return;
} }
let rel = get_attr(self.upcast(), &atom!("rel")); let rel = get_attr(self.upcast(), &local_name!("rel"));
match attr.local_name() { match attr.local_name() {
&atom!("href") => { &local_name!("href") => {
if string_is_stylesheet(&rel) { if string_is_stylesheet(&rel) {
self.handle_stylesheet_url(&attr.value()); self.handle_stylesheet_url(&attr.value());
} else if is_favicon(&rel) { } else if is_favicon(&rel) {
let sizes = get_attr(self.upcast(), &atom!("sizes")); let sizes = get_attr(self.upcast(), &local_name!("sizes"));
self.handle_favicon_url(rel.as_ref().unwrap(), &attr.value(), &sizes); self.handle_favicon_url(rel.as_ref().unwrap(), &attr.value(), &sizes);
} }
}, },
&atom!("sizes") => { &local_name!("sizes") => {
if is_favicon(&rel) { if is_favicon(&rel) {
if let Some(ref href) = get_attr(self.upcast(), &atom!("href")) { if let Some(ref href) = get_attr(self.upcast(), &local_name!("href")) {
self.handle_favicon_url(rel.as_ref().unwrap(), href, &Some(attr.value().to_string())); self.handle_favicon_url(rel.as_ref().unwrap(), href, &Some(attr.value().to_string()));
} }
} }
}, },
&atom!("media") => { &local_name!("media") => {
if string_is_stylesheet(&rel) { if string_is_stylesheet(&rel) {
if let Some(href) = self.upcast::<Element>().get_attribute(&ns!(), &atom!("href")) { if let Some(href) = self.upcast::<Element>().get_attribute(&ns!(), &local_name!("href")) {
self.handle_stylesheet_url(&href.value()); self.handle_stylesheet_url(&href.value());
} }
} }
@ -167,9 +167,9 @@ impl VirtualMethods for HTMLLinkElement {
} }
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("rel") => AttrValue::from_serialized_tokenlist(value.into()), &local_name!("rel") => AttrValue::from_serialized_tokenlist(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }
@ -182,9 +182,9 @@ impl VirtualMethods for HTMLLinkElement {
if tree_in_doc { if tree_in_doc {
let element = self.upcast(); let element = self.upcast();
let rel = get_attr(element, &atom!("rel")); let rel = get_attr(element, &local_name!("rel"));
let href = get_attr(element, &atom!("href")); let href = get_attr(element, &local_name!("href"));
let sizes = get_attr(self.upcast(), &atom!("sizes")); let sizes = get_attr(self.upcast(), &local_name!("sizes"));
match href { match href {
Some(ref href) if string_is_stylesheet(&rel) => { Some(ref href) if string_is_stylesheet(&rel) => {
@ -221,7 +221,7 @@ impl HTMLLinkElement {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
let mq_attribute = element.get_attribute(&ns!(), &atom!("media")); let mq_attribute = element.get_attribute(&ns!(), &local_name!("media"));
let value = mq_attribute.r().map(|a| a.value()); let value = mq_attribute.r().map(|a| a.value());
let mq_str = match value { let mq_str = match value {
Some(ref value) => &***value, Some(ref value) => &***value,
@ -398,7 +398,7 @@ impl HTMLLinkElementMethods for HTMLLinkElement {
// https://html.spec.whatwg.org/multipage/#dom-link-rel // https://html.spec.whatwg.org/multipage/#dom-link-rel
fn SetRel(&self, rel: DOMString) { fn SetRel(&self, rel: DOMString) {
self.upcast::<Element>().set_tokenlist_attribute(&atom!("rel"), rel); self.upcast::<Element>().set_tokenlist_attribute(&local_name!("rel"), rel);
} }
// https://html.spec.whatwg.org/multipage/#dom-link-media // https://html.spec.whatwg.org/multipage/#dom-link-media
@ -421,7 +421,7 @@ impl HTMLLinkElementMethods for HTMLLinkElement {
// https://html.spec.whatwg.org/multipage/#dom-link-rellist // https://html.spec.whatwg.org/multipage/#dom-link-rellist
fn RelList(&self) -> Root<DOMTokenList> { fn RelList(&self) -> Root<DOMTokenList> {
self.rel_list.or_init(|| DOMTokenList::new(self.upcast(), &atom!("rel"))) self.rel_list.or_init(|| DOMTokenList::new(self.upcast(), &local_name!("rel")))
} }
// https://html.spec.whatwg.org/multipage/#dom-link-charset // https://html.spec.whatwg.org/multipage/#dom-link-charset

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLMapElement { pub struct HTMLMapElement {
@ -16,7 +16,7 @@ pub struct HTMLMapElement {
} }
impl HTMLMapElement { impl HTMLMapElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLMapElement { document: &Document) -> HTMLMapElement {
HTMLMapElement { HTMLMapElement {
@ -25,7 +25,7 @@ impl HTMLMapElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLMapElement> { document: &Document) -> Root<HTMLMapElement> {
Node::reflect_node(box HTMLMapElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLMapElement::new_inherited(local_name, prefix, document),

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

@ -27,15 +27,16 @@ use dom::htmlvideoelement::HTMLVideoElement;
use dom::mediaerror::MediaError; use dom::mediaerror::MediaError;
use dom::node::{window_from_node, document_from_node, Node, UnbindContext}; use dom::node::{window_from_node, document_from_node, Node, UnbindContext};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use ipc_channel::ipc; use ipc_channel::ipc;
use ipc_channel::router::ROUTER; use ipc_channel::router::ROUTER;
use net_traits::{FetchResponseListener, FetchMetadata, Metadata, NetworkError}; use net_traits::{FetchResponseListener, FetchMetadata, Metadata, NetworkError};
use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType}; use net_traits::request::{CredentialsMode, Destination, RequestInit, Type as RequestType};
use network_listener::{NetworkListener, PreInvoke}; use network_listener::{NetworkListener, PreInvoke};
use script_thread::{Runnable, ScriptThread}; use script_thread::{Runnable, ScriptThread};
use servo_atoms::Atom;
use std::cell::Cell; use std::cell::Cell;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use string_cache::Atom;
use task_source::TaskSource; use task_source::TaskSource;
use time::{self, Timespec, Duration}; use time::{self, Timespec, Duration};
use url::Url; use url::Url;
@ -224,7 +225,7 @@ pub struct HTMLMediaElement {
} }
impl HTMLMediaElement { impl HTMLMediaElement {
pub fn new_inherited(tag_name: Atom, pub fn new_inherited(tag_name: LocalName,
prefix: Option<DOMString>, document: &Document) prefix: Option<DOMString>, document: &Document)
-> HTMLMediaElement { -> HTMLMediaElement {
HTMLMediaElement { HTMLMediaElement {
@ -443,7 +444,7 @@ impl HTMLMediaElement {
let mode = if false { let mode = if false {
// TODO media provider object // TODO media provider object
ResourceSelectionMode::Object ResourceSelectionMode::Object
} else if let Some(attr) = self.upcast::<Element>().get_attribute(&ns!(), &atom!("src")) { } else if let Some(attr) = self.upcast::<Element>().get_attribute(&ns!(), &local_name!("src")) {
ResourceSelectionMode::Attribute(attr.Value().to_string()) ResourceSelectionMode::Attribute(attr.Value().to_string())
} else if false { } else if false {
// TODO <source> child // TODO <source> child
@ -770,7 +771,7 @@ impl VirtualMethods for HTMLMediaElement {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("src") => { &local_name!("src") => {
if mutation.new_value(attr).is_some() { if mutation.new_value(attr).is_some() {
self.media_element_load_algorithm(); self.media_element_load_algorithm();
} }

16
components/script/dom/htmlmetaelement.rs
View file

@ -16,10 +16,10 @@ use dom::htmlelement::HTMLElement;
use dom::htmlheadelement::HTMLHeadElement; use dom::htmlheadelement::HTMLHeadElement;
use dom::node::{Node, UnbindContext, document_from_node}; use dom::node::{Node, UnbindContext, document_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use parking_lot::RwLock; use parking_lot::RwLock;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::sync::Arc; use std::sync::Arc;
use string_cache::Atom;
use style::attr::AttrValue; use style::attr::AttrValue;
use style::str::HTML_SPACE_CHARACTERS; use style::str::HTML_SPACE_CHARACTERS;
use style::stylesheets::{Stylesheet, CSSRule, Origin}; use style::stylesheets::{Stylesheet, CSSRule, Origin};
@ -33,7 +33,7 @@ pub struct HTMLMetaElement {
} }
impl HTMLMetaElement { impl HTMLMetaElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLMetaElement { document: &Document) -> HTMLMetaElement {
HTMLMetaElement { HTMLMetaElement {
@ -43,7 +43,7 @@ impl HTMLMetaElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLMetaElement> { document: &Document) -> Root<HTMLMetaElement> {
Node::reflect_node(box HTMLMetaElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLMetaElement::new_inherited(local_name, prefix, document),
@ -57,7 +57,7 @@ impl HTMLMetaElement {
fn process_attributes(&self) { fn process_attributes(&self) {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
if let Some(name) = element.get_attribute(&ns!(), &atom!("name")).r() { if let Some(name) = element.get_attribute(&ns!(), &local_name!("name")).r() {
let name = name.value().to_ascii_lowercase(); let name = name.value().to_ascii_lowercase();
let name = name.trim_matches(HTML_SPACE_CHARACTERS); let name = name.trim_matches(HTML_SPACE_CHARACTERS);
@ -76,7 +76,7 @@ impl HTMLMetaElement {
return; return;
} }
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
if let Some(content) = element.get_attribute(&ns!(), &atom!("content")).r() { if let Some(content) = element.get_attribute(&ns!(), &local_name!("content")).r() {
let content = content.value(); let content = content.value();
if !content.is_empty() { if !content.is_empty() {
if let Some(translated_rule) = ViewportRule::from_meta(&**content) { if let Some(translated_rule) = ViewportRule::from_meta(&**content) {
@ -97,7 +97,7 @@ impl HTMLMetaElement {
fn process_referrer_attribute(&self) { fn process_referrer_attribute(&self) {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
if let Some(name) = element.get_attribute(&ns!(), &atom!("name")).r() { if let Some(name) = element.get_attribute(&ns!(), &local_name!("name")).r() {
let name = name.value().to_ascii_lowercase(); let name = name.value().to_ascii_lowercase();
let name = name.trim_matches(HTML_SPACE_CHARACTERS); let name = name.trim_matches(HTML_SPACE_CHARACTERS);
@ -146,9 +146,9 @@ impl VirtualMethods for HTMLMetaElement {
} }
} }
fn parse_plain_attribute(&self, name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, name: &LocalName, value: DOMString) -> AttrValue {
match name { match name {
&atom!("name") => AttrValue::from_atomic(value.into()), &local_name!("name") => AttrValue::from_atomic(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(name, value), _ => self.super_type().unwrap().parse_plain_attribute(name, value),
} }
} }

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

@ -10,7 +10,7 @@ use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use dom::nodelist::NodeList; use dom::nodelist::NodeList;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLMeterElement { pub struct HTMLMeterElement {
@ -18,7 +18,7 @@ pub struct HTMLMeterElement {
} }
impl HTMLMeterElement { impl HTMLMeterElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLMeterElement { document: &Document) -> HTMLMeterElement {
HTMLMeterElement { HTMLMeterElement {
@ -27,7 +27,7 @@ impl HTMLMeterElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLMeterElement> { document: &Document) -> Root<HTMLMeterElement> {
Node::reflect_node(box HTMLMeterElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLMeterElement::new_inherited(local_name, prefix, document),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLModElement { pub struct HTMLModElement {
@ -16,7 +16,7 @@ pub struct HTMLModElement {
} }
impl HTMLModElement { impl HTMLModElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLModElement { document: &Document) -> HTMLModElement {
HTMLModElement { HTMLModElement {
@ -26,7 +26,7 @@ impl HTMLModElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLModElement> { document: &Document) -> Root<HTMLModElement> {
Node::reflect_node(box HTMLModElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLModElement::new_inherited(local_name, prefix, document),

12
components/script/dom/htmlobjectelement.rs
View file

@ -17,9 +17,9 @@ use dom::node::{Node, window_from_node};
use dom::validation::Validatable; use dom::validation::Validatable;
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use net_traits::image::base::Image; use net_traits::image::base::Image;
use std::sync::Arc; use std::sync::Arc;
use string_cache::Atom;
#[dom_struct] #[dom_struct]
pub struct HTMLObjectElement { pub struct HTMLObjectElement {
@ -29,7 +29,7 @@ pub struct HTMLObjectElement {
} }
impl HTMLObjectElement { impl HTMLObjectElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLObjectElement { document: &Document) -> HTMLObjectElement {
HTMLObjectElement { HTMLObjectElement {
@ -40,7 +40,7 @@ impl HTMLObjectElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLObjectElement> { document: &Document) -> Root<HTMLObjectElement> {
Node::reflect_node(box HTMLObjectElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLObjectElement::new_inherited(local_name, prefix, document),
@ -60,8 +60,8 @@ impl<'a> ProcessDataURL for &'a HTMLObjectElement {
let elem = self.upcast::<Element>(); let elem = self.upcast::<Element>();
// TODO: support other values // TODO: support other values
match (elem.get_attribute(&ns!(), &atom!("type")), match (elem.get_attribute(&ns!(), &local_name!("type")),
elem.get_attribute(&ns!(), &atom!("data"))) { elem.get_attribute(&ns!(), &local_name!("data"))) {
(None, Some(_uri)) => { (None, Some(_uri)) => {
// TODO(gw): Prefetch the image here. // TODO(gw): Prefetch the image here.
} }
@ -99,7 +99,7 @@ impl VirtualMethods for HTMLObjectElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("data") => { &local_name!("data") => {
if let AttributeMutation::Set(_) = mutation { if let AttributeMutation::Set(_) = mutation {
self.process_data_url(); self.process_data_url();
} }

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLOListElement { pub struct HTMLOListElement {
@ -16,7 +16,7 @@ pub struct HTMLOListElement {
} }
impl HTMLOListElement { impl HTMLOListElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLOListElement { document: &Document) -> HTMLOListElement {
HTMLOListElement { HTMLOListElement {
@ -25,7 +25,7 @@ impl HTMLOListElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLOListElement> { document: &Document) -> Root<HTMLOListElement> {
Node::reflect_node(box HTMLOListElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLOListElement::new_inherited(local_name, prefix, document),

8
components/script/dom/htmloptgroupelement.rs
View file

@ -14,7 +14,7 @@ use dom::htmlelement::HTMLElement;
use dom::htmloptionelement::HTMLOptionElement; use dom::htmloptionelement::HTMLOptionElement;
use dom::node::Node; use dom::node::Node;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::element_state::*; use style::element_state::*;
#[dom_struct] #[dom_struct]
@ -23,7 +23,7 @@ pub struct HTMLOptGroupElement {
} }
impl HTMLOptGroupElement { impl HTMLOptGroupElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLOptGroupElement { document: &Document) -> HTMLOptGroupElement {
HTMLOptGroupElement { HTMLOptGroupElement {
@ -34,7 +34,7 @@ impl HTMLOptGroupElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLOptGroupElement> { document: &Document) -> Root<HTMLOptGroupElement> {
Node::reflect_node(box HTMLOptGroupElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLOptGroupElement::new_inherited(local_name, prefix, document),
@ -59,7 +59,7 @@ impl VirtualMethods for HTMLOptGroupElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("disabled") => { &local_name!("disabled") => {
let disabled_state = match mutation { let disabled_state = match mutation {
AttributeMutation::Set(None) => true, AttributeMutation::Set(None) => true,
AttributeMutation::Set(Some(_)) => { AttributeMutation::Set(Some(_)) => {

16
components/script/dom/htmloptionelement.rs
View file

@ -22,8 +22,8 @@ use dom::htmlselectelement::HTMLSelectElement;
use dom::node::{Node, UnbindContext}; use dom::node::{Node, UnbindContext};
use dom::text::Text; use dom::text::Text;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use std::cell::Cell; use std::cell::Cell;
use string_cache::Atom;
use style::element_state::*; use style::element_state::*;
use style::str::{split_html_space_chars, str_join}; use style::str::{split_html_space_chars, str_join};
@ -39,7 +39,7 @@ pub struct HTMLOptionElement {
} }
impl HTMLOptionElement { impl HTMLOptionElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLOptionElement { document: &Document) -> HTMLOptionElement {
HTMLOptionElement { HTMLOptionElement {
@ -52,7 +52,7 @@ impl HTMLOptionElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLOptionElement> { document: &Document) -> Root<HTMLOptionElement> {
Node::reflect_node(box HTMLOptionElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLOptionElement::new_inherited(local_name, prefix, document),
@ -82,7 +82,7 @@ impl HTMLOptionElement {
// FIXME(ajeffrey): Provide a way of buffering DOMStrings other than using Strings // FIXME(ajeffrey): Provide a way of buffering DOMStrings other than using Strings
fn collect_text(element: &Element, value: &mut String) { fn collect_text(element: &Element, value: &mut String) {
let svg_script = *element.namespace() == ns!(svg) && element.local_name() == &atom!("script"); let svg_script = *element.namespace() == ns!(svg) && element.local_name() == &local_name!("script");
let html_script = element.is::<HTMLScriptElement>(); let html_script = element.is::<HTMLScriptElement>();
if svg_script || html_script { if svg_script || html_script {
return; return;
@ -133,7 +133,7 @@ impl HTMLOptionElementMethods for HTMLOptionElement {
// https://html.spec.whatwg.org/multipage/#attr-option-value // https://html.spec.whatwg.org/multipage/#attr-option-value
fn Value(&self) -> DOMString { fn Value(&self) -> DOMString {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
let attr = &atom!("value"); let attr = &local_name!("value");
if element.has_attribute(attr) { if element.has_attribute(attr) {
element.get_string_attribute(attr) element.get_string_attribute(attr)
} else { } else {
@ -147,7 +147,7 @@ impl HTMLOptionElementMethods for HTMLOptionElement {
// https://html.spec.whatwg.org/multipage/#attr-option-label // https://html.spec.whatwg.org/multipage/#attr-option-label
fn Label(&self) -> DOMString { fn Label(&self) -> DOMString {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
let attr = &atom!("label"); let attr = &local_name!("label");
if element.has_attribute(attr) { if element.has_attribute(attr) {
element.get_string_attribute(attr) element.get_string_attribute(attr)
} else { } else {
@ -185,7 +185,7 @@ impl VirtualMethods for HTMLOptionElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match attr.local_name() { match attr.local_name() {
&atom!("disabled") => { &local_name!("disabled") => {
let el = self.upcast::<Element>(); let el = self.upcast::<Element>();
match mutation { match mutation {
AttributeMutation::Set(_) => { AttributeMutation::Set(_) => {
@ -199,7 +199,7 @@ impl VirtualMethods for HTMLOptionElement {
} }
} }
}, },
&atom!("selected") => { &local_name!("selected") => {
match mutation { match mutation {
AttributeMutation::Set(_) => { AttributeMutation::Set(_) => {
// https://html.spec.whatwg.org/multipage/#concept-option-selectedness // https://html.spec.whatwg.org/multipage/#concept-option-selectedness

2
components/script/dom/htmloptionscollection.rs
View file

@ -44,7 +44,7 @@ impl HTMLOptionsCollection {
let document = document_from_node(&*root); let document = document_from_node(&*root);
for _ in 0..count { for _ in 0..count {
let element = HTMLOptionElement::new(atom!("option"), None, &document); let element = HTMLOptionElement::new(local_name!("option"), None, &document);
let node = element.upcast::<Node>(); let node = element.upcast::<Node>();
try!(root.AppendChild(node)); try!(root.AppendChild(node));
}; };

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

@ -13,7 +13,7 @@ use dom::htmlformelement::{FormControl, HTMLFormElement};
use dom::node::{Node, window_from_node}; use dom::node::{Node, window_from_node};
use dom::nodelist::NodeList; use dom::nodelist::NodeList;
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLOutputElement { pub struct HTMLOutputElement {
@ -21,7 +21,7 @@ pub struct HTMLOutputElement {
} }
impl HTMLOutputElement { impl HTMLOutputElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLOutputElement { document: &Document) -> HTMLOutputElement {
HTMLOutputElement { HTMLOutputElement {
@ -31,7 +31,7 @@ impl HTMLOutputElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLOutputElement> { document: &Document) -> Root<HTMLOutputElement> {
Node::reflect_node(box HTMLOutputElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLOutputElement::new_inherited(local_name, prefix, document),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLParagraphElement { pub struct HTMLParagraphElement {
@ -16,7 +16,7 @@ pub struct HTMLParagraphElement {
} }
impl HTMLParagraphElement { impl HTMLParagraphElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLParagraphElement { document: &Document) -> HTMLParagraphElement {
HTMLParagraphElement { HTMLParagraphElement {
@ -26,7 +26,7 @@ impl HTMLParagraphElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLParagraphElement> { document: &Document) -> Root<HTMLParagraphElement> {
Node::reflect_node(box HTMLParagraphElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLParagraphElement::new_inherited(local_name, prefix, document),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLParamElement { pub struct HTMLParamElement {
@ -16,7 +16,7 @@ pub struct HTMLParamElement {
} }
impl HTMLParamElement { impl HTMLParamElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLParamElement { document: &Document) -> HTMLParamElement {
HTMLParamElement { HTMLParamElement {
@ -26,7 +26,7 @@ impl HTMLParamElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLParamElement> { document: &Document) -> Root<HTMLParamElement> {
Node::reflect_node(box HTMLParamElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLParamElement::new_inherited(local_name, prefix, document),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLPreElement { pub struct HTMLPreElement {
@ -16,7 +16,7 @@ pub struct HTMLPreElement {
} }
impl HTMLPreElement { impl HTMLPreElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLPreElement { document: &Document) -> HTMLPreElement {
HTMLPreElement { HTMLPreElement {
@ -26,7 +26,7 @@ impl HTMLPreElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLPreElement> { document: &Document) -> Root<HTMLPreElement> {
Node::reflect_node(box HTMLPreElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLPreElement::new_inherited(local_name, prefix, document),

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

@ -10,7 +10,7 @@ use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use dom::nodelist::NodeList; use dom::nodelist::NodeList;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLProgressElement { pub struct HTMLProgressElement {
@ -18,7 +18,7 @@ pub struct HTMLProgressElement {
} }
impl HTMLProgressElement { impl HTMLProgressElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLProgressElement { document: &Document) -> HTMLProgressElement {
HTMLProgressElement { HTMLProgressElement {
@ -28,7 +28,7 @@ impl HTMLProgressElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLProgressElement> { document: &Document) -> Root<HTMLProgressElement> {
Node::reflect_node(box HTMLProgressElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLProgressElement::new_inherited(local_name, prefix, document),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLQuoteElement { pub struct HTMLQuoteElement {
@ -16,7 +16,7 @@ pub struct HTMLQuoteElement {
} }
impl HTMLQuoteElement { impl HTMLQuoteElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLQuoteElement { document: &Document) -> HTMLQuoteElement {
HTMLQuoteElement { HTMLQuoteElement {
@ -26,7 +26,7 @@ impl HTMLQuoteElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLQuoteElement> { document: &Document) -> Root<HTMLQuoteElement> {
Node::reflect_node(box HTMLQuoteElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLQuoteElement::new_inherited(local_name, prefix, document),

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

@ -28,16 +28,17 @@ use dom::virtualmethods::VirtualMethods;
use encoding::label::encoding_from_whatwg_label; use encoding::label::encoding_from_whatwg_label;
use encoding::types::{DecoderTrap, EncodingRef}; use encoding::types::{DecoderTrap, EncodingRef};
use html5ever::tree_builder::NextParserState; use html5ever::tree_builder::NextParserState;
use html5ever_atoms::LocalName;
use ipc_channel::ipc; use ipc_channel::ipc;
use ipc_channel::router::ROUTER; use ipc_channel::router::ROUTER;
use js::jsval::UndefinedValue; use js::jsval::UndefinedValue;
use net_traits::{FetchMetadata, FetchResponseListener, Metadata, NetworkError}; use net_traits::{FetchMetadata, FetchResponseListener, Metadata, NetworkError};
use net_traits::request::{CORSSettings, CredentialsMode, Destination, RequestInit, RequestMode, Type as RequestType}; use net_traits::request::{CORSSettings, CredentialsMode, Destination, RequestInit, RequestMode, Type as RequestType};
use network_listener::{NetworkListener, PreInvoke}; use network_listener::{NetworkListener, PreInvoke};
use servo_atoms::Atom;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::cell::Cell; use std::cell::Cell;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use string_cache::Atom;
use style::str::{HTML_SPACE_CHARACTERS, StaticStringVec}; use style::str::{HTML_SPACE_CHARACTERS, StaticStringVec};
use url::Url; use url::Url;
@ -67,7 +68,7 @@ pub struct HTMLScriptElement {
} }
impl HTMLScriptElement { impl HTMLScriptElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document, fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document,
creator: ElementCreator) -> HTMLScriptElement { creator: ElementCreator) -> HTMLScriptElement {
HTMLScriptElement { HTMLScriptElement {
htmlelement: htmlelement:
@ -82,7 +83,7 @@ impl HTMLScriptElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, prefix: Option<DOMString>, document: &Document, pub fn new(local_name: LocalName, prefix: Option<DOMString>, document: &Document,
creator: ElementCreator) -> Root<HTMLScriptElement> { creator: ElementCreator) -> Root<HTMLScriptElement> {
Node::reflect_node(box HTMLScriptElement::new_inherited(local_name, prefix, document, creator), Node::reflect_node(box HTMLScriptElement::new_inherited(local_name, prefix, document, creator),
document, document,
@ -286,7 +287,7 @@ impl HTMLScriptElement {
// Step 3. // Step 3.
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
let async = element.has_attribute(&atom!("async")); let async = element.has_attribute(&local_name!("async"));
// Note: confusingly, this is done if the element does *not* have an "async" attribute. // Note: confusingly, this is done if the element does *not* have an "async" attribute.
if was_parser_inserted && !async { if was_parser_inserted && !async {
self.non_blocking.set(true); self.non_blocking.set(true);
@ -294,7 +295,7 @@ impl HTMLScriptElement {
// Step 4. // Step 4.
let text = self.Text(); let text = self.Text();
if text.is_empty() && !element.has_attribute(&atom!("src")) { if text.is_empty() && !element.has_attribute(&local_name!("src")) {
return NextParserState::Continue; return NextParserState::Continue;
} }
@ -331,8 +332,8 @@ impl HTMLScriptElement {
// TODO(#4577): Step 11: CSP. // TODO(#4577): Step 11: CSP.
// Step 12. // Step 12.
let for_attribute = element.get_attribute(&ns!(), &atom!("for")); let for_attribute = element.get_attribute(&ns!(), &local_name!("for"));
let event_attribute = element.get_attribute(&ns!(), &atom!("event")); let event_attribute = element.get_attribute(&ns!(), &local_name!("event"));
match (for_attribute.r(), event_attribute.r()) { match (for_attribute.r(), event_attribute.r()) {
(Some(for_attribute), Some(event_attribute)) => { (Some(for_attribute), Some(event_attribute)) => {
let for_value = for_attribute.value().to_ascii_lowercase(); let for_value = for_attribute.value().to_ascii_lowercase();
@ -351,7 +352,7 @@ impl HTMLScriptElement {
} }
// Step 13. // Step 13.
let encoding = element.get_attribute(&ns!(), &atom!("charset")) let encoding = element.get_attribute(&ns!(), &local_name!("charset"))
.and_then(|charset| encoding_from_whatwg_label(&charset.value())) .and_then(|charset| encoding_from_whatwg_label(&charset.value()))
.unwrap_or_else(|| doc.encoding()); .unwrap_or_else(|| doc.encoding());
@ -370,7 +371,7 @@ impl HTMLScriptElement {
// TODO: Step 17: environment settings object. // TODO: Step 17: environment settings object.
let base_url = doc.base_url(); let base_url = doc.base_url();
let is_external = match element.get_attribute(&ns!(), &atom!("src")) { let is_external = match element.get_attribute(&ns!(), &local_name!("src")) {
// Step 18. // Step 18.
Some(ref src) => { Some(ref src) => {
// Step 18.1. // Step 18.1.
@ -402,7 +403,7 @@ impl HTMLScriptElement {
}; };
// Step 20. // Step 20.
let deferred = element.has_attribute(&atom!("defer")); let deferred = element.has_attribute(&local_name!("defer"));
// Step 20.a: classic, has src, has defer, was parser-inserted, is not async. // Step 20.a: classic, has src, has defer, was parser-inserted, is not async.
if is_external && if is_external &&
deferred && deferred &&
@ -555,7 +556,7 @@ impl HTMLScriptElement {
pub fn is_javascript(&self) -> bool { pub fn is_javascript(&self) -> bool {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
let type_attr = element.get_attribute(&ns!(), &atom!("type")); let type_attr = element.get_attribute(&ns!(), &local_name!("type"));
let is_js = match type_attr.as_ref().map(|s| s.value()) { let is_js = match type_attr.as_ref().map(|s| s.value()) {
Some(ref s) if s.is_empty() => { Some(ref s) if s.is_empty() => {
// type attr exists, but empty means js // type attr exists, but empty means js
@ -568,7 +569,7 @@ impl HTMLScriptElement {
}, },
None => { None => {
debug!("no script type"); debug!("no script type");
let language_attr = element.get_attribute(&ns!(), &atom!("language")); let language_attr = element.get_attribute(&ns!(), &local_name!("language"));
let is_js = match language_attr.as_ref().map(|s| s.value()) { let is_js = match language_attr.as_ref().map(|s| s.value()) {
Some(ref s) if s.is_empty() => { Some(ref s) if s.is_empty() => {
debug!("script language empty, inferring js"); debug!("script language empty, inferring js");
@ -615,7 +616,7 @@ impl VirtualMethods for HTMLScriptElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
match *attr.local_name() { match *attr.local_name() {
atom!("src") => { local_name!("src") => {
if let AttributeMutation::Set(_) = mutation { if let AttributeMutation::Set(_) = mutation {
if !self.parser_inserted.get() && self.upcast::<Node>().is_in_doc() { if !self.parser_inserted.get() && self.upcast::<Node>().is_in_doc() {
self.prepare(); self.prepare();
@ -692,7 +693,7 @@ impl HTMLScriptElementMethods for HTMLScriptElement {
// https://html.spec.whatwg.org/multipage/#dom-script-crossorigin // https://html.spec.whatwg.org/multipage/#dom-script-crossorigin
fn GetCrossOrigin(&self) -> Option<DOMString> { fn GetCrossOrigin(&self) -> Option<DOMString> {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
let attr = element.get_attribute(&ns!(), &atom!("crossorigin")); let attr = element.get_attribute(&ns!(), &local_name!("crossorigin"));
if let Some(mut val) = attr.map(|v| v.Value()) { if let Some(mut val) = attr.map(|v| v.Value()) {
val.make_ascii_lowercase(); val.make_ascii_lowercase();
@ -708,9 +709,9 @@ impl HTMLScriptElementMethods for HTMLScriptElement {
fn SetCrossOrigin(&self, value: Option<DOMString>) { fn SetCrossOrigin(&self, value: Option<DOMString>) {
let element = self.upcast::<Element>(); let element = self.upcast::<Element>();
match value { match value {
Some(val) => element.set_string_attribute(&atom!("crossorigin"), val), Some(val) => element.set_string_attribute(&local_name!("crossorigin"), val),
None => { None => {
element.remove_attribute(&ns!(), &atom!("crossorigin")); element.remove_attribute(&ns!(), &local_name!("crossorigin"));
} }
} }
} }

12
components/script/dom/htmlselectelement.rs
View file

@ -30,7 +30,7 @@ use dom::nodelist::NodeList;
use dom::validation::Validatable; use dom::validation::Validatable;
use dom::validitystate::ValidityState; use dom::validitystate::ValidityState;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::attr::AttrValue; use style::attr::AttrValue;
use style::element_state::*; use style::element_state::*;
@ -64,7 +64,7 @@ pub struct HTMLSelectElement {
static DEFAULT_SELECT_SIZE: u32 = 0; static DEFAULT_SELECT_SIZE: u32 = 0;
impl HTMLSelectElement { impl HTMLSelectElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLSelectElement { document: &Document) -> HTMLSelectElement {
HTMLSelectElement { HTMLSelectElement {
@ -76,7 +76,7 @@ impl HTMLSelectElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLSelectElement> { document: &Document) -> Root<HTMLSelectElement> {
Node::reflect_node(box HTMLSelectElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLSelectElement::new_inherited(local_name, prefix, document),
@ -338,7 +338,7 @@ impl VirtualMethods for HTMLSelectElement {
fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) { fn attribute_mutated(&self, attr: &Attr, mutation: AttributeMutation) {
self.super_type().unwrap().attribute_mutated(attr, mutation); self.super_type().unwrap().attribute_mutated(attr, mutation);
if attr.local_name() == &atom!("disabled") { if attr.local_name() == &local_name!("disabled") {
let el = self.upcast::<Element>(); let el = self.upcast::<Element>();
match mutation { match mutation {
AttributeMutation::Set(_) => { AttributeMutation::Set(_) => {
@ -374,9 +374,9 @@ impl VirtualMethods for HTMLSelectElement {
} }
} }
fn parse_plain_attribute(&self, local_name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, local_name: &LocalName, value: DOMString) -> AttrValue {
match *local_name { match *local_name {
atom!("size") => AttrValue::from_u32(value.into(), DEFAULT_SELECT_SIZE), local_name!("size") => AttrValue::from_u32(value.into(), DEFAULT_SELECT_SIZE),
_ => self.super_type().unwrap().parse_plain_attribute(local_name, value), _ => self.super_type().unwrap().parse_plain_attribute(local_name, value),
} }
} }

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLSourceElement { pub struct HTMLSourceElement {
@ -16,7 +16,7 @@ pub struct HTMLSourceElement {
} }
impl HTMLSourceElement { impl HTMLSourceElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLSourceElement { document: &Document) -> HTMLSourceElement {
HTMLSourceElement { HTMLSourceElement {
@ -26,7 +26,7 @@ impl HTMLSourceElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLSourceElement> { document: &Document) -> Root<HTMLSourceElement> {
Node::reflect_node(box HTMLSourceElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLSourceElement::new_inherited(local_name, prefix, document),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLSpanElement { pub struct HTMLSpanElement {
@ -16,14 +16,14 @@ pub struct HTMLSpanElement {
} }
impl HTMLSpanElement { impl HTMLSpanElement {
fn new_inherited(local_name: Atom, prefix: Option<DOMString>, document: &Document) -> HTMLSpanElement { fn new_inherited(local_name: LocalName, prefix: Option<DOMString>, document: &Document) -> HTMLSpanElement {
HTMLSpanElement { HTMLSpanElement {
htmlelement: HTMLElement::new_inherited(local_name, prefix, document) htmlelement: HTMLElement::new_inherited(local_name, prefix, document)
} }
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLSpanElement> { document: &Document) -> Root<HTMLSpanElement> {
Node::reflect_node(box HTMLSpanElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLSpanElement::new_inherited(local_name, prefix, document),

8
components/script/dom/htmlstyleelement.rs
View file

@ -14,9 +14,9 @@ use dom::element::Element;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{ChildrenMutation, Node, document_from_node, window_from_node}; use dom::node::{ChildrenMutation, Node, document_from_node, window_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use html5ever_atoms::LocalName;
use script_layout_interface::message::Msg; use script_layout_interface::message::Msg;
use std::sync::Arc; use std::sync::Arc;
use string_cache::Atom;
use style::media_queries::parse_media_query_list; use style::media_queries::parse_media_query_list;
use style::parser::ParserContextExtraData; use style::parser::ParserContextExtraData;
use style::stylesheets::{Stylesheet, Origin}; use style::stylesheets::{Stylesheet, Origin};
@ -29,7 +29,7 @@ pub struct HTMLStyleElement {
} }
impl HTMLStyleElement { impl HTMLStyleElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLStyleElement { document: &Document) -> HTMLStyleElement {
HTMLStyleElement { HTMLStyleElement {
@ -39,7 +39,7 @@ impl HTMLStyleElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLStyleElement> { document: &Document) -> Root<HTMLStyleElement> {
Node::reflect_node(box HTMLStyleElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLStyleElement::new_inherited(local_name, prefix, document),
@ -55,7 +55,7 @@ impl HTMLStyleElement {
let win = window_from_node(node); let win = window_from_node(node);
let url = win.get_url(); let url = win.get_url();
let mq_attribute = element.get_attribute(&ns!(), &atom!("media")); let mq_attribute = element.get_attribute(&ns!(), &local_name!("media"));
let mq_str = match mq_attribute { let mq_str = match mq_attribute {
Some(a) => String::from(&**a.value()), Some(a) => String::from(&**a.value()),
None => String::new(), None => String::new(),

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLTableCaptionElement { pub struct HTMLTableCaptionElement {
@ -16,7 +16,7 @@ pub struct HTMLTableCaptionElement {
} }
impl HTMLTableCaptionElement { impl HTMLTableCaptionElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLTableCaptionElement { document: &Document) -> HTMLTableCaptionElement {
HTMLTableCaptionElement { HTMLTableCaptionElement {
@ -26,7 +26,7 @@ impl HTMLTableCaptionElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLTableCaptionElement> { document: &Document) -> Root<HTMLTableCaptionElement> {
Node::reflect_node(box HTMLTableCaptionElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLTableCaptionElement::new_inherited(local_name, prefix, document),

18
components/script/dom/htmltablecellelement.rs
View file

@ -14,7 +14,7 @@ use dom::htmlelement::HTMLElement;
use dom::htmltablerowelement::HTMLTableRowElement; use dom::htmltablerowelement::HTMLTableRowElement;
use dom::node::Node; use dom::node::Node;
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use string_cache::Atom; use html5ever_atoms::LocalName;
use style::attr::{AttrValue, LengthOrPercentageOrAuto}; use style::attr::{AttrValue, LengthOrPercentageOrAuto};
const DEFAULT_COLSPAN: u32 = 1; const DEFAULT_COLSPAN: u32 = 1;
@ -25,7 +25,7 @@ pub struct HTMLTableCellElement {
} }
impl HTMLTableCellElement { impl HTMLTableCellElement {
pub fn new_inherited(tag_name: Atom, pub fn new_inherited(tag_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) document: &Document)
-> HTMLTableCellElement { -> HTMLTableCellElement {
@ -88,7 +88,7 @@ impl HTMLTableCellElementLayoutHelpers for LayoutJS<HTMLTableCellElement> {
fn get_background_color(&self) -> Option<RGBA> { fn get_background_color(&self) -> Option<RGBA> {
unsafe { unsafe {
(&*self.upcast::<Element>().unsafe_get()) (&*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("bgcolor")) .get_attr_for_layout(&ns!(), &local_name!("bgcolor"))
.and_then(AttrValue::as_color) .and_then(AttrValue::as_color)
.cloned() .cloned()
} }
@ -97,7 +97,7 @@ impl HTMLTableCellElementLayoutHelpers for LayoutJS<HTMLTableCellElement> {
fn get_colspan(&self) -> Option<u32> { fn get_colspan(&self) -> Option<u32> {
unsafe { unsafe {
(&*self.upcast::<Element>().unsafe_get()) (&*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("colspan")) .get_attr_for_layout(&ns!(), &local_name!("colspan"))
.map(AttrValue::as_uint) .map(AttrValue::as_uint)
} }
} }
@ -105,7 +105,7 @@ impl HTMLTableCellElementLayoutHelpers for LayoutJS<HTMLTableCellElement> {
fn get_width(&self) -> LengthOrPercentageOrAuto { fn get_width(&self) -> LengthOrPercentageOrAuto {
unsafe { unsafe {
(&*self.upcast::<Element>().unsafe_get()) (&*self.upcast::<Element>().unsafe_get())
.get_attr_for_layout(&ns!(), &atom!("width")) .get_attr_for_layout(&ns!(), &local_name!("width"))
.map(AttrValue::as_dimension) .map(AttrValue::as_dimension)
.cloned() .cloned()
.unwrap_or(LengthOrPercentageOrAuto::Auto) .unwrap_or(LengthOrPercentageOrAuto::Auto)
@ -118,11 +118,11 @@ impl VirtualMethods for HTMLTableCellElement {
Some(self.upcast::<HTMLElement>() as &VirtualMethods) Some(self.upcast::<HTMLElement>() as &VirtualMethods)
} }
fn parse_plain_attribute(&self, local_name: &Atom, value: DOMString) -> AttrValue { fn parse_plain_attribute(&self, local_name: &LocalName, value: DOMString) -> AttrValue {
match *local_name { match *local_name {
atom!("colspan") => AttrValue::from_u32(value.into(), DEFAULT_COLSPAN), local_name!("colspan") => AttrValue::from_u32(value.into(), DEFAULT_COLSPAN),
atom!("bgcolor") => AttrValue::from_legacy_color(value.into()), local_name!("bgcolor") => AttrValue::from_legacy_color(value.into()),
atom!("width") => AttrValue::from_nonzero_dimension(value.into()), local_name!("width") => AttrValue::from_nonzero_dimension(value.into()),
_ => self.super_type().unwrap().parse_plain_attribute(local_name, value), _ => self.super_type().unwrap().parse_plain_attribute(local_name, value),
} }
} }

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

@ -8,7 +8,7 @@ use dom::bindings::str::DOMString;
use dom::document::Document; use dom::document::Document;
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::Node; use dom::node::Node;
use string_cache::Atom; use html5ever_atoms::LocalName;
#[dom_struct] #[dom_struct]
pub struct HTMLTableColElement { pub struct HTMLTableColElement {
@ -16,7 +16,7 @@ pub struct HTMLTableColElement {
} }
impl HTMLTableColElement { impl HTMLTableColElement {
fn new_inherited(local_name: Atom, fn new_inherited(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> HTMLTableColElement { document: &Document) -> HTMLTableColElement {
HTMLTableColElement { HTMLTableColElement {
@ -26,7 +26,7 @@ impl HTMLTableColElement {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(local_name: Atom, pub fn new(local_name: LocalName,
prefix: Option<DOMString>, prefix: Option<DOMString>,
document: &Document) -> Root<HTMLTableColElement> { document: &Document) -> Root<HTMLTableColElement> {
Node::reflect_node(box HTMLTableColElement::new_inherited(local_name, prefix, document), Node::reflect_node(box HTMLTableColElement::new_inherited(local_name, prefix, document),

Some files were not shown because too many files have changed in this diff Show more