diff --git a/components/layout/util.rs b/components/layout/util.rs
index 198607473f1..9bb1a3ffa1f 100644
--- a/components/layout/util.rs
+++ b/components/layout/util.rs
@@ -78,20 +78,20 @@ pub trait LayoutDataAccess {
 impl<'ln> LayoutDataAccess for LayoutNode<'ln> {
     #[inline(always)]
     unsafe fn borrow_layout_data_unchecked(&self) -> *const Option<LayoutDataWrapper> {
-        mem::transmute(self.get().layout_data.borrow_unchecked())
+        mem::transmute(self.get().layout_data_unchecked())
     }
 
     #[inline(always)]
     fn borrow_layout_data<'a>(&'a self) -> Ref<'a,Option<LayoutDataWrapper>> {
         unsafe {
-            mem::transmute(self.get().layout_data.borrow())
+            mem::transmute(self.get().layout_data())
         }
     }
 
     #[inline(always)]
     fn mutate_layout_data<'a>(&'a self) -> RefMut<'a,Option<LayoutDataWrapper>> {
         unsafe {
-            mem::transmute(self.get().layout_data.borrow_mut())
+            mem::transmute(self.get().layout_data_mut())
         }
     }
 }
diff --git a/components/layout/wrapper.rs b/components/layout/wrapper.rs
index 7cde321f058..e7ace898d01 100644
--- a/components/layout/wrapper.rs
+++ b/components/layout/wrapper.rs
@@ -116,8 +116,8 @@ pub trait TLayoutNode {
                 fail!("not an iframe element!")
             }
             let iframe_element: JS<HTMLIFrameElement> = self.get_jsmanaged().transmute_copy();
-            let size = (*iframe_element.unsafe_get()).size.get().unwrap();
-            (size.pipeline_id, size.subpage_id)
+            let size = (*iframe_element.unsafe_get()).size().unwrap();
+            (*size.pipeline_id(), *size.subpage_id())
         }
     }
 
@@ -189,7 +189,7 @@ impl<'ln> TLayoutNode for LayoutNode<'ln> {
         unsafe {
             if self.get().is_text() {
                 let text: JS<Text> = self.get_jsmanaged().transmute_copy();
-                (*text.unsafe_get()).characterdata.data.borrow().clone()
+                (*text.unsafe_get()).characterdata().data().clone()
             } else if self.get().is_htmlinputelement() {
                 let input: JS<HTMLInputElement> = self.get_jsmanaged().transmute_copy();
                 input.get_value_for_layout()
@@ -425,7 +425,7 @@ pub struct LayoutElement<'le> {
 impl<'le> LayoutElement<'le> {
     pub fn style_attribute(&self) -> &'le Option<PropertyDeclarationBlock> {
         let style: &Option<PropertyDeclarationBlock> = unsafe {
-            let style: &RefCell<Option<PropertyDeclarationBlock>> = &self.element.style_attribute;
+            let style: &RefCell<Option<PropertyDeclarationBlock>> = self.element.style_attribute();
             // cast to the direct reference to T placed on the head of RefCell<T>
             mem::transmute(style)
         };
@@ -436,12 +436,12 @@ impl<'le> LayoutElement<'le> {
 impl<'le> TElement<'le> for LayoutElement<'le> {
     #[inline]
     fn get_local_name(self) -> &'le Atom {
-        &self.element.local_name
+        self.element.local_name()
     }
 
     #[inline]
     fn get_namespace(self) -> &'le Namespace {
-        &self.element.namespace
+        self.element.namespace()
     }
 
     #[inline]
@@ -456,7 +456,7 @@ impl<'le> TElement<'le> for LayoutElement<'le> {
 
     fn get_link(self) -> Option<&'le str> {
         // FIXME: This is HTML only.
-        match self.element.node.type_id_for_layout() {
+        match self.element.node().type_id_for_layout() {
             // http://www.whatwg.org/specs/web-apps/current-work/multipage/selectors.html#
             // selector-link
             ElementNodeTypeId(HTMLAnchorElementTypeId) |
@@ -470,7 +470,7 @@ impl<'le> TElement<'le> for LayoutElement<'le> {
 
     fn get_hover_state(self) -> bool {
         unsafe {
-            self.element.node.get_hover_state_for_layout()
+            self.element.node().get_hover_state_for_layout()
         }
     }
 
@@ -481,13 +481,13 @@ impl<'le> TElement<'le> for LayoutElement<'le> {
 
     fn get_disabled_state(self) -> bool {
         unsafe {
-            self.element.node.get_disabled_state_for_layout()
+            self.element.node().get_disabled_state_for_layout()
         }
     }
 
     fn get_enabled_state(self) -> bool {
         unsafe {
-            self.element.node.get_enabled_state_for_layout()
+            self.element.node().get_enabled_state_for_layout()
         }
     }
 
@@ -721,7 +721,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     #[inline(always)]
     pub fn borrow_layout_data<'a>(&'a self) -> Ref<'a,Option<LayoutDataWrapper>> {
         unsafe {
-            mem::transmute(self.get().layout_data.borrow())
+            mem::transmute(self.get().layout_data())
         }
     }
 
@@ -729,7 +729,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     #[inline(always)]
     pub fn mutate_layout_data<'a>(&'a self) -> RefMut<'a,Option<LayoutDataWrapper>> {
         unsafe {
-            mem::transmute(self.get().layout_data.borrow_mut())
+            mem::transmute(self.get().layout_data_mut())
         }
     }
 
@@ -765,7 +765,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
             Some(TextNodeTypeId) => {
                 unsafe {
                     let text: JS<Text> = self.get_jsmanaged().transmute_copy();
-                    if !is_whitespace((*text.unsafe_get()).characterdata.data.borrow().as_slice()) {
+                    if !is_whitespace((*text.unsafe_get()).characterdata().data().as_slice()) {
                         return false
                     }
 
diff --git a/components/plugins/lib.rs b/components/plugins/lib.rs
index 221de13d289..d4894963f8f 100644
--- a/components/plugins/lib.rs
+++ b/components/plugins/lib.rs
@@ -27,6 +27,7 @@ mod jstraceable;
 pub fn plugin_registrar(reg: &mut Registry) {
     reg.register_lint_pass(box lints::TransmutePass as LintPassObject);
     reg.register_lint_pass(box lints::UnrootedPass as LintPassObject);
+    reg.register_lint_pass(box lints::PrivatizePass as LintPassObject);
     reg.register_syntax_extension(intern("jstraceable"), Decorator(box jstraceable::expand_jstraceable))
 }
 
diff --git a/components/plugins/lints.rs b/components/plugins/lints.rs
index 605240d74e9..01d6a81a7a8 100644
--- a/components/plugins/lints.rs
+++ b/components/plugins/lints.rs
@@ -2,7 +2,8 @@
  * 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 syntax::{ast, codemap, visit};
+use syntax::{ast, ast_util, codemap, visit};
+use syntax::ast::Public;
 use syntax::attr::AttrMetaMethods;
 use rustc::lint::{Context, LintPass, LintArray};
 use rustc::middle::ty::expr_ty;
@@ -14,9 +15,12 @@ declare_lint!(TRANSMUTE_TYPE_LINT, Allow,
               "Warn and report types being transmuted")
 declare_lint!(UNROOTED_MUST_ROOT, Deny,
               "Warn and report usage of unrooted jsmanaged objects")
+declare_lint!(PRIVATIZE, Deny,
+              "Allows to enforce private fields for struct definitions")
 
 pub struct TransmutePass;
 pub struct UnrootedPass;
+pub struct PrivatizePass;
 
 impl LintPass for TransmutePass {
     fn get_lints(&self) -> LintArray {
@@ -146,3 +150,22 @@ impl LintPass for UnrootedPass {
     }
 }
 
+impl LintPass for PrivatizePass {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(PRIVATIZE)
+    }
+
+    fn check_struct_def(&mut self, cx: &Context, def: &ast::StructDef, _i: ast::Ident, _gen: &ast::Generics, id: ast::NodeId) {
+        if ty::has_attr(cx.tcx, ast_util::local_def(id), "privatize") {
+            for field in def.fields.iter() {
+                match field.node {
+                    ast::StructField_ { kind: ast::NamedField(ident, visibility), .. } if visibility == Public => {
+                        cx.span_lint(PRIVATIZE, field.span,
+                                     format!("Field {} is public where only private fields are allowed", ident.name).as_slice());
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}
diff --git a/components/script/dom/attr.rs b/components/script/dom/attr.rs
index 0a3bacc856f..d54be57b8e0 100644
--- a/components/script/dom/attr.rs
+++ b/components/script/dom/attr.rs
@@ -72,13 +72,14 @@ impl Str for AttrValue {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Attr {
     reflector_: Reflector,
     local_name: Atom,
     value: RefCell<AttrValue>,
-    pub name: Atom,
-    pub namespace: Namespace,
-    pub prefix: Option<DOMString>,
+    name: Atom,
+    namespace: Namespace,
+    prefix: Option<DOMString>,
 
     /// the element that owns this attribute.
     owner: JS<Element>,
@@ -111,6 +112,21 @@ impl Attr {
         reflect_dom_object(box Attr::new_inherited(local_name, value, name, namespace, prefix, owner),
                            &global::Window(window), AttrBinding::Wrap)
     }
+
+    #[inline]
+    pub fn name<'a>(&'a self) -> &'a Atom {
+        &self.name
+    }
+
+    #[inline]
+    pub fn namespace<'a>(&'a self) -> &'a Namespace {
+        &self.namespace
+    }
+
+    #[inline]
+    pub fn prefix<'a>(&'a self) -> &'a Option<DOMString> {
+        &self.prefix
+    }
 }
 
 impl<'a> AttrMethods for JSRef<'a, Attr> {
diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py
index 9f80ca0dd5c..7cf193baf0c 100644
--- a/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/components/script/dom/bindings/codegen/CodegenRust.py
@@ -5452,7 +5452,7 @@ class GlobalGenRoots():
                 protoDescriptor = config.getDescriptor(protoName)
                 delegate = string.Template('''impl ${selfName} for ${baseName} {
   fn ${fname}(&self) -> bool {
-    self.${parentName}.${fname}()
+    self.${parentName}().${fname}()
   }
 }
 ''').substitute({'fname': 'is_' + name.lower(),
diff --git a/components/script/dom/bindings/global.rs b/components/script/dom/bindings/global.rs
index b4b7d85452b..a1933db4aa5 100644
--- a/components/script/dom/bindings/global.rs
+++ b/components/script/dom/bindings/global.rs
@@ -83,7 +83,7 @@ impl<'a> GlobalRef<'a> {
     /// thread.
     pub fn script_chan<'b>(&'b self) -> &'b ScriptChan {
         match *self {
-            Window(ref window) => &window.script_chan,
+            Window(ref window) => window.script_chan(),
             Worker(ref worker) => worker.script_chan(),
         }
     }
diff --git a/components/script/dom/bindings/utils.rs b/components/script/dom/bindings/utils.rs
index 834f274096f..082172a1f60 100644
--- a/components/script/dom/bindings/utils.rs
+++ b/components/script/dom/bindings/utils.rs
@@ -660,7 +660,7 @@ pub extern fn outerize_global(_cx: *mut JSContext, obj: JSHandleObject) -> *mut
                              IDLInterface::get_prototype_depth(None::<window::Window>))
             .unwrap()
             .root();
-        win.browser_context.borrow().as_ref().unwrap().window_proxy()
+        win.browser_context().as_ref().unwrap().window_proxy()
     }
 }
 
diff --git a/components/script/dom/blob.rs b/components/script/dom/blob.rs
index 71f83dffd96..5849b75ff10 100644
--- a/components/script/dom/blob.rs
+++ b/components/script/dom/blob.rs
@@ -17,6 +17,7 @@ pub enum BlobType {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Blob {
     reflector_: Reflector,
     type_: BlobType
diff --git a/components/script/dom/browsercontext.rs b/components/script/dom/browsercontext.rs
index 094dc1a5e09..9f6041710e3 100644
--- a/components/script/dom/browsercontext.rs
+++ b/components/script/dom/browsercontext.rs
@@ -15,6 +15,7 @@ use std::ptr;
 
 #[allow(raw_pointer_deriving)]
 #[jstraceable]
+#[privatize]
 pub struct BrowserContext {
     history: Vec<SessionHistoryEntry>,
     active_index: uint,
@@ -38,7 +39,7 @@ impl BrowserContext {
 
     pub fn active_window(&self) -> Temporary<Window> {
         let doc = self.active_document().root();
-        Temporary::new(doc.window.clone())
+        Temporary::new(doc.window().clone())
     }
 
     pub fn window_proxy(&self) -> *mut JSObject {
@@ -66,6 +67,7 @@ impl BrowserContext {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct SessionHistoryEntry {
     document: JS<Document>,
     children: Vec<BrowserContext>
diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index eb80fa498da..c9a19c3301c 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -17,6 +17,7 @@ use canvas::canvas_render_task::{CanvasMsg, CanvasRenderTask, ClearRect, Close,
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct CanvasRenderingContext2D {
     reflector_: Reflector,
     global: GlobalField,
diff --git a/components/script/dom/characterdata.rs b/components/script/dom/characterdata.rs
index 277295daef9..8201965bdb3 100644
--- a/components/script/dom/characterdata.rs
+++ b/components/script/dom/characterdata.rs
@@ -14,18 +14,19 @@ use dom::eventtarget::{EventTarget, NodeTargetTypeId};
 use dom::node::{CommentNodeTypeId, Node, NodeTypeId, TextNodeTypeId, ProcessingInstructionNodeTypeId, NodeHelpers};
 use servo_util::str::DOMString;
 
-use std::cell::RefCell;
+use std::cell::{Ref, RefCell};
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct CharacterData {
-    pub node: Node,
-    pub data: RefCell<DOMString>,
+    node: Node,
+    data: RefCell<DOMString>,
 }
 
 impl CharacterDataDerived for EventTarget {
     fn is_characterdata(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             NodeTargetTypeId(TextNodeTypeId) |
             NodeTargetTypeId(CommentNodeTypeId) |
             NodeTargetTypeId(ProcessingInstructionNodeTypeId) => true,
@@ -41,6 +42,21 @@ impl CharacterData {
             data: RefCell::new(data),
         }
     }
+
+    #[inline]
+    pub fn node<'a>(&'a self) -> &'a Node {
+        &self.node
+    }
+
+    #[inline]
+    pub fn data(&self) -> Ref<DOMString> {
+        self.data.borrow()
+    }
+
+    #[inline]
+    pub fn set_data(&self, data: DOMString) {
+        *self.data.borrow_mut() = data;
+    }
 }
 
 impl<'a> CharacterDataMethods for JSRef<'a, CharacterData> {
diff --git a/components/script/dom/comment.rs b/components/script/dom/comment.rs
index a2c3c84a6a8..8da33dab01f 100644
--- a/components/script/dom/comment.rs
+++ b/components/script/dom/comment.rs
@@ -18,13 +18,14 @@ use servo_util::str::DOMString;
 /// An HTML comment.
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Comment {
-    pub characterdata: CharacterData,
+    characterdata: CharacterData,
 }
 
 impl CommentDerived for EventTarget {
     fn is_comment(&self) -> bool {
-        self.type_id == NodeTargetTypeId(CommentNodeTypeId)
+        *self.type_id() == NodeTargetTypeId(CommentNodeTypeId)
     }
 }
 
@@ -44,6 +45,11 @@ impl Comment {
         let document = global.as_window().Document().root();
         Ok(Comment::new(data, *document))
     }
+
+    #[inline]
+    pub fn characterdata<'a>(&'a self) -> &'a CharacterData {
+        &self.characterdata
+    }
 }
 
 impl Reflectable for Comment {
diff --git a/components/script/dom/console.rs b/components/script/dom/console.rs
index cefb8cfaa87..a62d2ad4047 100644
--- a/components/script/dom/console.rs
+++ b/components/script/dom/console.rs
@@ -11,8 +11,9 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Console {
-    pub reflector_: Reflector
+    reflector_: Reflector
 }
 
 impl Console {
diff --git a/components/script/dom/customevent.rs b/components/script/dom/customevent.rs
index c25c328afaa..b6549f28a16 100644
--- a/components/script/dom/customevent.rs
+++ b/components/script/dom/customevent.rs
@@ -19,6 +19,7 @@ use std::cell::Cell;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct CustomEvent {
     event: Event,
     detail: Cell<JSVal>,
@@ -26,7 +27,7 @@ pub struct CustomEvent {
 
 impl CustomEventDerived for Event {
     fn is_customevent(&self) -> bool {
-        self.type_id == CustomEventTypeId
+        *self.type_id() == CustomEventTypeId
     }
 }
 
diff --git a/components/script/dom/dedicatedworkerglobalscope.rs b/components/script/dom/dedicatedworkerglobalscope.rs
index cd873c39930..22e5c4c6454 100644
--- a/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/components/script/dom/dedicatedworkerglobalscope.rs
@@ -37,6 +37,7 @@ use url::Url;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DedicatedWorkerGlobalScope {
     workerglobalscope: WorkerGlobalScope,
     receiver: Receiver<ScriptMsg>,
@@ -192,7 +193,7 @@ impl Reflectable for DedicatedWorkerGlobalScope {
 
 impl DedicatedWorkerGlobalScopeDerived for EventTarget {
     fn is_dedicatedworkerglobalscope(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             WorkerGlobalScopeTypeId(DedicatedGlobalScope) => true,
             _ => false
         }
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index 99dde0e9f0c..f37a8feb2f6 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -62,7 +62,7 @@ use url::Url;
 
 use std::collections::hashmap::HashMap;
 use std::ascii::StrAsciiExt;
-use std::cell::{Cell, RefCell};
+use std::cell::{Cell, Ref, RefCell};
 use std::default::Default;
 use time;
 
@@ -75,16 +75,17 @@ pub enum IsHTMLDocument {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Document {
-    pub node: Node,
+    node: Node,
     reflector_: Reflector,
-    pub window: JS<Window>,
+    window: JS<Window>,
     idmap: RefCell<HashMap<Atom, Vec<JS<Element>>>>,
     implementation: MutNullableJS<DOMImplementation>,
     content_type: DOMString,
     last_modified: RefCell<Option<DOMString>>,
-    pub encoding_name: RefCell<DOMString>,
-    pub is_html_document: bool,
+    encoding_name: RefCell<DOMString>,
+    is_html_document: bool,
     url: Url,
     quirks_mode: Cell<QuirksMode>,
     images: MutNullableJS<HTMLCollection>,
@@ -98,7 +99,7 @@ pub struct Document {
 
 impl DocumentDerived for EventTarget {
     fn is_document(&self) -> bool {
-        self.type_id == NodeTargetTypeId(DocumentNodeTypeId)
+        *self.type_id() == NodeTargetTypeId(DocumentNodeTypeId)
     }
 }
 
@@ -343,6 +344,21 @@ impl Document {
         node.set_owner_doc(*document);
         Temporary::from_rooted(*document)
     }
+
+    #[inline]
+    pub fn window<'a>(&'a self) -> &'a JS<Window> {
+        &self.window
+    }
+
+    #[inline]
+    pub fn encoding_name(&self) -> Ref<DOMString> {
+        self.encoding_name.borrow()
+    }
+
+    #[inline]
+    pub fn is_html_document(&self) -> bool {
+        self.is_html_document
+    }
 }
 
 impl Reflectable for Document {
@@ -641,7 +657,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
                     for child in title_elem.children() {
                         if child.is_text() {
                             let text: JSRef<Text> = TextCast::to_ref(child).unwrap();
-                            title.push_str(text.characterdata.data.borrow().as_slice());
+                            title.push_str(text.characterdata().data().as_slice());
                         }
                     }
                 });
diff --git a/components/script/dom/documentfragment.rs b/components/script/dom/documentfragment.rs
index 40a837125a6..8b3b8e6bba6 100644
--- a/components/script/dom/documentfragment.rs
+++ b/components/script/dom/documentfragment.rs
@@ -20,13 +20,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DocumentFragment {
-    pub node: Node,
+    node: Node,
 }
 
 impl DocumentFragmentDerived for EventTarget {
     fn is_documentfragment(&self) -> bool {
-        self.type_id == NodeTargetTypeId(DocumentFragmentNodeTypeId)
+        *self.type_id() == NodeTargetTypeId(DocumentFragmentNodeTypeId)
     }
 }
 
diff --git a/components/script/dom/documenttype.rs b/components/script/dom/documenttype.rs
index 8d902a34b26..683b1c56ae0 100644
--- a/components/script/dom/documenttype.rs
+++ b/components/script/dom/documenttype.rs
@@ -15,16 +15,17 @@ use servo_util::str::DOMString;
 /// The `DOCTYPE` tag.
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DocumentType {
-    pub node: Node,
-    pub name: DOMString,
-    pub public_id: DOMString,
-    pub system_id: DOMString,
+    node: Node,
+    name: DOMString,
+    public_id: DOMString,
+    system_id: DOMString,
 }
 
 impl DocumentTypeDerived for EventTarget {
     fn is_documenttype(&self) -> bool {
-        self.type_id == NodeTargetTypeId(DoctypeNodeTypeId)
+        *self.type_id() == NodeTargetTypeId(DoctypeNodeTypeId)
     }
 }
 
@@ -53,6 +54,21 @@ impl DocumentType {
                                                        document);
         Node::reflect_node(box documenttype, document, DocumentTypeBinding::Wrap)
     }
+
+    #[inline]
+    pub fn name<'a>(&'a self) -> &'a DOMString {
+        &self.name
+    }
+
+    #[inline]
+    pub fn public_id<'a>(&'a self) -> &'a DOMString {
+        &self.public_id
+    }
+
+    #[inline]
+    pub fn system_id<'a>(&'a self) -> &'a DOMString {
+        &self.system_id
+    }
 }
 
 impl<'a> DocumentTypeMethods for JSRef<'a, DocumentType> {
diff --git a/components/script/dom/domexception.rs b/components/script/dom/domexception.rs
index 924494c0455..73dc4c149fe 100644
--- a/components/script/dom/domexception.rs
+++ b/components/script/dom/domexception.rs
@@ -62,9 +62,10 @@ impl DOMErrorName {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DOMException {
-    pub code: DOMErrorName,
-    pub reflector_: Reflector
+    code: DOMErrorName,
+    reflector_: Reflector
 }
 
 impl DOMException {
diff --git a/components/script/dom/domimplementation.rs b/components/script/dom/domimplementation.rs
index 063153f369e..7e23d86f2bc 100644
--- a/components/script/dom/domimplementation.rs
+++ b/components/script/dom/domimplementation.rs
@@ -24,6 +24,7 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DOMImplementation {
     document: JS<Document>,
     reflector_: Reflector,
@@ -38,7 +39,7 @@ impl DOMImplementation {
     }
 
     pub fn new(document: JSRef<Document>) -> Temporary<DOMImplementation> {
-        let window = document.window.root();
+        let window = document.window().root();
         reflect_dom_object(box DOMImplementation::new_inherited(document),
                            &Window(*window),
                            DOMImplementationBinding::Wrap)
@@ -72,7 +73,7 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
     fn CreateDocument(self, namespace: Option<DOMString>, qname: DOMString,
                       maybe_doctype: Option<JSRef<DocumentType>>) -> Fallible<Temporary<Document>> {
         let doc = self.document.root();
-        let win = doc.window.root();
+        let win = doc.window().root();
 
         // Step 1.
         let doc = Document::new(*win, None, NonHTMLDocument, None).root();
@@ -117,7 +118,7 @@ impl<'a> DOMImplementationMethods for JSRef<'a, DOMImplementation> {
     // http://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
     fn CreateHTMLDocument(self, title: Option<DOMString>) -> Temporary<Document> {
         let document = self.document.root();
-        let win = document.window.root();
+        let win = document.window().root();
 
         // Step 1-2.
         let doc = Document::new(*win, None, HTMLDocument, None).root();
diff --git a/components/script/dom/domparser.rs b/components/script/dom/domparser.rs
index 315a3851bb1..7b6bbae3e7c 100644
--- a/components/script/dom/domparser.rs
+++ b/components/script/dom/domparser.rs
@@ -16,6 +16,7 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DOMParser {
     window: JS<Window>, //XXXjdm Document instead?
     reflector_: Reflector
diff --git a/components/script/dom/domrect.rs b/components/script/dom/domrect.rs
index 3c79479edab..39e9c4cbb0e 100644
--- a/components/script/dom/domrect.rs
+++ b/components/script/dom/domrect.rs
@@ -12,6 +12,7 @@ use servo_util::geometry::Au;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DOMRect {
     reflector_: Reflector,
     top: f32,
diff --git a/components/script/dom/domrectlist.rs b/components/script/dom/domrectlist.rs
index 8be9ab9cbf6..88ec6d5e148 100644
--- a/components/script/dom/domrectlist.rs
+++ b/components/script/dom/domrectlist.rs
@@ -12,6 +12,7 @@ use dom::window::Window;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DOMRectList {
     reflector_: Reflector,
     rects: Vec<JS<DOMRect>>,
diff --git a/components/script/dom/domtokenlist.rs b/components/script/dom/domtokenlist.rs
index 71fb76bdb44..59d931dea31 100644
--- a/components/script/dom/domtokenlist.rs
+++ b/components/script/dom/domtokenlist.rs
@@ -17,6 +17,7 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct DOMTokenList {
     reflector_: Reflector,
     element: JS<Element>,
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index ef5ec630670..6ff62874731 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -35,7 +35,7 @@ use servo_util::namespace;
 use servo_util::str::DOMString;
 
 use std::ascii::StrAsciiExt;
-use std::cell::RefCell;
+use std::cell::{Ref, RefMut, RefCell};
 use std::default::Default;
 use std::mem;
 use std::slice::Items;
@@ -44,20 +44,21 @@ use url::UrlParser;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Element {
-    pub node: Node,
-    pub local_name: Atom,
-    pub namespace: Namespace,
-    pub prefix: Option<DOMString>,
-    pub attrs: RefCell<Vec<JS<Attr>>>,
-    pub style_attribute: RefCell<Option<style::PropertyDeclarationBlock>>,
-    pub attr_list: MutNullableJS<NamedNodeMap>,
+    node: Node,
+    local_name: Atom,
+    namespace: Namespace,
+    prefix: Option<DOMString>,
+    attrs: RefCell<Vec<JS<Attr>>>,
+    style_attribute: RefCell<Option<style::PropertyDeclarationBlock>>,
+    attr_list: MutNullableJS<NamedNodeMap>,
     class_list: MutNullableJS<DOMTokenList>,
 }
 
 impl ElementDerived for EventTarget {
     fn is_element(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             NodeTargetTypeId(ElementNodeTypeId(_)) => true,
             _ => false
         }
@@ -166,6 +167,41 @@ impl Element {
         Node::reflect_node(box Element::new_inherited(ElementTypeId_, local_name, namespace, prefix, document),
                            document, ElementBinding::Wrap)
     }
+
+    #[inline]
+    pub fn node<'a>(&'a self) -> &'a Node {
+        &self.node
+    }
+
+    #[inline]
+    pub fn local_name<'a>(&'a self) -> &'a Atom {
+        &self.local_name
+    }
+
+    #[inline]
+    pub fn namespace<'a>(&'a self) -> &'a Namespace {
+        &self.namespace
+    }
+
+    #[inline]
+    pub fn prefix<'a>(&'a self) -> &'a Option<DOMString> {
+        &self.prefix
+    }
+
+    #[inline]
+    pub fn attrs(&self) -> Ref<Vec<JS<Attr>>> {
+        self.attrs.borrow()
+    }
+
+    #[inline]
+    pub fn attrs_mut(&self) -> RefMut<Vec<JS<Attr>>> {
+        self.attrs.borrow_mut()
+    }
+
+    #[inline]
+    pub fn style_attribute<'a>(&'a self) -> &'a RefCell<Option<style::PropertyDeclarationBlock>> {
+        &self.style_attribute
+    }
 }
 
 pub trait RawLayoutElementHelpers {
@@ -186,7 +222,7 @@ impl RawLayoutElementHelpers for Element {
         (*attrs).iter().find(|attr: & &JS<Attr>| {
             let attr = attr.unsafe_get();
             name == (*attr).local_name_atom_forever().as_slice() &&
-            (*attr).namespace == *namespace
+            *(*attr).namespace() == *namespace
         }).map(|attr| {
             let attr = attr.unsafe_get();
             (*attr).value_ref_forever()
@@ -217,7 +253,7 @@ impl RawLayoutElementHelpers for Element {
         (*attrs).iter().find(|attr: & &JS<Attr>| {
             let attr = attr.unsafe_get();
             name == (*attr).local_name_atom_forever().as_slice() &&
-            (*attr).namespace == *namespace
+            *(*attr).namespace() == *namespace
         }).and_then(|attr| {
             let attr = attr.unsafe_get();
             (*attr).value_atom_forever()
@@ -263,7 +299,7 @@ impl LayoutElementHelpers for JS<Element> {
         }
         let node: JS<Node> = self.transmute_copy();
         let owner_doc = node.owner_doc_for_layout().unsafe_get();
-        (*owner_doc).is_html_document
+        (*owner_doc).is_html_document()
     }
 }
 
@@ -355,7 +391,7 @@ pub trait AttributeHandlers {
 impl<'a> AttributeHandlers for JSRef<'a, Element> {
     fn get_attribute(self, namespace: Namespace, local_name: &str) -> Option<Temporary<Attr>> {
         self.get_attributes(local_name).iter().map(|attr| attr.root())
-            .find(|attr| attr.namespace == namespace)
+            .find(|attr| *attr.namespace() == namespace)
             .map(|x| Temporary::from_rooted(*x))
     }
 
@@ -491,7 +527,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
             false => Atom::from_slice(name)
         };
         self.attrs.borrow().iter().map(|attr| attr.root()).any(|attr| {
-            *attr.local_name() == name && attr.namespace == ns!("")
+            *attr.local_name() == name && *attr.namespace() == ns!("")
         })
     }
 
@@ -626,7 +662,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
                 let node: JSRef<Node> = NodeCast::from_ref(self);
                 node.owner_doc().root()
             };
-            let window = doc.window.root();
+            let window = doc.window().root();
             let list = NamedNodeMap::new(*window, self);
             self.attr_list.assign(Some(list));
         }
@@ -679,7 +715,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
         let name = Atom::from_slice(name.as_slice());
         let value = self.parse_attribute(&ns!(""), &name, value);
         self.do_set_attribute(name.clone(), value, name.clone(), ns!(""), None, |attr| {
-            attr.name.as_slice() == name.as_slice()
+            attr.name().as_slice() == name.as_slice()
         });
         Ok(())
     }
@@ -748,7 +784,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
                               namespace.clone(), prefix.map(|s| s.to_string()),
                               |attr| {
             *attr.local_name() == local_name &&
-            attr.namespace == namespace
+            *attr.namespace() == namespace
         });
         Ok(())
     }
diff --git a/components/script/dom/event.rs b/components/script/dom/event.rs
index 92df2faac71..05b3d6af3a5 100644
--- a/components/script/dom/event.rs
+++ b/components/script/dom/event.rs
@@ -49,21 +49,22 @@ pub enum EventCancelable {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Event {
-    pub type_id: EventTypeId,
+    type_id: EventTypeId,
     reflector_: Reflector,
-    pub current_target: MutNullableJS<EventTarget>,
-    pub target: MutNullableJS<EventTarget>,
+    current_target: MutNullableJS<EventTarget>,
+    target: MutNullableJS<EventTarget>,
     type_: RefCell<DOMString>,
-    pub phase: Cell<EventPhase>,
-    pub canceled: Cell<bool>,
-    pub stop_propagation: Cell<bool>,
-    pub stop_immediate: Cell<bool>,
-    pub cancelable: Cell<bool>,
-    pub bubbles: Cell<bool>,
-    pub trusted: Cell<bool>,
-    pub dispatching: Cell<bool>,
-    pub initialized: Cell<bool>,
+    phase: Cell<EventPhase>,
+    canceled: Cell<bool>,
+    stop_propagation: Cell<bool>,
+    stop_immediate: Cell<bool>,
+    cancelable: Cell<bool>,
+    bubbles: Cell<bool>,
+    trusted: Cell<bool>,
+    dispatching: Cell<bool>,
+    initialized: Cell<bool>,
     timestamp: u64,
 }
 
@@ -110,6 +111,61 @@ impl Event {
         let cancelable = if init.cancelable { Cancelable } else { NotCancelable };
         Ok(Event::new(global, type_, bubbles, cancelable))
     }
+
+    #[inline]
+    pub fn type_id<'a>(&'a self) -> &'a EventTypeId {
+        &self.type_id
+    }
+
+    #[inline]
+    pub fn clear_current_target(&self) {
+        self.current_target.clear();
+    }
+
+    #[inline]
+    pub fn set_current_target(&self, val: JSRef<EventTarget>) {
+        self.current_target.assign(Some(val));
+    }
+
+    #[inline]
+    pub fn set_target(&self, val: JSRef<EventTarget>) {
+        self.target.assign(Some(val));
+    }
+
+    #[inline]
+    pub fn set_phase(&self, val: EventPhase) {
+        self.phase.set(val)
+    }
+
+    #[inline]
+    pub fn stop_propagation(&self) -> bool {
+        self.stop_propagation.get()
+    }
+
+    #[inline]
+    pub fn stop_immediate(&self) -> bool {
+        self.stop_immediate.get()
+    }
+
+    #[inline]
+    pub fn bubbles(&self) -> bool {
+        self.bubbles.get()
+    }
+
+    #[inline]
+    pub fn dispatching(&self) -> bool {
+        self.dispatching.get()
+    }
+
+    #[inline]
+    pub fn set_dispatching(&self, val: bool) {
+        self.dispatching.set(val)
+    }
+
+    #[inline]
+    pub fn initialized(&self) -> bool {
+        self.initialized.get()
+    }
 }
 
 impl<'a> EventMethods for JSRef<'a, Event> {
diff --git a/components/script/dom/eventdispatcher.rs b/components/script/dom/eventdispatcher.rs
index 54f2814db79..bdfb98c7bae 100644
--- a/components/script/dom/eventdispatcher.rs
+++ b/components/script/dom/eventdispatcher.rs
@@ -5,7 +5,7 @@
 use dom::bindings::callback::ReportExceptions;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, NodeDerived};
-use dom::bindings::js::{JS, JSRef, OptionalSettable, OptionalRootable, Root};
+use dom::bindings::js::{JS, JSRef, OptionalRootable, Root};
 use dom::eventtarget::{Capturing, Bubbling, EventTarget};
 use dom::event::{Event, PhaseAtTarget, PhaseNone, PhaseBubbling, PhaseCapturing};
 use dom::node::{Node, NodeHelpers};
@@ -15,13 +15,13 @@ use dom::virtualmethods::vtable_for;
 pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
                               pseudo_target: Option<JSRef<'b, EventTarget>>,
                               event: JSRef<Event>) -> bool {
-    assert!(!event.dispatching.get());
+    assert!(!event.dispatching());
 
-    event.target.assign(Some(match pseudo_target {
+    event.set_target(match pseudo_target {
         Some(pseudo_target) => pseudo_target,
         None => target.clone(),
-    }));
-    event.dispatching.set(true);
+    });
+    event.set_dispatching(true);
 
     let type_ = event.Type();
 
@@ -36,7 +36,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
         vec!()
     };
 
-    event.phase.set(PhaseCapturing);
+    event.set_phase(PhaseCapturing);
 
     //FIXME: The "callback this value" should be currentTarget
 
@@ -44,17 +44,17 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
     for cur_target in chain.as_slice().iter().rev() {
         let stopped = match cur_target.get_listeners_for(type_.as_slice(), Capturing) {
             Some(listeners) => {
-                event.current_target.assign(Some(cur_target.deref().clone()));
+                event.set_current_target(cur_target.deref().clone());
                 for listener in listeners.iter() {
                     // Explicitly drop any exception on the floor.
                     let _ = listener.HandleEvent_(**cur_target, event, ReportExceptions);
 
-                    if event.stop_immediate.get() {
+                    if event.stop_immediate() {
                         break;
                     }
                 }
 
-                event.stop_propagation.get()
+                event.stop_propagation()
             }
             None => false
         };
@@ -65,9 +65,9 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
     }
 
     /* at target */
-    if !event.stop_propagation.get() {
-        event.phase.set(PhaseAtTarget);
-        event.current_target.assign(Some(target.clone()));
+    if !event.stop_propagation() {
+        event.set_phase(PhaseAtTarget);
+        event.set_current_target(target.clone());
 
         let opt_listeners = target.get_listeners(type_.as_slice());
         for listeners in opt_listeners.iter() {
@@ -75,7 +75,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
                 // Explicitly drop any exception on the floor.
                 let _ = listener.HandleEvent_(target, event, ReportExceptions);
 
-                if event.stop_immediate.get() {
+                if event.stop_immediate() {
                     break;
                 }
             }
@@ -83,23 +83,23 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
     }
 
     /* bubbling */
-    if event.bubbles.get() && !event.stop_propagation.get() {
-        event.phase.set(PhaseBubbling);
+    if event.bubbles() && !event.stop_propagation() {
+        event.set_phase(PhaseBubbling);
 
         for cur_target in chain.iter() {
             let stopped = match cur_target.get_listeners_for(type_.as_slice(), Bubbling) {
                 Some(listeners) => {
-                    event.current_target.assign(Some(cur_target.deref().clone()));
+                    event.set_current_target(cur_target.deref().clone());
                     for listener in listeners.iter() {
                         // Explicitly drop any exception on the floor.
                         let _ = listener.HandleEvent_(**cur_target, event, ReportExceptions);
 
-                        if event.stop_immediate.get() {
+                        if event.stop_immediate() {
                             break;
                         }
                     }
 
-                    event.stop_propagation.get()
+                    event.stop_propagation()
                 }
                 None => false
             };
@@ -131,9 +131,9 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
         let _ = chain.pop();
     }
 
-    event.dispatching.set(false);
-    event.phase.set(PhaseNone);
-    event.current_target.clear();
+    event.set_dispatching(false);
+    event.set_phase(PhaseNone);
+    event.clear_current_target();
 
     !event.DefaultPrevented()
 }
diff --git a/components/script/dom/eventtarget.rs b/components/script/dom/eventtarget.rs
index bb6c8000426..e51272cff6b 100644
--- a/components/script/dom/eventtarget.rs
+++ b/components/script/dom/eventtarget.rs
@@ -59,15 +59,17 @@ impl EventListenerType {
 
 #[deriving(PartialEq)]
 #[jstraceable]
+#[privatize]
 pub struct EventListenerEntry {
-    pub phase: ListenerPhase,
-    pub listener: EventListenerType
+    phase: ListenerPhase,
+    listener: EventListenerType
 }
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct EventTarget {
-    pub type_id: EventTargetTypeId,
+    type_id: EventTargetTypeId,
     reflector_: Reflector,
     handlers: RefCell<HashMap<DOMString, Vec<EventListenerEntry>>>,
 }
@@ -94,6 +96,11 @@ impl EventTarget {
             filtered.map(|entry| entry.listener.get_listener()).collect()
         })
     }
+
+    #[inline]
+    pub fn type_id<'a>(&'a self) -> &'a EventTargetTypeId {
+        &self.type_id
+    }
 }
 
 pub trait EventTargetHelpers {
@@ -121,7 +128,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     fn dispatch_event_with_target(self,
                                   target: Option<JSRef<EventTarget>>,
                                   event: JSRef<Event>) -> Fallible<bool> {
-        if event.dispatching.get() || !event.initialized.get() {
+        if event.dispatching() || !event.initialized() {
             return Err(InvalidState);
         }
         Ok(dispatch_event(self, target, event))
diff --git a/components/script/dom/file.rs b/components/script/dom/file.rs
index 69eaf491d1c..cb42537f63f 100644
--- a/components/script/dom/file.rs
+++ b/components/script/dom/file.rs
@@ -12,10 +12,11 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct File {
-    pub blob: Blob,
-    pub name: DOMString,
-    pub type_: BlobType
+    blob: Blob,
+    name: DOMString,
+    type_: BlobType
 }
 
 impl File {
@@ -34,6 +35,10 @@ impl File {
                            global,
                            FileBinding::Wrap)
     }
+
+    pub fn name<'a>(&'a self) -> &'a DOMString {
+        &self.name
+    }
 }
 
 impl<'a> FileMethods for JSRef<'a, File> {
diff --git a/components/script/dom/formdata.rs b/components/script/dom/formdata.rs
index b0730355bcd..140ff809125 100644
--- a/components/script/dom/formdata.rs
+++ b/components/script/dom/formdata.rs
@@ -27,6 +27,7 @@ pub enum FormDatum {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct FormData {
     data: RefCell<HashMap<DOMString, Vec<FormDatum>>>,
     reflector_: Reflector,
@@ -112,7 +113,7 @@ impl PrivateFormDataHelpers for FormData {
     fn get_file_from_blob(&self, value: JSRef<Blob>, filename: Option<DOMString>) -> Temporary<File> {
         let global = self.global.root();
         let f: Option<JSRef<File>> = FileCast::to_ref(value);
-        let name = filename.unwrap_or(f.map(|inner| inner.name.clone()).unwrap_or("blob".to_string()));
+        let name = filename.unwrap_or(f.map(|inner| inner.name().clone()).unwrap_or("blob".to_string()));
         File::new(&global.root_ref(), value, name)
     }
 }
diff --git a/components/script/dom/htmlanchorelement.rs b/components/script/dom/htmlanchorelement.rs
index 74ab2976456..19492ef6264 100644
--- a/components/script/dom/htmlanchorelement.rs
+++ b/components/script/dom/htmlanchorelement.rs
@@ -23,13 +23,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLAnchorElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLAnchorElementDerived for EventTarget {
     fn is_htmlanchorelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLAnchorElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAnchorElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlappletelement.rs b/components/script/dom/htmlappletelement.rs
index b40bc50bc67..eeb7eb35188 100644
--- a/components/script/dom/htmlappletelement.rs
+++ b/components/script/dom/htmlappletelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLAppletElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLAppletElementDerived for EventTarget {
     fn is_htmlappletelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLAppletElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAppletElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlareaelement.rs b/components/script/dom/htmlareaelement.rs
index 57c3fe883d4..c4272fde753 100644
--- a/components/script/dom/htmlareaelement.rs
+++ b/components/script/dom/htmlareaelement.rs
@@ -16,13 +16,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLAreaElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLAreaElementDerived for EventTarget {
     fn is_htmlareaelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLAreaElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAreaElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlaudioelement.rs b/components/script/dom/htmlaudioelement.rs
index 0d419c40338..9eed3b6c1db 100644
--- a/components/script/dom/htmlaudioelement.rs
+++ b/components/script/dom/htmlaudioelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLAudioElement {
-    pub htmlmediaelement: HTMLMediaElement
+    htmlmediaelement: HTMLMediaElement
 }
 
 impl HTMLAudioElementDerived for EventTarget {
     fn is_htmlaudioelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLAudioElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLAudioElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlbaseelement.rs b/components/script/dom/htmlbaseelement.rs
index 1a9d0e833bd..7bf12bb0822 100644
--- a/components/script/dom/htmlbaseelement.rs
+++ b/components/script/dom/htmlbaseelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLBaseElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLBaseElementDerived for EventTarget {
     fn is_htmlbaseelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLBaseElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBaseElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlbodyelement.rs b/components/script/dom/htmlbodyelement.rs
index a73e6ef40b6..7c0c0c17711 100644
--- a/components/script/dom/htmlbodyelement.rs
+++ b/components/script/dom/htmlbodyelement.rs
@@ -22,13 +22,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLBodyElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLBodyElementDerived for EventTarget {
     fn is_htmlbodyelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLBodyElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBodyElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlbrelement.rs b/components/script/dom/htmlbrelement.rs
index 4585c433ae2..74811afe074 100644
--- a/components/script/dom/htmlbrelement.rs
+++ b/components/script/dom/htmlbrelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLBRElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLBRElementDerived for EventTarget {
     fn is_htmlbrelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLBRElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLBRElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlbuttonelement.rs b/components/script/dom/htmlbuttonelement.rs
index f12035d148e..af4dec6dcb3 100644
--- a/components/script/dom/htmlbuttonelement.rs
+++ b/components/script/dom/htmlbuttonelement.rs
@@ -22,13 +22,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLButtonElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLButtonElementDerived for EventTarget {
     fn is_htmlbuttonelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLButtonElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLButtonElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs
index 3f7d11531bc..ac5a5d7ded5 100644
--- a/components/script/dom/htmlcanvaselement.rs
+++ b/components/script/dom/htmlcanvaselement.rs
@@ -30,8 +30,9 @@ static DefaultHeight: u32 = 150;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLCanvasElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
     context: MutNullableJS<CanvasRenderingContext2D>,
     width: Cell<u32>,
     height: Cell<u32>,
@@ -39,7 +40,7 @@ pub struct HTMLCanvasElement {
 
 impl HTMLCanvasElementDerived for EventTarget {
     fn is_htmlcanvaselement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLCanvasElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLCanvasElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlcollection.rs b/components/script/dom/htmlcollection.rs
index 00c19ad8f92..035ee8287a4 100644
--- a/components/script/dom/htmlcollection.rs
+++ b/components/script/dom/htmlcollection.rs
@@ -31,6 +31,7 @@ pub enum CollectionTypeId {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLCollection {
     collection: CollectionTypeId,
     reflector_: Reflector,
@@ -66,7 +67,7 @@ impl HTMLCollection {
             fn filter(&self, elem: JSRef<Element>, _root: JSRef<Node>) -> bool {
                 match self.namespace_filter {
                     None => true,
-                    Some(ref namespace) => elem.namespace == *namespace
+                    Some(ref namespace) => *elem.namespace() == *namespace
                 }
             }
         }
@@ -88,9 +89,9 @@ impl HTMLCollection {
         impl CollectionFilter for TagNameFilter {
             fn filter(&self, elem: JSRef<Element>, _root: JSRef<Node>) -> bool {
                 if elem.html_element_in_html_document() {
-                    elem.local_name == self.ascii_lower_tag
+                    *elem.local_name() == self.ascii_lower_tag
                 } else {
-                    elem.local_name == self.tag
+                    *elem.local_name() == self.tag
                 }
             }
         }
@@ -120,11 +121,11 @@ impl HTMLCollection {
             fn filter(&self, elem: JSRef<Element>, _root: JSRef<Node>) -> bool {
                 let ns_match = match self.namespace_filter {
                     Some(ref namespace) => {
-                        elem.namespace == *namespace
+                        *elem.namespace() == *namespace
                     },
                     None => true
                 };
-                ns_match && elem.local_name == self.tag
+                ns_match && *elem.local_name() == self.tag
             }
         }
         let filter = TagNameNSFilter {
diff --git a/components/script/dom/htmldataelement.rs b/components/script/dom/htmldataelement.rs
index aeafde6d06e..58e2ad90f73 100644
--- a/components/script/dom/htmldataelement.rs
+++ b/components/script/dom/htmldataelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLDataElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLDataElementDerived for EventTarget {
     fn is_htmldataelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLDataElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDataElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmldatalistelement.rs b/components/script/dom/htmldatalistelement.rs
index 9c57a7176ff..3363997142b 100644
--- a/components/script/dom/htmldatalistelement.rs
+++ b/components/script/dom/htmldatalistelement.rs
@@ -18,13 +18,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLDataListElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLDataListElementDerived for EventTarget {
     fn is_htmldatalistelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLDataListElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDataListElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmldirectoryelement.rs b/components/script/dom/htmldirectoryelement.rs
index b55bd539781..f1cd840e298 100644
--- a/components/script/dom/htmldirectoryelement.rs
+++ b/components/script/dom/htmldirectoryelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLDirectoryElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLDirectoryElementDerived for EventTarget {
     fn is_htmldirectoryelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLDirectoryElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDirectoryElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmldivelement.rs b/components/script/dom/htmldivelement.rs
index c164beec7d0..d35ad9dc4be 100644
--- a/components/script/dom/htmldivelement.rs
+++ b/components/script/dom/htmldivelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLDivElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLDivElementDerived for EventTarget {
     fn is_htmldivelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLDivElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDivElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmldlistelement.rs b/components/script/dom/htmldlistelement.rs
index d107a277faf..643f7e81263 100644
--- a/components/script/dom/htmldlistelement.rs
+++ b/components/script/dom/htmldlistelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLDListElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLDListElementDerived for EventTarget {
     fn is_htmldlistelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLDListElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLDListElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlelement.rs b/components/script/dom/htmlelement.rs
index 65f6fb33c36..00ea736a07f 100644
--- a/components/script/dom/htmlelement.rs
+++ b/components/script/dom/htmlelement.rs
@@ -22,13 +22,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLElement {
-    pub element: Element
+    element: Element
 }
 
 impl HTMLElementDerived for EventTarget {
     fn is_htmlelement(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             NodeTargetTypeId(ElementNodeTypeId(ElementTypeId_)) => false,
             NodeTargetTypeId(ElementNodeTypeId(_)) => true,
             _ => false
@@ -48,6 +49,11 @@ impl HTMLElement {
         let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, prefix, document);
         Node::reflect_node(box element, document, HTMLElementBinding::Wrap)
     }
+
+    #[inline]
+    pub fn element<'a>(&'a self) -> &'a Element {
+        &self.element
+    }
 }
 
 trait PrivateHTMLElementHelpers {
diff --git a/components/script/dom/htmlembedelement.rs b/components/script/dom/htmlembedelement.rs
index 587a0d375f3..e8de6bbd08a 100644
--- a/components/script/dom/htmlembedelement.rs
+++ b/components/script/dom/htmlembedelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLEmbedElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLEmbedElementDerived for EventTarget {
     fn is_htmlembedelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLEmbedElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLEmbedElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlfieldsetelement.rs b/components/script/dom/htmlfieldsetelement.rs
index db043564710..4ec69852e95 100644
--- a/components/script/dom/htmlfieldsetelement.rs
+++ b/components/script/dom/htmlfieldsetelement.rs
@@ -23,13 +23,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLFieldSetElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLFieldSetElementDerived for EventTarget {
     fn is_htmlfieldsetelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLFieldSetElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFieldSetElementTypeId))
     }
 }
 
@@ -57,7 +58,7 @@ impl<'a> HTMLFieldSetElementMethods for JSRef<'a, HTMLFieldSetElement> {
                 static tag_names: StaticStringVec = &["button", "fieldset", "input",
                     "keygen", "object", "output", "select", "textarea"];
                 let root: JSRef<Element> = ElementCast::to_ref(root).unwrap();
-                elem != root && tag_names.iter().any(|&tag_name| tag_name == elem.local_name.as_slice())
+                elem != root && tag_names.iter().any(|&tag_name| tag_name == elem.local_name().as_slice())
             }
         }
         let node: JSRef<Node> = NodeCast::from_ref(self);
diff --git a/components/script/dom/htmlfontelement.rs b/components/script/dom/htmlfontelement.rs
index 0feede649a4..5f11a672cc4 100644
--- a/components/script/dom/htmlfontelement.rs
+++ b/components/script/dom/htmlfontelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLFontElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLFontElementDerived for EventTarget {
     fn is_htmlfontelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLFontElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFontElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlformelement.rs b/components/script/dom/htmlformelement.rs
index 75ce3119648..639d2296608 100644
--- a/components/script/dom/htmlformelement.rs
+++ b/components/script/dom/htmlformelement.rs
@@ -31,13 +31,14 @@ use url::form_urlencoded::serialize;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLFormElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLFormElementDerived for EventTarget {
     fn is_htmlformelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLFormElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFormElementTypeId))
     }
 }
 
@@ -217,8 +218,8 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
         }
 
         // This is wrong. https://html.spec.whatwg.org/multipage/forms.html#planned-navigation
-        let ScriptChan(ref script_chan) = win.script_chan;
-        script_chan.send(TriggerLoadMsg(win.page.id, load_data));
+        let ScriptChan(ref script_chan) = *win.script_chan();
+        script_chan.send(TriggerLoadMsg(win.page().id, load_data));
     }
 
     fn get_form_dataset(self, _submitter: Option<FormSubmitter>) -> Vec<FormDatum> {
diff --git a/components/script/dom/htmlframeelement.rs b/components/script/dom/htmlframeelement.rs
index 62febac5b7f..76a8b190cb1 100644
--- a/components/script/dom/htmlframeelement.rs
+++ b/components/script/dom/htmlframeelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLFrameElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLFrameElementDerived for EventTarget {
     fn is_htmlframeelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLFrameElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFrameElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlframesetelement.rs b/components/script/dom/htmlframesetelement.rs
index a2599a734d6..168ab8f73ec 100644
--- a/components/script/dom/htmlframesetelement.rs
+++ b/components/script/dom/htmlframesetelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLFrameSetElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLFrameSetElementDerived for EventTarget {
     fn is_htmlframesetelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLFrameSetElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLFrameSetElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlheadelement.rs b/components/script/dom/htmlheadelement.rs
index c972400c0d6..51cbf9f9b88 100644
--- a/components/script/dom/htmlheadelement.rs
+++ b/components/script/dom/htmlheadelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLHeadElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLHeadElementDerived for EventTarget {
     fn is_htmlheadelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLHeadElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHeadElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlheadingelement.rs b/components/script/dom/htmlheadingelement.rs
index ace784a96a9..1f91a89abee 100644
--- a/components/script/dom/htmlheadingelement.rs
+++ b/components/script/dom/htmlheadingelement.rs
@@ -25,14 +25,15 @@ pub enum HeadingLevel {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLHeadingElement {
-    pub htmlelement: HTMLElement,
-    pub level: HeadingLevel,
+    htmlelement: HTMLElement,
+    level: HeadingLevel,
 }
 
 impl HTMLHeadingElementDerived for EventTarget {
     fn is_htmlheadingelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLHeadingElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHeadingElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlhrelement.rs b/components/script/dom/htmlhrelement.rs
index 8167c5854f7..95400b2713d 100644
--- a/components/script/dom/htmlhrelement.rs
+++ b/components/script/dom/htmlhrelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLHRElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLHRElementDerived for EventTarget {
     fn is_htmlhrelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLHRElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHRElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlhtmlelement.rs b/components/script/dom/htmlhtmlelement.rs
index 279eb740709..f3cd408a31d 100644
--- a/components/script/dom/htmlhtmlelement.rs
+++ b/components/script/dom/htmlhtmlelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLHtmlElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLHtmlElementDerived for EventTarget {
     fn is_htmlhtmlelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLHtmlElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLHtmlElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmliframeelement.rs b/components/script/dom/htmliframeelement.rs
index 94353173333..77bbfcf9013 100644
--- a/components/script/dom/htmliframeelement.rs
+++ b/components/script/dom/htmliframeelement.rs
@@ -41,22 +41,36 @@ enum SandboxAllowance {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLIFrameElement {
-    pub htmlelement: HTMLElement,
-    pub size: Cell<Option<IFrameSize>>,
-    pub sandbox: Cell<Option<u8>>,
+    htmlelement: HTMLElement,
+    size: Cell<Option<IFrameSize>>,
+    sandbox: Cell<Option<u8>>,
 }
 
 impl HTMLIFrameElementDerived for EventTarget {
     fn is_htmliframeelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLIFrameElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLIFrameElementTypeId))
     }
 }
 
 #[jstraceable]
+#[privatize]
 pub struct IFrameSize {
-    pub pipeline_id: PipelineId,
-    pub subpage_id: SubpageId,
+    pipeline_id: PipelineId,
+    subpage_id: SubpageId,
+}
+
+impl IFrameSize {
+    #[inline]
+    pub fn pipeline_id<'a>(&'a self) -> &'a PipelineId {
+        &self.pipeline_id
+    }
+
+    #[inline]
+    pub fn subpage_id<'a>(&'a self) -> &'a SubpageId {
+        &self.subpage_id
+    }
 }
 
 pub trait HTMLIFrameElementHelpers {
@@ -126,6 +140,11 @@ impl HTMLIFrameElement {
         let element = HTMLIFrameElement::new_inherited(localName, prefix, document);
         Node::reflect_node(box element, document, HTMLIFrameElementBinding::Wrap)
     }
+
+    #[inline]
+    pub fn size(&self) -> Option<IFrameSize> {
+        self.size.get()
+    }
 }
 
 impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
@@ -152,7 +171,7 @@ impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
     fn GetContentWindow(self) -> Option<Temporary<Window>> {
         self.size.get().and_then(|size| {
             let window = window_from_node(self).root();
-            let children = window.page.children.borrow();
+            let children = window.page().children.borrow();
             let child = children.iter().find(|child| {
                 child.subpage_id.unwrap() == size.subpage_id
             });
diff --git a/components/script/dom/htmlimageelement.rs b/components/script/dom/htmlimageelement.rs
index 299cb4923ca..d8a4f9d67f6 100644
--- a/components/script/dom/htmlimageelement.rs
+++ b/components/script/dom/htmlimageelement.rs
@@ -26,14 +26,15 @@ use std::cell::RefCell;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLImageElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
     image: RefCell<Option<Url>>,
 }
 
 impl HTMLImageElementDerived for EventTarget {
     fn is_htmlimageelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLImageElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLImageElementTypeId))
     }
 }
 
@@ -47,8 +48,8 @@ impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
     fn update_image(self, value: Option<(DOMString, &Url)>) {
         let node: JSRef<Node> = NodeCast::from_ref(self);
         let document = node.owner_doc().root();
-        let window = document.window.root();
-        let image_cache = &window.image_cache_task;
+        let window = document.window().root();
+        let image_cache = window.image_cache_task();
         match value {
             None => {
                 *self.image.borrow_mut() = None;
diff --git a/components/script/dom/htmlinputelement.rs b/components/script/dom/htmlinputelement.rs
index ab9818d99f0..b63fee7917b 100644
--- a/components/script/dom/htmlinputelement.rs
+++ b/components/script/dom/htmlinputelement.rs
@@ -45,8 +45,9 @@ enum InputType {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLInputElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
     input_type: Cell<InputType>,
     checked: Cell<bool>,
     uncommitted_value: RefCell<Option<String>>,
@@ -56,7 +57,7 @@ pub struct HTMLInputElement {
 
 impl HTMLInputElementDerived for EventTarget {
     fn is_htmlinputelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLInputElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLInputElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmllabelelement.rs b/components/script/dom/htmllabelelement.rs
index 7ff84e0075a..59fe5479f53 100644
--- a/components/script/dom/htmllabelelement.rs
+++ b/components/script/dom/htmllabelelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLLabelElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLLabelElementDerived for EventTarget {
     fn is_htmllabelelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLLabelElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLabelElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmllegendelement.rs b/components/script/dom/htmllegendelement.rs
index 86bf81ca7ec..2d4725528ab 100644
--- a/components/script/dom/htmllegendelement.rs
+++ b/components/script/dom/htmllegendelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLLegendElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLLegendElementDerived for EventTarget {
     fn is_htmllegendelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLLegendElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLegendElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmllielement.rs b/components/script/dom/htmllielement.rs
index 948430d3eda..f4d789ec549 100644
--- a/components/script/dom/htmllielement.rs
+++ b/components/script/dom/htmllielement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLLIElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLLIElementDerived for EventTarget {
     fn is_htmllielement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLLIElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLIElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index 41810b51f26..1c641562d81 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/components/script/dom/htmllinkelement.rs
@@ -23,13 +23,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLLinkElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLLinkElementDerived for EventTarget {
     fn is_htmllinkelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLLinkElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLLinkElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlmapelement.rs b/components/script/dom/htmlmapelement.rs
index 585102c2af9..0cca9e14a84 100644
--- a/components/script/dom/htmlmapelement.rs
+++ b/components/script/dom/htmlmapelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLMapElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLMapElementDerived for EventTarget {
     fn is_htmlmapelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLMapElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMapElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlmediaelement.rs b/components/script/dom/htmlmediaelement.rs
index ef841c31a35..54ff9308672 100644
--- a/components/script/dom/htmlmediaelement.rs
+++ b/components/script/dom/htmlmediaelement.rs
@@ -14,13 +14,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLMediaElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLMediaElementDerived for EventTarget {
     fn is_htmlmediaelement(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             NodeTargetTypeId(ElementNodeTypeId(HTMLVideoElementTypeId)) |
             NodeTargetTypeId(ElementNodeTypeId(HTMLAudioElementTypeId)) => true,
             _ => false
@@ -34,6 +35,11 @@ impl HTMLMediaElement {
             htmlelement: HTMLElement::new_inherited(type_id, tag_name, prefix, document)
         }
     }
+
+    #[inline]
+    pub fn htmlelement<'a>(&'a self) -> &'a HTMLElement {
+        &self.htmlelement
+    }
 }
 
 impl Reflectable for HTMLMediaElement {
diff --git a/components/script/dom/htmlmetaelement.rs b/components/script/dom/htmlmetaelement.rs
index 34873293440..4a38ebfbc3a 100644
--- a/components/script/dom/htmlmetaelement.rs
+++ b/components/script/dom/htmlmetaelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLMetaElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLMetaElementDerived for EventTarget {
     fn is_htmlmetaelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLMetaElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMetaElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlmeterelement.rs b/components/script/dom/htmlmeterelement.rs
index 1648cde9751..76e2f9400d0 100644
--- a/components/script/dom/htmlmeterelement.rs
+++ b/components/script/dom/htmlmeterelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLMeterElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLMeterElementDerived for EventTarget {
     fn is_htmlmeterelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLMeterElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLMeterElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlmodelement.rs b/components/script/dom/htmlmodelement.rs
index 35ebb61e6ad..0fa5e2e0cd2 100644
--- a/components/script/dom/htmlmodelement.rs
+++ b/components/script/dom/htmlmodelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLModElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLModElementDerived for EventTarget {
     fn is_htmlmodelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLModElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLModElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlobjectelement.rs b/components/script/dom/htmlobjectelement.rs
index 1d39c3a07f5..d7a073150ef 100644
--- a/components/script/dom/htmlobjectelement.rs
+++ b/components/script/dom/htmlobjectelement.rs
@@ -27,13 +27,14 @@ use url::Url;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLObjectElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLObjectElementDerived for EventTarget {
     fn is_htmlobjectelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLObjectElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLObjectElementTypeId))
     }
 }
 
@@ -108,7 +109,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLObjectElement> {
 
         if "data" == name.as_slice() {
             let window = window_from_node(*self).root();
-            self.process_data_url(window.image_cache_task.clone());
+            self.process_data_url(window.image_cache_task().clone());
         }
     }
 }
diff --git a/components/script/dom/htmlolistelement.rs b/components/script/dom/htmlolistelement.rs
index ae36ce0d628..82c67341c31 100644
--- a/components/script/dom/htmlolistelement.rs
+++ b/components/script/dom/htmlolistelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLOListElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLOListElementDerived for EventTarget {
     fn is_htmlolistelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLOListElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOListElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmloptgroupelement.rs b/components/script/dom/htmloptgroupelement.rs
index 9e0cade682d..e7fe66c2e0d 100644
--- a/components/script/dom/htmloptgroupelement.rs
+++ b/components/script/dom/htmloptgroupelement.rs
@@ -20,13 +20,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLOptGroupElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLOptGroupElementDerived for EventTarget {
     fn is_htmloptgroupelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLOptGroupElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOptGroupElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmloptionelement.rs b/components/script/dom/htmloptionelement.rs
index ecd8b2d498b..e44011bc2ce 100644
--- a/components/script/dom/htmloptionelement.rs
+++ b/components/script/dom/htmloptionelement.rs
@@ -24,13 +24,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLOptionElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLOptionElementDerived for EventTarget {
     fn is_htmloptionelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLOptionElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOptionElementTypeId))
     }
 }
 
@@ -50,7 +51,7 @@ impl HTMLOptionElement {
 
 fn collect_text(node: &JSRef<Node>, value: &mut DOMString) {
     let elem: JSRef<Element> = ElementCast::to_ref(*node).unwrap();
-    let svg_script = elem.namespace == ns!(SVG) && elem.local_name.as_slice() == "script";
+    let svg_script = *elem.namespace() == ns!(SVG) && elem.local_name().as_slice() == "script";
     let html_script = node.is_htmlscriptelement();
     if svg_script || html_script {
         return;
diff --git a/components/script/dom/htmloutputelement.rs b/components/script/dom/htmloutputelement.rs
index 1442980de26..0b9f0b0d872 100644
--- a/components/script/dom/htmloutputelement.rs
+++ b/components/script/dom/htmloutputelement.rs
@@ -17,13 +17,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLOutputElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLOutputElementDerived for EventTarget {
     fn is_htmloutputelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLOutputElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLOutputElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlparagraphelement.rs b/components/script/dom/htmlparagraphelement.rs
index 6b91ba18afc..66a70b6963f 100644
--- a/components/script/dom/htmlparagraphelement.rs
+++ b/components/script/dom/htmlparagraphelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLParagraphElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLParagraphElementDerived for EventTarget {
     fn is_htmlparagraphelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLParagraphElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLParagraphElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlparamelement.rs b/components/script/dom/htmlparamelement.rs
index 2b664425e85..7845a767512 100644
--- a/components/script/dom/htmlparamelement.rs
+++ b/components/script/dom/htmlparamelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLParamElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLParamElementDerived for EventTarget {
     fn is_htmlparamelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLParamElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLParamElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlpreelement.rs b/components/script/dom/htmlpreelement.rs
index 9ec13769e78..89799212226 100644
--- a/components/script/dom/htmlpreelement.rs
+++ b/components/script/dom/htmlpreelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLPreElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLPreElementDerived for EventTarget {
     fn is_htmlpreelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLPreElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLPreElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlprogresselement.rs b/components/script/dom/htmlprogresselement.rs
index c9506716562..65db0e536af 100644
--- a/components/script/dom/htmlprogresselement.rs
+++ b/components/script/dom/htmlprogresselement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLProgressElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLProgressElementDerived for EventTarget {
     fn is_htmlprogresselement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLProgressElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLProgressElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlquoteelement.rs b/components/script/dom/htmlquoteelement.rs
index 532554254c2..f028b3d9c5d 100644
--- a/components/script/dom/htmlquoteelement.rs
+++ b/components/script/dom/htmlquoteelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLQuoteElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLQuoteElementDerived for EventTarget {
     fn is_htmlquoteelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLQuoteElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLQuoteElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs
index 3c200b9f324..138c7ea8679 100644
--- a/components/script/dom/htmlscriptelement.rs
+++ b/components/script/dom/htmlscriptelement.rs
@@ -20,13 +20,14 @@ use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS, StaticStringVec};
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLScriptElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLScriptElementDerived for EventTarget {
     fn is_htmlscriptelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLScriptElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLScriptElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlselectelement.rs b/components/script/dom/htmlselectelement.rs
index 8c86318c38c..d825bf1f3a1 100644
--- a/components/script/dom/htmlselectelement.rs
+++ b/components/script/dom/htmlselectelement.rs
@@ -23,13 +23,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLSelectElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLSelectElementDerived for EventTarget {
     fn is_htmlselectelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLSelectElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSelectElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlserializer.rs b/components/script/dom/htmlserializer.rs
index f8b57996375..e9de8987ac0 100644
--- a/components/script/dom/htmlserializer.rs
+++ b/components/script/dom/htmlserializer.rs
@@ -69,7 +69,7 @@ pub fn serialize(iterator: &mut NodeIterator) -> String {
 
 fn serialize_comment(comment: JSRef<Comment>, html: &mut String) {
     html.push_str("<!--");
-    html.push_str(comment.characterdata.data.borrow().as_slice());
+    html.push_str(comment.characterdata().data().as_slice());
     html.push_str("-->");
 }
 
@@ -78,49 +78,49 @@ fn serialize_text(text: JSRef<Text>, html: &mut String) {
     match text_node.parent_node().map(|node| node.root()) {
         Some(ref parent) if parent.is_element() => {
             let elem: JSRef<Element> = ElementCast::to_ref(**parent).unwrap();
-            match elem.local_name.as_slice() {
+            match elem.local_name().as_slice() {
                 "style" | "script" | "xmp" | "iframe" |
                 "noembed" | "noframes" | "plaintext" |
-                "noscript" if elem.namespace == ns!(HTML)
-                => html.push_str(text.characterdata.data.borrow().as_slice()),
-                _ => escape(text.characterdata.data.borrow().as_slice(), false, html)
+                "noscript" if *elem.namespace() == ns!(HTML)
+                => html.push_str(text.characterdata().data().as_slice()),
+                _ => escape(text.characterdata().data().as_slice(), false, html)
             }
         }
-        _ => escape(text.characterdata.data.borrow().as_slice(), false, html)
+        _ => escape(text.characterdata().data().as_slice(), false, html)
     }
 }
 
 fn serialize_processing_instruction(processing_instruction: JSRef<ProcessingInstruction>,
                                     html: &mut String) {
     html.push_str("<?");
-    html.push_str(processing_instruction.target.as_slice());
+    html.push_str(processing_instruction.target().as_slice());
     html.push_char(' ');
-    html.push_str(processing_instruction.characterdata.data.borrow().as_slice());
+    html.push_str(processing_instruction.characterdata().data().as_slice());
     html.push_str("?>");
 }
 
 fn serialize_doctype(doctype: JSRef<DocumentType>, html: &mut String) {
     html.push_str("<!DOCTYPE");
-    html.push_str(doctype.name.as_slice());
+    html.push_str(doctype.name().as_slice());
     html.push_char('>');
 }
 
 fn serialize_elem(elem: JSRef<Element>, open_elements: &mut Vec<String>, html: &mut String) {
     html.push_char('<');
-    html.push_str(elem.local_name.as_slice());
-    for attr in elem.attrs.borrow().iter() {
+    html.push_str(elem.local_name().as_slice());
+    for attr in elem.attrs().iter() {
         let attr = attr.root();
         serialize_attr(*attr, html);
     };
     html.push_char('>');
 
-    match elem.local_name.as_slice() {
-        "pre" | "listing" | "textarea" if elem.namespace == ns!(HTML) => {
+    match elem.local_name().as_slice() {
+        "pre" | "listing" | "textarea" if *elem.namespace() == ns!(HTML) => {
             let node: JSRef<Node> = NodeCast::from_ref(elem);
             match node.first_child().map(|child| child.root()) {
                 Some(ref child) if child.is_text() => {
                     let text: JSRef<CharacterData> = CharacterDataCast::to_ref(**child).unwrap();
-                    if text.data.borrow().len() > 0 && text.data.borrow().as_slice().char_at(0) == '\n' {
+                    if text.data().len() > 0 && text.data().as_slice().char_at(0) == '\n' {
                         html.push_char('\x0A');
                     }
                 },
@@ -131,26 +131,26 @@ fn serialize_elem(elem: JSRef<Element>, open_elements: &mut Vec<String>, html: &
     }
 
     if !(elem.is_void()) {
-        open_elements.push(elem.local_name.as_slice().to_string());
+        open_elements.push(elem.local_name().as_slice().to_string());
     }
 }
 
 fn serialize_attr(attr: JSRef<Attr>, html: &mut String) {
     html.push_char(' ');
-    if attr.namespace == ns!(XML) {
+    if *attr.namespace() == ns!(XML) {
         html.push_str("xml:");
         html.push_str(attr.local_name().as_slice());
-    } else if attr.namespace == ns!(XMLNS) &&
+    } else if *attr.namespace() == ns!(XMLNS) &&
         *attr.local_name() == Atom::from_slice("xmlns") {
         html.push_str("xmlns");
-    } else if attr.namespace == ns!(XMLNS) {
+    } else if *attr.namespace() == ns!(XMLNS) {
         html.push_str("xmlns:");
         html.push_str(attr.local_name().as_slice());
-    } else if attr.namespace == ns!(XLink) {
+    } else if *attr.namespace() == ns!(XLink) {
         html.push_str("xlink:");
         html.push_str(attr.local_name().as_slice());
     } else {
-        html.push_str(attr.name.as_slice());
+        html.push_str(attr.name().as_slice());
     };
     html.push_str("=\"");
     escape(attr.value().as_slice(), true, html);
diff --git a/components/script/dom/htmlsourceelement.rs b/components/script/dom/htmlsourceelement.rs
index 07d971c0dff..8a7578febdf 100644
--- a/components/script/dom/htmlsourceelement.rs
+++ b/components/script/dom/htmlsourceelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLSourceElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLSourceElementDerived for EventTarget {
     fn is_htmlsourceelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLSourceElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSourceElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlspanelement.rs b/components/script/dom/htmlspanelement.rs
index a3a55d5b00a..fba53a8b795 100644
--- a/components/script/dom/htmlspanelement.rs
+++ b/components/script/dom/htmlspanelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLSpanElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLSpanElementDerived for EventTarget {
     fn is_htmlspanelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLSpanElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLSpanElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs
index b0c190b7aeb..46c631fc730 100644
--- a/components/script/dom/htmlstyleelement.rs
+++ b/components/script/dom/htmlstyleelement.rs
@@ -19,13 +19,14 @@ use style::Stylesheet;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLStyleElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLStyleElementDerived for EventTarget {
     fn is_htmlstyleelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLStyleElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLStyleElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltablecaptionelement.rs b/components/script/dom/htmltablecaptionelement.rs
index 68a0feab854..e1ecf1914ce 100644
--- a/components/script/dom/htmltablecaptionelement.rs
+++ b/components/script/dom/htmltablecaptionelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTableCaptionElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLTableCaptionElementDerived for EventTarget {
     fn is_htmltablecaptionelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTableCaptionElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableCaptionElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltablecellelement.rs b/components/script/dom/htmltablecellelement.rs
index f4fc2002fa9..95bcebf5480 100644
--- a/components/script/dom/htmltablecellelement.rs
+++ b/components/script/dom/htmltablecellelement.rs
@@ -14,13 +14,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTableCellElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTableCellElementDerived for EventTarget {
     fn is_htmltablecellelement(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             NodeTargetTypeId(ElementNodeTypeId(HTMLTableDataCellElementTypeId)) |
             NodeTargetTypeId(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId)) => true,
             _ => false
@@ -34,6 +35,11 @@ impl HTMLTableCellElement {
             htmlelement: HTMLElement::new_inherited(type_id, tag_name, prefix, document)
         }
     }
+
+    #[inline]
+    pub fn htmlelement<'a>(&'a self) -> &'a HTMLElement {
+        &self.htmlelement
+    }
 }
 
 impl Reflectable for HTMLTableCellElement {
diff --git a/components/script/dom/htmltablecolelement.rs b/components/script/dom/htmltablecolelement.rs
index 88bc8b7beb5..03caf0e22b8 100644
--- a/components/script/dom/htmltablecolelement.rs
+++ b/components/script/dom/htmltablecolelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTableColElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTableColElementDerived for EventTarget {
     fn is_htmltablecolelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTableColElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableColElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltabledatacellelement.rs b/components/script/dom/htmltabledatacellelement.rs
index 83569b1e08c..11b8b117a2c 100644
--- a/components/script/dom/htmltabledatacellelement.rs
+++ b/components/script/dom/htmltabledatacellelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTableDataCellElement {
-    pub htmltablecellelement: HTMLTableCellElement,
+    htmltablecellelement: HTMLTableCellElement,
 }
 
 impl HTMLTableDataCellElementDerived for EventTarget {
     fn is_htmltabledatacellelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTableDataCellElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableDataCellElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltableelement.rs b/components/script/dom/htmltableelement.rs
index 1d9b4eff9d0..e33a44cdd58 100644
--- a/components/script/dom/htmltableelement.rs
+++ b/components/script/dom/htmltableelement.rs
@@ -19,13 +19,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTableElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTableElementDerived for EventTarget {
     fn is_htmltableelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTableElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltableheadercellelement.rs b/components/script/dom/htmltableheadercellelement.rs
index 056c7b9d789..eae776a6903 100644
--- a/components/script/dom/htmltableheadercellelement.rs
+++ b/components/script/dom/htmltableheadercellelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTableHeaderCellElement {
-    pub htmltablecellelement: HTMLTableCellElement,
+    htmltablecellelement: HTMLTableCellElement,
 }
 
 impl HTMLTableHeaderCellElementDerived for EventTarget {
     fn is_htmltableheadercellelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableHeaderCellElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltablerowelement.rs b/components/script/dom/htmltablerowelement.rs
index 51fb63bd7e8..45f1f06fe28 100644
--- a/components/script/dom/htmltablerowelement.rs
+++ b/components/script/dom/htmltablerowelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTableRowElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTableRowElementDerived for EventTarget {
     fn is_htmltablerowelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTableRowElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableRowElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltablesectionelement.rs b/components/script/dom/htmltablesectionelement.rs
index 7b3eb02ebc1..f4a26c709ec 100644
--- a/components/script/dom/htmltablesectionelement.rs
+++ b/components/script/dom/htmltablesectionelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTableSectionElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTableSectionElementDerived for EventTarget {
     fn is_htmltablesectionelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTableSectionElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTableSectionElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltemplateelement.rs b/components/script/dom/htmltemplateelement.rs
index 523b8b8bae0..9e959937ec6 100644
--- a/components/script/dom/htmltemplateelement.rs
+++ b/components/script/dom/htmltemplateelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTemplateElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTemplateElementDerived for EventTarget {
     fn is_htmltemplateelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTemplateElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTemplateElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltextareaelement.rs b/components/script/dom/htmltextareaelement.rs
index d109a26c524..37fd0544f4f 100644
--- a/components/script/dom/htmltextareaelement.rs
+++ b/components/script/dom/htmltextareaelement.rs
@@ -20,13 +20,14 @@ use string_cache::Atom;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTextAreaElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTextAreaElementDerived for EventTarget {
     fn is_htmltextareaelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTextAreaElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTextAreaElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltimeelement.rs b/components/script/dom/htmltimeelement.rs
index 5d71321b88b..4cf70e20214 100644
--- a/components/script/dom/htmltimeelement.rs
+++ b/components/script/dom/htmltimeelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTimeElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLTimeElementDerived for EventTarget {
     fn is_htmltimeelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTimeElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTimeElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmltitleelement.rs b/components/script/dom/htmltitleelement.rs
index 1004d1c7473..5e7d8fbd1b3 100644
--- a/components/script/dom/htmltitleelement.rs
+++ b/components/script/dom/htmltitleelement.rs
@@ -18,13 +18,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTitleElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTitleElementDerived for EventTarget {
     fn is_htmltitleelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTitleElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTitleElementTypeId))
     }
 }
 
@@ -50,7 +51,7 @@ impl<'a> HTMLTitleElementMethods for JSRef<'a, HTMLTitleElement> {
         for child in node.children() {
             let text: Option<JSRef<Text>> = TextCast::to_ref(child);
             match text {
-                Some(text) => content.push_str(text.characterdata.data.borrow().as_slice()),
+                Some(text) => content.push_str(text.characterdata().data().as_slice()),
                 None => (),
             }
         }
diff --git a/components/script/dom/htmltrackelement.rs b/components/script/dom/htmltrackelement.rs
index a1c5c428d74..f1ae254b365 100644
--- a/components/script/dom/htmltrackelement.rs
+++ b/components/script/dom/htmltrackelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLTrackElement {
-    pub htmlelement: HTMLElement,
+    htmlelement: HTMLElement,
 }
 
 impl HTMLTrackElementDerived for EventTarget {
     fn is_htmltrackelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLTrackElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLTrackElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlulistelement.rs b/components/script/dom/htmlulistelement.rs
index ffeb8affa11..bd417aef8ca 100644
--- a/components/script/dom/htmlulistelement.rs
+++ b/components/script/dom/htmlulistelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLUListElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLUListElementDerived for EventTarget {
     fn is_htmlulistelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLUListElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLUListElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlunknownelement.rs b/components/script/dom/htmlunknownelement.rs
index f39329c8e1f..1194346baa9 100644
--- a/components/script/dom/htmlunknownelement.rs
+++ b/components/script/dom/htmlunknownelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLUnknownElement {
-    pub htmlelement: HTMLElement
+    htmlelement: HTMLElement
 }
 
 impl HTMLUnknownElementDerived for EventTarget {
     fn is_htmlunknownelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLUnknownElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLUnknownElementTypeId))
     }
 }
 
diff --git a/components/script/dom/htmlvideoelement.rs b/components/script/dom/htmlvideoelement.rs
index ecbabaa906b..6e7080aca68 100644
--- a/components/script/dom/htmlvideoelement.rs
+++ b/components/script/dom/htmlvideoelement.rs
@@ -15,13 +15,14 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct HTMLVideoElement {
-    pub htmlmediaelement: HTMLMediaElement
+    htmlmediaelement: HTMLMediaElement
 }
 
 impl HTMLVideoElementDerived for EventTarget {
     fn is_htmlvideoelement(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ElementNodeTypeId(HTMLVideoElementTypeId))
+        *self.type_id() == NodeTargetTypeId(ElementNodeTypeId(HTMLVideoElementTypeId))
     }
 }
 
diff --git a/components/script/dom/location.rs b/components/script/dom/location.rs
index baa57fba1c6..c55da71ad68 100644
--- a/components/script/dom/location.rs
+++ b/components/script/dom/location.rs
@@ -17,6 +17,7 @@ use std::rc::Rc;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Location {
     reflector_: Reflector, //XXXjdm cycle: window->Location->window
     page: Rc<Page>,
diff --git a/components/script/dom/messageevent.rs b/components/script/dom/messageevent.rs
index 97b37dedddf..0f21a0b8096 100644
--- a/components/script/dom/messageevent.rs
+++ b/components/script/dom/messageevent.rs
@@ -20,6 +20,7 @@ use js::jsval::JSVal;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct MessageEvent {
     event: Event,
     data: JSVal,
@@ -29,7 +30,7 @@ pub struct MessageEvent {
 
 impl MessageEventDerived for Event {
     fn is_messageevent(&self) -> bool {
-        self.type_id == MessageEventTypeId
+        *self.type_id() == MessageEventTypeId
     }
 }
 
diff --git a/components/script/dom/mouseevent.rs b/components/script/dom/mouseevent.rs
index 9560af42f53..2ecfaa06ca5 100644
--- a/components/script/dom/mouseevent.rs
+++ b/components/script/dom/mouseevent.rs
@@ -21,23 +21,24 @@ use std::default::Default;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct MouseEvent {
-    pub mouseevent: UIEvent,
-    pub screen_x: Cell<i32>,
-    pub screen_y: Cell<i32>,
-    pub client_x: Cell<i32>,
-    pub client_y: Cell<i32>,
-    pub ctrl_key: Cell<bool>,
-    pub shift_key: Cell<bool>,
-    pub alt_key: Cell<bool>,
-    pub meta_key: Cell<bool>,
-    pub button: Cell<i16>,
-    pub related_target: MutNullableJS<EventTarget>
+    mouseevent: UIEvent,
+    screen_x: Cell<i32>,
+    screen_y: Cell<i32>,
+    client_x: Cell<i32>,
+    client_y: Cell<i32>,
+    ctrl_key: Cell<bool>,
+    shift_key: Cell<bool>,
+    alt_key: Cell<bool>,
+    meta_key: Cell<bool>,
+    button: Cell<i16>,
+    related_target: MutNullableJS<EventTarget>
 }
 
 impl MouseEventDerived for Event {
     fn is_mouseevent(&self) -> bool {
-        self.type_id == MouseEventTypeId
+        *self.type_id() == MouseEventTypeId
     }
 }
 
diff --git a/components/script/dom/namednodemap.rs b/components/script/dom/namednodemap.rs
index 3762ec2ad6b..c0304510c68 100644
--- a/components/script/dom/namednodemap.rs
+++ b/components/script/dom/namednodemap.rs
@@ -13,6 +13,7 @@ use dom::window::Window;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct NamedNodeMap {
     reflector_: Reflector,
     owner: JS<Element>,
@@ -34,11 +35,11 @@ impl NamedNodeMap {
 
 impl<'a> NamedNodeMapMethods for JSRef<'a, NamedNodeMap> {
     fn Length(self) -> u32 {
-        self.owner.root().attrs.borrow().len() as u32
+        self.owner.root().attrs().len() as u32
     }
 
     fn Item(self, index: u32) -> Option<Temporary<Attr>> {
-        self.owner.root().attrs.borrow().as_slice().get(index as uint).map(|x| Temporary::new(x.clone()))
+        self.owner.root().attrs().as_slice().get(index as uint).map(|x| Temporary::new(x.clone()))
     }
 
     fn IndexedGetter(self, index: u32, found: &mut bool) -> Option<Temporary<Attr>> {
diff --git a/components/script/dom/navigator.rs b/components/script/dom/navigator.rs
index 957abd558ec..beb03131bf8 100644
--- a/components/script/dom/navigator.rs
+++ b/components/script/dom/navigator.rs
@@ -13,8 +13,9 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Navigator {
-    pub reflector_: Reflector //XXXjdm cycle: window->navigator->window
+    reflector_: Reflector //XXXjdm cycle: window->navigator->window
 }
 
 impl Navigator {
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index 9ef523ba9e9..2716c56dc5c 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -73,9 +73,10 @@ use uuid;
 /// An HTML node.
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Node {
     /// The JavaScript reflector for this node.
-    pub eventtarget: EventTarget,
+    eventtarget: EventTarget,
 
     /// The type of node that this is.
     type_id: NodeTypeId,
@@ -108,14 +109,14 @@ pub struct Node {
     ///
     /// Must be sent back to the layout task to be destroyed when this
     /// node is finalized.
-    pub layout_data: LayoutDataRef,
+    layout_data: LayoutDataRef,
 
     unique_id: RefCell<String>,
 }
 
 impl NodeDerived for EventTarget {
     fn is_node(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             NodeTargetTypeId(_) => true,
             _ => false
         }
@@ -741,7 +742,7 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
     }
 
     fn is_in_html_doc(self) -> bool {
-        self.owner_doc().root().is_html_document
+        self.owner_doc().root().is_html_document()
     }
 
     fn children(self) -> AbstractNodeChildrenIterator<'a> {
@@ -1112,7 +1113,7 @@ impl Node {
              document:  JSRef<Document>,
              wrap_fn:   extern "Rust" fn(*mut JSContext, &GlobalRef, Box<N>) -> Temporary<N>)
              -> Temporary<N> {
-        let window = document.window.root();
+        let window = document.window().root();
         reflect_dom_object(node, &global::Window(*window), wrap_fn)
     }
 
@@ -1144,6 +1145,26 @@ impl Node {
         }
     }
 
+    #[inline]
+    pub fn eventtarget<'a>(&'a self) -> &'a EventTarget {
+        &self.eventtarget
+    }
+
+    #[inline]
+    pub fn layout_data(&self) -> Ref<Option<LayoutData>> {
+        self.layout_data.borrow()
+    }
+
+    #[inline]
+    pub fn layout_data_mut(&self) -> RefMut<Option<LayoutData>> {
+        self.layout_data.borrow_mut()
+    }
+
+    #[inline]
+    pub unsafe fn layout_data_unchecked(&self) -> *const Option<LayoutData> {
+        self.layout_data.borrow_unchecked()
+    }
+
     // http://dom.spec.whatwg.org/#concept-node-adopt
     pub fn adopt(node: JSRef<Node>, document: JSRef<Document>) {
         // Step 1.
@@ -1453,9 +1474,9 @@ impl Node {
         let copy: Root<Node> = match node.type_id() {
             DoctypeNodeTypeId => {
                 let doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(node).unwrap();
-                let doctype = DocumentType::new(doctype.name.clone(),
-                                                Some(doctype.public_id.clone()),
-                                                Some(doctype.system_id.clone()), *document);
+                let doctype = DocumentType::new(doctype.name().clone(),
+                                                Some(doctype.public_id().clone()),
+                                                Some(doctype.system_id().clone()), *document);
                 NodeCast::from_temporary(doctype)
             },
             DocumentFragmentNodeTypeId => {
@@ -1464,35 +1485,35 @@ impl Node {
             },
             CommentNodeTypeId => {
                 let comment: JSRef<Comment> = CommentCast::to_ref(node).unwrap();
-                let comment = Comment::new(comment.characterdata.data.borrow().clone(), *document);
+                let comment = Comment::new(comment.characterdata().data().clone(), *document);
                 NodeCast::from_temporary(comment)
             },
             DocumentNodeTypeId => {
                 let document: JSRef<Document> = DocumentCast::to_ref(node).unwrap();
-                let is_html_doc = match document.is_html_document {
+                let is_html_doc = match document.is_html_document() {
                     true => HTMLDocument,
                     false => NonHTMLDocument
                 };
-                let window = document.window.root();
+                let window = document.window().root();
                 let document = Document::new(*window, Some(document.url().clone()),
                                              is_html_doc, None);
                 NodeCast::from_temporary(document)
             },
             ElementNodeTypeId(..) => {
                 let element: JSRef<Element> = ElementCast::to_ref(node).unwrap();
-                let element = build_element_from_tag(element.local_name.as_slice().to_string(),
-                    element.namespace.clone(), Some(element.prefix.as_slice().to_string()), *document);
+                let element = build_element_from_tag(element.local_name().as_slice().to_string(),
+                    element.namespace().clone(), Some(element.prefix().as_slice().to_string()), *document);
                 NodeCast::from_temporary(element)
             },
             TextNodeTypeId => {
                 let text: JSRef<Text> = TextCast::to_ref(node).unwrap();
-                let text = Text::new(text.characterdata.data.borrow().clone(), *document);
+                let text = Text::new(text.characterdata().data().clone(), *document);
                 NodeCast::from_temporary(text)
             },
             ProcessingInstructionNodeTypeId => {
                 let pi: JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap();
-                let pi = ProcessingInstruction::new(pi.target.clone(),
-                                                    pi.characterdata.data.borrow().clone(), *document);
+                let pi = ProcessingInstruction::new(pi.target().clone(),
+                                                    pi.characterdata().data().clone(), *document);
                 NodeCast::from_temporary(pi)
             },
         }.root();
@@ -1511,7 +1532,7 @@ impl Node {
             DocumentNodeTypeId => {
                 let node_doc: JSRef<Document> = DocumentCast::to_ref(node).unwrap();
                 let copy_doc: JSRef<Document> = DocumentCast::to_ref(*copy).unwrap();
-                copy_doc.set_encoding_name(node_doc.encoding_name.borrow().clone());
+                copy_doc.set_encoding_name(node_doc.encoding_name().clone());
                 copy_doc.set_quirks_mode(node_doc.quirks_mode());
             },
             ElementNodeTypeId(..) => {
@@ -1519,13 +1540,13 @@ impl Node {
                 let copy_elem: JSRef<Element> = ElementCast::to_ref(*copy).unwrap();
 
                 // FIXME: https://github.com/mozilla/servo/issues/1737
-                let window = document.window.root();
-                for attr in node_elem.attrs.borrow().iter().map(|attr| attr.root()) {
-                    copy_elem.attrs.borrow_mut().push_unrooted(
+                let window = document.window().root();
+                for attr in node_elem.attrs().iter().map(|attr| attr.root()) {
+                    copy_elem.attrs_mut().push_unrooted(
                         &Attr::new(*window,
                                    attr.local_name().clone(), attr.value().clone(),
-                                   attr.name.clone(), attr.namespace.clone(),
-                                   attr.prefix.clone(), copy_elem));
+                                   attr.name().clone(), attr.namespace().clone(),
+                                   attr.prefix().clone(), copy_elem));
                 }
             },
             _ => ()
@@ -1569,7 +1590,7 @@ impl Node {
         for node in iterator {
             let text: Option<JSRef<Text>> = TextCast::to_ref(node);
             match text {
-                Some(text) => content.push_str(text.characterdata.data.borrow().as_slice()),
+                Some(text) => content.push_str(text.characterdata().data().as_slice()),
                 None => (),
             }
         }
@@ -1607,7 +1628,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
             CommentNodeTypeId => "#comment".to_string(),
             DoctypeNodeTypeId => {
                 let doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(self).unwrap();
-                doctype.name.clone()
+                doctype.name().clone()
             },
             DocumentFragmentNodeTypeId => "#document-fragment".to_string(),
             DocumentNodeTypeId => "#document".to_string()
@@ -1662,7 +1683,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
         }
 
         let doc = self.owner_doc().root();
-        let window = doc.window.root();
+        let window = doc.window().root();
         let child_list = NodeList::new_child_list(*window, self);
         self.child_list.assign(Some(child_list));
         self.child_list.get().unwrap()
@@ -1759,7 +1780,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
                 self.wait_until_safe_to_modify_dom();
 
                 let characterdata: JSRef<CharacterData> = CharacterDataCast::to_ref(self).unwrap();
-                *characterdata.data.borrow_mut() = value;
+                characterdata.set_data(value);
 
                 // Notify the document that the content of this node is different
                 let document = self.owner_doc().root();
@@ -1954,36 +1975,36 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
         fn is_equal_doctype(node: JSRef<Node>, other: JSRef<Node>) -> bool {
             let doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(node).unwrap();
             let other_doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(other).unwrap();
-            (doctype.name == other_doctype.name) &&
-            (doctype.public_id == other_doctype.public_id) &&
-            (doctype.system_id == other_doctype.system_id)
+            (*doctype.name() == *other_doctype.name()) &&
+            (*doctype.public_id() == *other_doctype.public_id()) &&
+            (*doctype.system_id() == *other_doctype.system_id())
         }
         fn is_equal_element(node: JSRef<Node>, other: JSRef<Node>) -> bool {
             let element: JSRef<Element> = ElementCast::to_ref(node).unwrap();
             let other_element: JSRef<Element> = ElementCast::to_ref(other).unwrap();
             // FIXME: namespace prefix
-            (element.namespace == other_element.namespace) &&
-            (element.local_name == other_element.local_name) &&
-            (element.attrs.borrow().len() == other_element.attrs.borrow().len())
+            (*element.namespace() == *other_element.namespace()) &&
+            (*element.local_name() == *other_element.local_name()) &&
+            (element.attrs().len() == other_element.attrs().len())
         }
         fn is_equal_processinginstruction(node: JSRef<Node>, other: JSRef<Node>) -> bool {
             let pi: JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap();
             let other_pi: JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(other).unwrap();
-            (pi.target == other_pi.target) &&
-            (*pi.characterdata.data.borrow() == *other_pi.characterdata.data.borrow())
+            (*pi.target() == *other_pi.target()) &&
+            (*pi.characterdata().data() == *other_pi.characterdata().data())
         }
         fn is_equal_characterdata(node: JSRef<Node>, other: JSRef<Node>) -> bool {
             let characterdata: JSRef<CharacterData> = CharacterDataCast::to_ref(node).unwrap();
             let other_characterdata: JSRef<CharacterData> = CharacterDataCast::to_ref(other).unwrap();
-            *characterdata.data.borrow() == *other_characterdata.data.borrow()
+            *characterdata.data() == *other_characterdata.data()
         }
         fn is_equal_element_attrs(node: JSRef<Node>, other: JSRef<Node>) -> bool {
             let element: JSRef<Element> = ElementCast::to_ref(node).unwrap();
             let other_element: JSRef<Element> = ElementCast::to_ref(other).unwrap();
-            assert!(element.attrs.borrow().len() == other_element.attrs.borrow().len());
-            element.attrs.borrow().iter().map(|attr| attr.root()).all(|attr| {
-                other_element.attrs.borrow().iter().map(|attr| attr.root()).any(|other_attr| {
-                    (attr.namespace == other_attr.namespace) &&
+            assert!(element.attrs().len() == other_element.attrs().len());
+            element.attrs().iter().map(|attr| attr.root()).all(|attr| {
+                other_element.attrs().iter().map(|attr| attr.root()).any(|other_attr| {
+                    (*attr.namespace() == *other_attr.namespace()) &&
                     (attr.local_name() == other_attr.local_name()) &&
                     (attr.value().as_slice() == other_attr.value().as_slice())
                 })
@@ -2120,7 +2141,7 @@ pub fn document_from_node<T: NodeBase+Reflectable>(derived: JSRef<T>) -> Tempora
 
 pub fn window_from_node<T: NodeBase+Reflectable>(derived: JSRef<T>) -> Temporary<Window> {
     let document = document_from_node(derived).root();
-    Temporary::new(document.window.clone())
+    Temporary::new(document.window().clone())
 }
 
 impl<'a> VirtualMethods for JSRef<'a, Node> {
diff --git a/components/script/dom/nodeiterator.rs b/components/script/dom/nodeiterator.rs
index 2e4fe3f442b..27656da9433 100644
--- a/components/script/dom/nodeiterator.rs
+++ b/components/script/dom/nodeiterator.rs
@@ -10,8 +10,9 @@ use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct NodeIterator {
-    pub reflector_: Reflector
+    reflector_: Reflector
 }
 
 impl NodeIterator {
diff --git a/components/script/dom/nodelist.rs b/components/script/dom/nodelist.rs
index 598ebfa932b..f2da3a0c4ba 100644
--- a/components/script/dom/nodelist.rs
+++ b/components/script/dom/nodelist.rs
@@ -19,6 +19,7 @@ pub enum NodeListType {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct NodeList {
     list_type: NodeListType,
     reflector_: Reflector,
diff --git a/components/script/dom/performance.rs b/components/script/dom/performance.rs
index f1c5896b2a7..ae6fb7061cc 100644
--- a/components/script/dom/performance.rs
+++ b/components/script/dom/performance.rs
@@ -15,6 +15,7 @@ pub type DOMHighResTimeStamp = f64;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Performance {
     reflector_: Reflector,
     timing: JS<PerformanceTiming>,
diff --git a/components/script/dom/performancetiming.rs b/components/script/dom/performancetiming.rs
index 955187f3dfb..0c8b6a60008 100644
--- a/components/script/dom/performancetiming.rs
+++ b/components/script/dom/performancetiming.rs
@@ -11,6 +11,7 @@ use dom::window::Window;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct PerformanceTiming {
     reflector_: Reflector,
     navigationStart: u64,
@@ -29,8 +30,8 @@ impl PerformanceTiming {
 
     #[allow(unrooted_must_root)]
     pub fn new(window: JSRef<Window>) -> Temporary<PerformanceTiming> {
-        let timing = PerformanceTiming::new_inherited(window.navigationStart,
-                                                      window.navigationStartPrecise);
+        let timing = PerformanceTiming::new_inherited(window.navigation_start(),
+                                                      window.navigation_start_precise());
         reflect_dom_object(box timing, &global::Window(window),
                            PerformanceTimingBinding::Wrap)
     }
diff --git a/components/script/dom/processinginstruction.rs b/components/script/dom/processinginstruction.rs
index dc6631ad34e..19017ae9050 100644
--- a/components/script/dom/processinginstruction.rs
+++ b/components/script/dom/processinginstruction.rs
@@ -16,14 +16,15 @@ use servo_util::str::DOMString;
 /// An HTML processing instruction node.
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct ProcessingInstruction {
-    pub characterdata: CharacterData,
-    pub target: DOMString,
+    characterdata: CharacterData,
+    target: DOMString,
 }
 
 impl ProcessingInstructionDerived for EventTarget {
     fn is_processinginstruction(&self) -> bool {
-        self.type_id == NodeTargetTypeId(ProcessingInstructionNodeTypeId)
+        *self.type_id() == NodeTargetTypeId(ProcessingInstructionNodeTypeId)
     }
 }
 
@@ -39,6 +40,14 @@ impl ProcessingInstruction {
         Node::reflect_node(box ProcessingInstruction::new_inherited(target, data, document),
                            document, ProcessingInstructionBinding::Wrap)
     }
+
+    pub fn characterdata<'a>(&'a self) -> &'a CharacterData {
+        &self.characterdata
+    }
+
+    pub fn target<'a>(&'a self) -> &'a DOMString {
+        &self.target
+    }
 }
 
 impl<'a> ProcessingInstructionMethods for JSRef<'a, ProcessingInstruction> {
diff --git a/components/script/dom/progressevent.rs b/components/script/dom/progressevent.rs
index 2869a035b25..52d1f6f35ff 100644
--- a/components/script/dom/progressevent.rs
+++ b/components/script/dom/progressevent.rs
@@ -15,6 +15,7 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct ProgressEvent {
     event: Event,
     length_computable: bool,
@@ -24,7 +25,7 @@ pub struct ProgressEvent {
 
 impl ProgressEventDerived for Event {
     fn is_progressevent(&self) -> bool {
-        self.type_id == ProgressEventTypeId
+        *self.type_id() == ProgressEventTypeId
     }
 }
 
diff --git a/components/script/dom/range.rs b/components/script/dom/range.rs
index 56197342d0b..a611604e6bb 100644
--- a/components/script/dom/range.rs
+++ b/components/script/dom/range.rs
@@ -13,6 +13,7 @@ use dom::document::Document;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Range {
     reflector_: Reflector
 }
@@ -25,7 +26,7 @@ impl Range {
     }
 
     pub fn new(document: JSRef<Document>) -> Temporary<Range> {
-        let window = document.window.root();
+        let window = document.window().root();
         reflect_dom_object(box Range::new_inherited(),
                            &Window(*window),
                            RangeBinding::Wrap)
diff --git a/components/script/dom/screen.rs b/components/script/dom/screen.rs
index 7fafbd4bc6a..ad4250ee1c6 100644
--- a/components/script/dom/screen.rs
+++ b/components/script/dom/screen.rs
@@ -11,6 +11,7 @@ use dom::window::Window;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Screen {
     reflector_: Reflector,
 }
diff --git a/components/script/dom/testbinding.rs b/components/script/dom/testbinding.rs
index 4937dfbd9a8..a409c70d1bf 100644
--- a/components/script/dom/testbinding.rs
+++ b/components/script/dom/testbinding.rs
@@ -20,6 +20,7 @@ use js::jsval::{JSVal, NullValue};
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct TestBinding {
     reflector: Reflector,
     global: GlobalField,
diff --git a/components/script/dom/text.rs b/components/script/dom/text.rs
index b073f8ec298..b8fea7c23cb 100644
--- a/components/script/dom/text.rs
+++ b/components/script/dom/text.rs
@@ -18,13 +18,14 @@ use servo_util::str::DOMString;
 /// An HTML text node.
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Text {
-    pub characterdata: CharacterData,
+    characterdata: CharacterData,
 }
 
 impl TextDerived for EventTarget {
     fn is_text(&self) -> bool {
-        self.type_id == NodeTargetTypeId(TextNodeTypeId)
+        *self.type_id() == NodeTargetTypeId(TextNodeTypeId)
     }
 }
 
@@ -44,6 +45,11 @@ impl Text {
         let document = global.as_window().Document().root();
         Ok(Text::new(text, *document))
     }
+
+    #[inline]
+    pub fn characterdata<'a>(&'a self) -> &'a CharacterData {
+        &self.characterdata
+    }
 }
 
 impl Reflectable for Text {
diff --git a/components/script/dom/treewalker.rs b/components/script/dom/treewalker.rs
index 7bdb4403b1a..f9100dd15be 100644
--- a/components/script/dom/treewalker.rs
+++ b/components/script/dom/treewalker.rs
@@ -23,12 +23,13 @@ use std::cell::Cell;
 // http://dom.spec.whatwg.org/#interface-treewalker
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct TreeWalker {
-    pub reflector_: Reflector,
-    pub root_node: JS<Node>,
-    pub current_node: Cell<JS<Node>>,
-    pub what_to_show: u32,
-    pub filter: Filter
+    reflector_: Reflector,
+    root_node: JS<Node>,
+    current_node: Cell<JS<Node>>,
+    what_to_show: u32,
+    filter: Filter
 }
 
 impl TreeWalker {
@@ -48,7 +49,7 @@ impl TreeWalker {
                            root_node: JSRef<Node>,
                            what_to_show: u32,
                            filter: Filter) -> Temporary<TreeWalker> {
-        let window = document.window.root();
+        let window = document.window().root();
         reflect_dom_object(box TreeWalker::new_inherited(root_node, what_to_show, filter),
                            &Window(*window),
                            TreeWalkerBinding::Wrap)
diff --git a/components/script/dom/uievent.rs b/components/script/dom/uievent.rs
index 18fe2dc3585..d5dd2cfc4df 100644
--- a/components/script/dom/uievent.rs
+++ b/components/script/dom/uievent.rs
@@ -21,15 +21,16 @@ use std::default::Default;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct UIEvent {
-    pub event: Event,
+    event: Event,
     view: MutNullableJS<Window>,
     detail: Cell<i32>
 }
 
 impl UIEventDerived for Event {
     fn is_uievent(&self) -> bool {
-        self.type_id == UIEventTypeId
+        *self.type_id() == UIEventTypeId
     }
 }
 
@@ -67,6 +68,11 @@ impl UIEvent {
                                  init.view.root_ref(), init.detail);
         Ok(event)
     }
+
+    #[inline]
+    pub fn event<'a>(&'a self) -> &'a Event {
+        &self.event
+    }
 }
 
 impl<'a> UIEventMethods for JSRef<'a, UIEvent> {
diff --git a/components/script/dom/urlsearchparams.rs b/components/script/dom/urlsearchparams.rs
index be95361fdbb..8174fafcc98 100644
--- a/components/script/dom/urlsearchparams.rs
+++ b/components/script/dom/urlsearchparams.rs
@@ -22,6 +22,7 @@ use std::ascii::OwnedStrAsciiExt;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct URLSearchParams {
     data: RefCell<HashMap<DOMString, Vec<DOMString>>>,
     reflector_: Reflector,
diff --git a/components/script/dom/validitystate.rs b/components/script/dom/validitystate.rs
index 99bd9258416..ef76ac433e1 100644
--- a/components/script/dom/validitystate.rs
+++ b/components/script/dom/validitystate.rs
@@ -10,6 +10,7 @@ use dom::window::Window;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct ValidityState {
     reflector_: Reflector,
     state: u8,
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index f3edfc04943..9a7eeef11c0 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -40,7 +40,7 @@ use url::{Url, UrlParser};
 use libc;
 use serialize::base64::{FromBase64, ToBase64, STANDARD};
 use std::collections::hashmap::HashMap;
-use std::cell::{Cell, RefCell};
+use std::cell::{Cell, Ref, RefCell};
 use std::cmp;
 use std::comm::{channel, Sender};
 use std::comm::Select;
@@ -57,9 +57,10 @@ use time;
 pub struct TimerId(i32);
 
 #[jstraceable]
+#[privatize]
 pub struct TimerHandle {
     handle: TimerId,
-    pub data: TimerData,
+    data: TimerData,
     cancel_chan: Option<Sender<()>>,
 }
 
@@ -78,22 +79,23 @@ impl TimerHandle {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Window {
     eventtarget: EventTarget,
-    pub script_chan: ScriptChan,
-    pub control_chan: ScriptControlChan,
+    script_chan: ScriptChan,
+    control_chan: ScriptControlChan,
     console: MutNullableJS<Console>,
     location: MutNullableJS<Location>,
     navigator: MutNullableJS<Navigator>,
-    pub image_cache_task: ImageCacheTask,
-    pub active_timers: RefCell<HashMap<TimerId, TimerHandle>>,
+    image_cache_task: ImageCacheTask,
+    active_timers: RefCell<HashMap<TimerId, TimerHandle>>,
     next_timer_handle: Cell<i32>,
-    pub compositor: Box<ScriptListener+'static>,
-    pub browser_context: RefCell<Option<BrowserContext>>,
-    pub page: Rc<Page>,
+    compositor: Box<ScriptListener+'static>,
+    browser_context: RefCell<Option<BrowserContext>>,
+    page: Rc<Page>,
     performance: MutNullableJS<Performance>,
-    pub navigationStart: u64,
-    pub navigationStartPrecise: f64,
+    navigation_start: u64,
+    navigation_start_precise: f64,
     screen: MutNullableJS<Screen>,
 }
 
@@ -103,9 +105,38 @@ impl Window {
         (*js_info.as_ref().unwrap().js_context).ptr
     }
 
+    pub fn script_chan<'a>(&'a self) -> &'a ScriptChan {
+        &self.script_chan
+    }
+
+    pub fn control_chan<'a>(&'a self) -> &'a ScriptControlChan {
+        &self.control_chan
+    }
+
+    pub fn image_cache_task<'a>(&'a self) -> &'a ImageCacheTask {
+        &self.image_cache_task
+    }
+
+    pub fn compositor<'a>(&'a self) -> &'a ScriptListener+'static {
+        &*self.compositor
+    }
+
+    pub fn browser_context(&self) -> Ref<Option<BrowserContext>> {
+        self.browser_context.borrow()
+    }
+
     pub fn page<'a>(&'a self) -> &'a Page {
         &*self.page
     }
+
+    pub fn navigation_start(&self) -> u64 {
+        self.navigation_start
+    }
+
+    pub fn navigation_start_precise(&self) -> f64 {
+        self.navigation_start_precise
+    }
+
     pub fn get_url(&self) -> Url {
         self.page().get_url()
     }
@@ -124,9 +155,10 @@ impl Drop for Window {
 // (ie. function value to invoke and all arguments to pass
 //      to the function when calling it)
 #[jstraceable]
+#[privatize]
 pub struct TimerData {
-    pub is_interval: bool,
-    pub funval: JSVal,
+    is_interval: bool,
+    funval: JSVal,
 }
 
 // http://www.whatwg.org/html/#atob
@@ -543,8 +575,8 @@ impl Window {
             next_timer_handle: Cell::new(0),
             browser_context: RefCell::new(None),
             performance: Default::default(),
-            navigationStart: time::get_time().sec as u64,
-            navigationStartPrecise: time::precise_time_s(),
+            navigation_start: time::get_time().sec as u64,
+            navigation_start_precise: time::precise_time_s(),
             screen: Default::default(),
         };
 
diff --git a/components/script/dom/worker.rs b/components/script/dom/worker.rs
index 4941a1c6a35..f7feec1929f 100644
--- a/components/script/dom/worker.rs
+++ b/components/script/dom/worker.rs
@@ -33,6 +33,7 @@ untraceable!(TrustedWorkerAddress)
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Worker {
     eventtarget: EventTarget,
     refcount: Cell<uint>,
diff --git a/components/script/dom/workerglobalscope.rs b/components/script/dom/workerglobalscope.rs
index 355fb3f2cc3..a545cf05fbe 100644
--- a/components/script/dom/workerglobalscope.rs
+++ b/components/script/dom/workerglobalscope.rs
@@ -32,8 +32,9 @@ pub enum WorkerGlobalScopeId {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct WorkerGlobalScope {
-    pub eventtarget: EventTarget,
+    eventtarget: EventTarget,
     worker_url: Url,
     js_context: Rc<Cx>,
     resource_task: ResourceTask,
@@ -61,6 +62,11 @@ impl WorkerGlobalScope {
         }
     }
 
+    #[inline]
+    pub fn eventtarget<'a>(&'a self) -> &'a EventTarget {
+        &self.eventtarget
+    }
+
     pub fn get_cx(&self) -> *mut JSContext {
         self.js_context.ptr
     }
diff --git a/components/script/dom/workerlocation.rs b/components/script/dom/workerlocation.rs
index 1eaa40829da..145ba8c8f93 100644
--- a/components/script/dom/workerlocation.rs
+++ b/components/script/dom/workerlocation.rs
@@ -16,6 +16,7 @@ use url::Url;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct WorkerLocation {
     reflector_: Reflector,
     url: Url,
diff --git a/components/script/dom/workernavigator.rs b/components/script/dom/workernavigator.rs
index 2d3c496048c..6cc02c0e3fa 100644
--- a/components/script/dom/workernavigator.rs
+++ b/components/script/dom/workernavigator.rs
@@ -13,6 +13,7 @@ use servo_util::str::DOMString;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct WorkerNavigator {
     reflector_: Reflector,
 }
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index ac1d283cc56..1e96b701d1e 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -104,6 +104,7 @@ enum SyncOrAsync<'a> {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct XMLHttpRequest {
     eventtarget: XMLHttpRequestEventTarget,
     ready_state: Cell<XMLHttpRequestState>,
@@ -679,7 +680,7 @@ impl Reflectable for XMLHttpRequest {
 
 impl XMLHttpRequestDerived for EventTarget {
     fn is_xmlhttprequest(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             XMLHttpRequestTargetTypeId(XMLHttpRequestTypeId) => true,
             _ => false
         }
diff --git a/components/script/dom/xmlhttprequesteventtarget.rs b/components/script/dom/xmlhttprequesteventtarget.rs
index 9345c676a89..0b9c9e7a75f 100644
--- a/components/script/dom/xmlhttprequesteventtarget.rs
+++ b/components/script/dom/xmlhttprequesteventtarget.rs
@@ -13,8 +13,9 @@ use dom::xmlhttprequest::XMLHttpRequestId;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct XMLHttpRequestEventTarget {
-    pub eventtarget: EventTarget,
+    eventtarget: EventTarget,
 }
 
 impl XMLHttpRequestEventTarget {
@@ -23,10 +24,15 @@ impl XMLHttpRequestEventTarget {
             eventtarget: EventTarget::new_inherited(XMLHttpRequestTargetTypeId(type_id))
         }
     }
+
+    #[inline]
+    pub fn eventtarget<'a>(&'a self) -> &'a EventTarget {
+        &self.eventtarget
+    }
 }
 impl XMLHttpRequestEventTargetDerived for EventTarget {
     fn is_xmlhttprequesteventtarget(&self) -> bool {
-        match self.type_id {
+        match *self.type_id() {
             XMLHttpRequestTargetTypeId(_) => true,
             _ => false
         }
diff --git a/components/script/dom/xmlhttprequestupload.rs b/components/script/dom/xmlhttprequestupload.rs
index 2059a69126d..7e11df328a8 100644
--- a/components/script/dom/xmlhttprequestupload.rs
+++ b/components/script/dom/xmlhttprequestupload.rs
@@ -13,6 +13,7 @@ use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct XMLHttpRequestUpload {
     eventtarget: XMLHttpRequestEventTarget
 }
@@ -37,6 +38,6 @@ impl Reflectable for XMLHttpRequestUpload {
 
 impl XMLHttpRequestUploadDerived for EventTarget {
     fn is_xmlhttprequestupload(&self) -> bool {
-        self.type_id == XMLHttpRequestTargetTypeId(XMLHttpRequestUploadTypeId)
+        *self.type_id() == XMLHttpRequestTargetTypeId(XMLHttpRequestUploadTypeId)
     }
 }
diff --git a/components/script/html/hubbub_html_parser.rs b/components/script/html/hubbub_html_parser.rs
index 4b943a4409a..27f37984517 100644
--- a/components/script/html/hubbub_html_parser.rs
+++ b/components/script/html/hubbub_html_parser.rs
@@ -503,7 +503,7 @@ pub fn parse_html(page: &Page,
                         for child in scriptnode.children() {
                             debug!("child = {:?}", child);
                             let text: JSRef<Text> = TextCast::to_ref(child).unwrap();
-                            data.push_str(text.characterdata.data.borrow().as_slice());
+                            data.push_str(text.characterdata().data().as_slice());
                         }
 
                         debug!("script data = {:?}", data);
diff --git a/components/script/page.rs b/components/script/page.rs
index f8a2248d447..90f07955bfb 100644
--- a/components/script/page.rs
+++ b/components/script/page.rs
@@ -167,7 +167,7 @@ impl Page {
         if self.damaged.get() {
             let frame = self.frame();
             let window = frame.as_ref().unwrap().window.root();
-            self.reflow(goal, window.control_chan.clone(), &*window.compositor);
+            self.reflow(goal, window.control_chan().clone(), window.compositor());
         } else {
             self.avoided_reflows.set(self.avoided_reflows.get() + 1);
         }