style: Address review comments relating to bgcolor and column spans

components/script/dom/bindings/trace.rs

@@ -32,6 +32,7 @@ use dom::bindings::utils::{Reflectable, Reflector, WindowProxyHandler};
 use dom::node::{Node, TrustedNodeAddress};
 
 use collections::hash::{Hash, Hasher};
+use cssparser::RGBA;
 use geom::rect::Rect;
 use html5ever::tree_builder::QuirksMode;
 use hyper::header::Headers;
@@ -48,7 +49,7 @@ use script_traits::UntrustedNodeAddress;
 use servo_msg::compositor_msg::ScriptListener;
 use servo_msg::constellation_msg::ConstellationChan;
 use servo_util::smallvec::{SmallVec1, SmallVec};
-use servo_util::str::{LengthOrPercentageOrAuto, SimpleColor};
+use servo_util::str::{LengthOrPercentageOrAuto};
 use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::comm::{Receiver, Sender};
@@ -214,7 +215,7 @@ no_jsmanaged_fields!(LayoutChan)
 no_jsmanaged_fields!(WindowProxyHandler)
 no_jsmanaged_fields!(UntrustedNodeAddress)
 no_jsmanaged_fields!(LengthOrPercentageOrAuto)
-no_jsmanaged_fields!(SimpleColor)
+no_jsmanaged_fields!(RGBA)
 
 impl<'a> JSTraceable for &'a str {
     #[inline]

components/script/dom/element.rs

@@ -19,7 +19,8 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, ElementDerived, EventTar
 use dom::bindings::codegen::InheritTypes::{HTMLBodyElementDerived, HTMLInputElementCast};
 use dom::bindings::codegen::InheritTypes::{HTMLInputElementDerived, HTMLTableElementCast};
 use dom::bindings::codegen::InheritTypes::{HTMLTableElementDerived, HTMLTableCellElementDerived};
-use dom::bindings::codegen::InheritTypes::{NodeCast};
+use dom::bindings::codegen::InheritTypes::{HTMLTableRowElementDerived};
+use dom::bindings::codegen::InheritTypes::{HTMLTableSectionElementDerived, NodeCast};
 use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, TemporaryPushable};
 use dom::bindings::js::{OptionalRootable, Root};
 use dom::bindings::utils::{Reflectable, Reflector};
@@ -38,19 +39,22 @@ use dom::htmlinputelement::{HTMLInputElement, RawLayoutHTMLInputElementHelpers};
 use dom::htmlserializer::serialize;
 use dom::htmltableelement::{HTMLTableElement, HTMLTableElementHelpers};
 use dom::htmltablecellelement::{HTMLTableCellElement, HTMLTableCellElementHelpers};
+use dom::htmltablerowelement::{HTMLTableRowElement, HTMLTableRowElementHelpers};
+use dom::htmltablesectionelement::{HTMLTableSectionElement, HTMLTableSectionElementHelpers};
 use dom::node::{CLICK_IN_PROGRESS, ElementNodeTypeId, LayoutNodeHelpers, Node, NodeHelpers};
 use dom::node::{NodeIterator, NodeStyleDamaged, OtherNodeDamage, document_from_node};
 use dom::node::{window_from_node};
 use dom::nodelist::NodeList;
 use dom::virtualmethods::{VirtualMethods, vtable_for};
 use devtools_traits::AttrInfo;
-use style::{mod, BgColorSimpleColorAttribute, BorderUnsignedIntegerAttribute};
-use style::{ColSpanUnsignedIntegerAttribute, IntegerAttribute, LengthAttribute};
+use style::{mod, AuthorOrigin, BgColorSimpleColorAttribute, BorderUnsignedIntegerAttribute};
+use style::{ColSpanUnsignedIntegerAttribute, IntegerAttribute, LengthAttribute, ParserContext};
 use style::{SimpleColorAttribute, SizeIntegerAttribute, UnsignedIntegerAttribute};
-use style::{WidthLengthAttribute, matches, parse_selector_list_from_str};
+use style::{WidthLengthAttribute, matches};
 use servo_util::namespace;
-use servo_util::str::{DOMString, LengthOrPercentageOrAuto, SimpleColor};
+use servo_util::str::{DOMString, LengthOrPercentageOrAuto};
 
+use cssparser::RGBA;
 use std::ascii::AsciiExt;
 use std::cell::{Ref, RefMut};
 use std::default::Default;
@@ -210,7 +214,7 @@ pub trait RawLayoutElementHelpers {
     unsafe fn get_unsigned_integer_attribute_for_layout(&self, attribute: UnsignedIntegerAttribute)
                                                         -> Option<u32>;
     unsafe fn get_simple_color_attribute_for_layout(&self, attribute: SimpleColorAttribute)
-                                                    -> Option<SimpleColor>;
+                                                    -> Option<RGBA>;
     fn local_name<'a>(&'a self) -> &'a Atom;
     fn namespace<'a>(&'a self) -> &'a Namespace;
     fn style_attribute<'a>(&'a self) -> &'a DOMRefCell<Option<style::PropertyDeclarationBlock>>;
@@ -341,9 +345,6 @@ impl RawLayoutElementHelpers for Element {
                 if self.is_htmltableelement() {
                     let this: &HTMLTableElement = mem::transmute(self);
                     this.get_border()
-                } else if self.is_htmltablecellelement() {
-                    let this: &HTMLTableCellElement = mem::transmute(self);
-                    this.get_border()
                 } else {
                     // Don't panic since `:-servo-nonzero-border` can cause this to be called on
                     // arbitrary elements.
@@ -355,7 +356,9 @@ impl RawLayoutElementHelpers for Element {
                     let this: &HTMLTableCellElement = mem::transmute(self);
                     this.get_colspan()
                 } else {
-                    panic!("I'm not a table cell!")
+                    // Don't panic since `display` can cause this to be called on arbitrary
+                    // elements.
+                    None
                 }
             }
         }
@@ -364,7 +367,7 @@ impl RawLayoutElementHelpers for Element {
     #[inline]
     #[allow(unrooted_must_root)]
     unsafe fn get_simple_color_attribute_for_layout(&self, attribute: SimpleColorAttribute)
-                                                    -> Option<SimpleColor> {
+                                                    -> Option<RGBA> {
         match attribute {
             BgColorSimpleColorAttribute => {
                 if self.is_htmlbodyelement() {
@@ -376,8 +379,14 @@ impl RawLayoutElementHelpers for Element {
                 } else if self.is_htmltablecellelement() {
                     let this: &HTMLTableCellElement = mem::transmute(self);
                     this.get_background_color()
+                } else if self.is_htmltablerowelement() {
+                    let this: &HTMLTableRowElement = mem::transmute(self);
+                    this.get_background_color()
+                } else if self.is_htmltablesectionelement() {
+                    let this: &HTMLTableSectionElement = mem::transmute(self);
+                    this.get_background_color()
                 } else {
-                    panic!("I'm not a body, table, or table cell!")
+                    None
                 }
             }
         }
@@ -1011,7 +1020,10 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
 
     // http://dom.spec.whatwg.org/#dom-element-matches
     fn Matches(self, selectors: DOMString) -> Fallible<bool> {
-        match parse_selector_list_from_str(selectors.as_slice()) {
+        let parser_context = ParserContext {
+            origin: AuthorOrigin,
+        };
+        match style::parse_selector_list_from_str(&parser_context, selectors.as_slice()) {
             Err(()) => Err(Syntax),
             Ok(ref selectors) => {
                 let root: JSRef<Node> = NodeCast::from_ref(self);

components/script/dom/htmlbodyelement.rs

@@ -17,13 +17,14 @@ use dom::htmlelement::HTMLElement;
 use dom::node::{Node, ElementNodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::{mod, DOMString, SimpleColor};
+use cssparser::RGBA;
+use servo_util::str::{mod, DOMString};
 use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLBodyElement {
     htmlelement: HTMLElement,
-    background_color: Cell<Option<SimpleColor>>,
+    background_color: Cell<Option<RGBA>>,
 }
 
 impl HTMLBodyElementDerived for EventTarget {
@@ -65,11 +66,11 @@ impl<'a> HTMLBodyElementMethods for JSRef<'a, HTMLBodyElement> {
 }
 
 pub trait HTMLBodyElementHelpers {
-    fn get_background_color(&self) -> Option<SimpleColor>;
+    fn get_background_color(&self) -> Option<RGBA>;
 }
 
 impl HTMLBodyElementHelpers for HTMLBodyElement {
-    fn get_background_color(&self) -> Option<SimpleColor> {
+    fn get_background_color(&self) -> Option<RGBA> {
         self.background_color.get()
     }
 }

components/script/dom/htmltablecellelement.rs

@@ -14,14 +14,14 @@ use dom::htmlelement::HTMLElement;
 use dom::node::ElementNodeTypeId;
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::{mod, AutoLpa, DOMString, LengthOrPercentageOrAuto, SimpleColor};
+use cssparser::RGBA;
+use servo_util::str::{mod, AutoLpa, DOMString, LengthOrPercentageOrAuto};
 use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLTableCellElement {
     htmlelement: HTMLElement,
-    background_color: Cell<Option<SimpleColor>>,
-    border: Cell<Option<u32>>,
+    background_color: Cell<Option<RGBA>>,
     colspan: Cell<Option<u32>>,
     width: Cell<LengthOrPercentageOrAuto>,
 }
@@ -45,7 +45,6 @@ impl HTMLTableCellElement {
         HTMLTableCellElement {
             htmlelement: HTMLElement::new_inherited(type_id, tag_name, prefix, document),
             background_color: Cell::new(None),
-            border: Cell::new(None),
             colspan: Cell::new(None),
             width: Cell::new(AutoLpa),
         }
@@ -58,21 +57,16 @@ impl HTMLTableCellElement {
 }
 
 pub trait HTMLTableCellElementHelpers {
-    fn get_background_color(&self) -> Option<SimpleColor>;
-    fn get_border(&self) -> Option<u32>;
+    fn get_background_color(&self) -> Option<RGBA>;
     fn get_colspan(&self) -> Option<u32>;
     fn get_width(&self) -> LengthOrPercentageOrAuto;
 }
 
 impl HTMLTableCellElementHelpers for HTMLTableCellElement {
-    fn get_background_color(&self) -> Option<SimpleColor> {
+    fn get_background_color(&self) -> Option<RGBA> {
         self.background_color.get()
     }
 
-    fn get_border(&self) -> Option<u32> {
-        self.border.get()
-    }
-
     fn get_colspan(&self) -> Option<u32> {
         self.colspan.get()
     }
@@ -98,12 +92,6 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTableCellElement> {
             &atom!("bgcolor") => {
                 self.background_color.set(str::parse_legacy_color(attr.value().as_slice()).ok())
             }
-            &atom!("border") => {
-                // According to HTML5 § 14.3.9, invalid values map to 1px.
-                self.border.set(Some(str::parse_unsigned_integer(attr.value()
-                                                                     .as_slice()
-                                                                     .chars()).unwrap_or(1)))
-            }
             &atom!("colspan") => {
                 self.colspan.set(str::parse_unsigned_integer(attr.value().as_slice().chars()));
             }
@@ -120,7 +108,6 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTableCellElement> {
 
         match attr.local_name() {
             &atom!("bgcolor") => self.background_color.set(None),
-            &atom!("border") => self.border.set(None),
             &atom!("colspan") => self.colspan.set(None),
             &atom!("width") => self.width.set(AutoLpa),
             _ => ()

components/script/dom/htmltableelement.rs

@@ -18,13 +18,14 @@ use dom::htmltablecaptionelement::HTMLTableCaptionElement;
 use dom::node::{Node, NodeHelpers, ElementNodeTypeId};
 use dom::virtualmethods::VirtualMethods;
 
-use servo_util::str::{mod, AutoLpa, DOMString, LengthOrPercentageOrAuto, SimpleColor};
+use cssparser::RGBA;
+use servo_util::str::{mod, AutoLpa, DOMString, LengthOrPercentageOrAuto};
 use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLTableElement {
     htmlelement: HTMLElement,
-    background_color: Cell<Option<SimpleColor>>,
+    background_color: Cell<Option<RGBA>>,
     border: Cell<Option<u32>>,
     width: Cell<LengthOrPercentageOrAuto>,
 }
@@ -95,13 +96,13 @@ impl<'a> HTMLTableElementMethods for JSRef<'a, HTMLTableElement> {
 }
 
 pub trait HTMLTableElementHelpers {
-    fn get_background_color(&self) -> Option<SimpleColor>;
+    fn get_background_color(&self) -> Option<RGBA>;
     fn get_border(&self) -> Option<u32>;
     fn get_width(&self) -> LengthOrPercentageOrAuto;
 }
 
 impl HTMLTableElementHelpers for HTMLTableElement {
-    fn get_background_color(&self) -> Option<SimpleColor> {
+    fn get_background_color(&self) -> Option<RGBA> {
         self.background_color.get()
     }
 

components/script/dom/htmltablerowelement.rs

@@ -2,8 +2,9 @@
  * 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/. */
 
+use dom::attr::{Attr, AttrHelpers};
 use dom::bindings::codegen::Bindings::HTMLTableRowElementBinding;
-use dom::bindings::codegen::InheritTypes::HTMLTableRowElementDerived;
+use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableRowElementDerived};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
@@ -11,11 +12,16 @@ use dom::element::HTMLTableRowElementTypeId;
 use dom::eventtarget::{EventTarget, NodeTargetTypeId};
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, ElementNodeTypeId};
-use servo_util::str::DOMString;
+use dom::virtualmethods::VirtualMethods;
+
+use cssparser::RGBA;
+use servo_util::str::{mod, DOMString};
+use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLTableRowElement {
     htmlelement: HTMLElement,
+    background_color: Cell<Option<RGBA>>,
 }
 
 impl HTMLTableRowElementDerived for EventTarget {
@@ -25,9 +31,14 @@ impl HTMLTableRowElementDerived for EventTarget {
 }
 
 impl HTMLTableRowElement {
-    fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableRowElement {
+    fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
+                     -> HTMLTableRowElement {
         HTMLTableRowElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTableRowElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(HTMLTableRowElementTypeId,
+                                                    localName,
+                                                    prefix,
+                                                    document),
+            background_color: Cell::new(None),
         }
     }
 
@@ -45,3 +56,47 @@ impl Reflectable for HTMLTableRowElement {
         self.htmlelement.reflector()
     }
 }
+
+pub trait HTMLTableRowElementHelpers {
+    fn get_background_color(&self) -> Option<RGBA>;
+}
+
+impl HTMLTableRowElementHelpers for HTMLTableRowElement {
+    fn get_background_color(&self) -> Option<RGBA> {
+        self.background_color.get()
+    }
+}
+
+impl<'a> VirtualMethods for JSRef<'a, HTMLTableRowElement> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods> {
+        let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_borrowed_ref(self);
+        Some(htmlelement as &VirtualMethods)
+    }
+
+    fn after_set_attr(&self, attr: JSRef<Attr>) {
+        match self.super_type() {
+            Some(ref s) => s.after_set_attr(attr),
+            _ => ()
+        }
+
+        match attr.local_name() {
+            &atom!("bgcolor") => {
+                self.background_color.set(str::parse_legacy_color(attr.value().as_slice()).ok())
+            }
+            _ => {}
+        }
+    }
+
+    fn before_remove_attr(&self, attr: JSRef<Attr>) {
+        match self.super_type() {
+            Some(ref s) => s.before_remove_attr(attr),
+            _ => ()
+        }
+
+        match attr.local_name() {
+            &atom!("bgcolor") => self.background_color.set(None),
+            _ => {}
+        }
+    }
+}
+

components/script/dom/htmltablesectionelement.rs

@@ -2,8 +2,9 @@
  * 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/. */
 
+use dom::attr::{Attr, AttrHelpers};
 use dom::bindings::codegen::Bindings::HTMLTableSectionElementBinding;
-use dom::bindings::codegen::InheritTypes::HTMLTableSectionElementDerived;
+use dom::bindings::codegen::InheritTypes::{HTMLElementCast, HTMLTableSectionElementDerived};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
@@ -11,11 +12,16 @@ use dom::element::HTMLTableSectionElementTypeId;
 use dom::eventtarget::{EventTarget, NodeTargetTypeId};
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, ElementNodeTypeId};
-use servo_util::str::DOMString;
+use dom::virtualmethods::VirtualMethods;
+
+use cssparser::RGBA;
+use servo_util::str::{mod, DOMString};
+use std::cell::Cell;
 
 #[dom_struct]
 pub struct HTMLTableSectionElement {
     htmlelement: HTMLElement,
+    background_color: Cell<Option<RGBA>>,
 }
 
 impl HTMLTableSectionElementDerived for EventTarget {
@@ -25,14 +31,20 @@ impl HTMLTableSectionElementDerived for EventTarget {
 }
 
 impl HTMLTableSectionElement {
-    fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> HTMLTableSectionElement {
+    fn new_inherited(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
+                     -> HTMLTableSectionElement {
         HTMLTableSectionElement {
-            htmlelement: HTMLElement::new_inherited(HTMLTableSectionElementTypeId, localName, prefix, document)
+            htmlelement: HTMLElement::new_inherited(HTMLTableSectionElementTypeId,
+                                                    localName,
+                                                    prefix,
+                                                    document),
+            background_color: Cell::new(None),
         }
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<HTMLTableSectionElement> {
+    pub fn new(localName: DOMString, prefix: Option<DOMString>, document: JSRef<Document>)
+               -> Temporary<HTMLTableSectionElement> {
         let element = HTMLTableSectionElement::new_inherited(localName, prefix, document);
         Node::reflect_node(box element, document, HTMLTableSectionElementBinding::Wrap)
     }
@@ -43,3 +55,47 @@ impl Reflectable for HTMLTableSectionElement {
         self.htmlelement.reflector()
     }
 }
+
+pub trait HTMLTableSectionElementHelpers {
+    fn get_background_color(&self) -> Option<RGBA>;
+}
+
+impl HTMLTableSectionElementHelpers for HTMLTableSectionElement {
+    fn get_background_color(&self) -> Option<RGBA> {
+        self.background_color.get()
+    }
+}
+
+impl<'a> VirtualMethods for JSRef<'a, HTMLTableSectionElement> {
+    fn super_type<'a>(&'a self) -> Option<&'a VirtualMethods> {
+        let htmlelement: &JSRef<HTMLElement> = HTMLElementCast::from_borrowed_ref(self);
+        Some(htmlelement as &VirtualMethods)
+    }
+
+    fn after_set_attr(&self, attr: JSRef<Attr>) {
+        match self.super_type() {
+            Some(ref s) => s.after_set_attr(attr),
+            _ => ()
+        }
+
+        match attr.local_name() {
+            &atom!("bgcolor") => {
+                self.background_color.set(str::parse_legacy_color(attr.value().as_slice()).ok())
+            }
+            _ => {}
+        }
+    }
+
+    fn before_remove_attr(&self, attr: JSRef<Attr>) {
+        match self.super_type() {
+            Some(ref s) => s.before_remove_attr(attr),
+            _ => ()
+        }
+
+        match attr.local_name() {
+            &atom!("bgcolor") => self.background_color.set(None),
+            _ => {}
+        }
+    }
+}
+

components/script/dom/node.rs

@@ -50,7 +50,7 @@ use devtools_traits::NodeInfo;
 use script_traits::UntrustedNodeAddress;
 use servo_util::geometry::Au;
 use servo_util::str::{DOMString, null_str_as_empty};
-use style::{parse_selector_list_from_str, matches, SelectorList};
+use style::{matches, AuthorOrigin, ParserContext, SelectorList};
 
 use js::jsapi::{JSContext, JSObject, JSTracer, JSRuntime};
 use js::jsfriendapi;
@@ -60,8 +60,7 @@ use std::cell::{Cell, RefCell, Ref, RefMut};
 use std::default::Default;
 use std::iter::{FilterMap, Peekable};
 use std::mem;
-use style;
-use style::ComputedValues;
+use style::{mod, ComputedValues};
 use sync::Arc;
 use uuid;
 use string_cache::QualName;
@@ -741,7 +740,10 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
     // http://dom.spec.whatwg.org/#dom-parentnode-queryselector
     fn query_selector(self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>> {
         // Step 1.
-        match parse_selector_list_from_str(selectors.as_slice()) {
+        let parser_context = ParserContext {
+            origin: AuthorOrigin,
+        };
+        match style::parse_selector_list_from_str(&parser_context, selectors.as_slice()) {
             // Step 2.
             Err(()) => return Err(Syntax),
             // Step 3.
@@ -758,11 +760,15 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
     /// Get an iterator over all nodes which match a set of selectors
     /// Be careful not to do anything which may manipulate the DOM tree whilst iterating, otherwise
     /// the iterator may be invalidated
-    unsafe fn query_selector_iter(self, selectors: DOMString) -> Fallible<QuerySelectorIterator<'a>> {
+    unsafe fn query_selector_iter(self, selectors: DOMString)
+                                  -> Fallible<QuerySelectorIterator<'a>> {
         // Step 1.
         let nodes;
         let root = self.ancestors().last().unwrap_or(self.clone());
-        match parse_selector_list_from_str(selectors.as_slice()) {
+        let parser_context = ParserContext {
+            origin: AuthorOrigin,
+        };
+        match style::parse_selector_list_from_str(&parser_context, selectors.as_slice()) {
             // Step 2.
             Err(()) => return Err(Syntax),
             // Step 3.

components/script/dom/virtualmethods.rs

@@ -24,6 +24,8 @@ use dom::bindings::codegen::InheritTypes::HTMLSelectElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLStyleElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLTableElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLTableCellElementCast;
+use dom::bindings::codegen::InheritTypes::HTMLTableRowElementCast;
+use dom::bindings::codegen::InheritTypes::HTMLTableSectionElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLTextAreaElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLTitleElementCast;
 use dom::bindings::js::JSRef;
@@ -49,6 +51,8 @@ use dom::element::HTMLStyleElementTypeId;
 use dom::element::HTMLTableDataCellElementTypeId;
 use dom::element::HTMLTableElementTypeId;
 use dom::element::HTMLTableHeaderCellElementTypeId;
+use dom::element::HTMLTableRowElementTypeId;
+use dom::element::HTMLTableSectionElementTypeId;
 use dom::element::HTMLTextAreaElementTypeId;
 use dom::element::HTMLTitleElementTypeId;
 use dom::event::Event;
@@ -71,6 +75,8 @@ use dom::htmlselectelement::HTMLSelectElement;
 use dom::htmlstyleelement::HTMLStyleElement;
 use dom::htmltableelement::HTMLTableElement;
 use dom::htmltablecellelement::HTMLTableCellElement;
+use dom::htmltablerowelement::HTMLTableRowElement;
+use dom::htmltablesectionelement::HTMLTableSectionElement;
 use dom::htmltextareaelement::HTMLTextAreaElement;
 use dom::htmltitleelement::HTMLTitleElement;
 use dom::node::{Node, NodeHelpers, ElementNodeTypeId, CloneChildrenFlag};
@@ -236,7 +242,18 @@ pub fn vtable_for<'a>(node: &'a JSRef<'a, Node>) -> &'a VirtualMethods + 'a {
         }
         ElementNodeTypeId(HTMLTableDataCellElementTypeId) |
         ElementNodeTypeId(HTMLTableHeaderCellElementTypeId) => {
-            let element: &'a JSRef<'a, HTMLTableCellElement> = HTMLTableCellElementCast::to_borrowed_ref(node).unwrap();
+            let element: &'a JSRef<'a, HTMLTableCellElement> =
+                HTMLTableCellElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
+        }
+        ElementNodeTypeId(HTMLTableRowElementTypeId) => {
+            let element: &'a JSRef<'a, HTMLTableRowElement> =
+                HTMLTableRowElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
+        }
+        ElementNodeTypeId(HTMLTableSectionElementTypeId) => {
+            let element: &'a JSRef<'a, HTMLTableSectionElement> =
+                HTMLTableSectionElementCast::to_borrowed_ref(node).unwrap();
             element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLTextAreaElementTypeId) => {