auto merge of #1028 : bholley/servo/reflector_rename, r=jdm

There are still a few instances of "wrapper"-ish names scattered throughout the code, but this is a good start.

src/components/script/dom/bindings/codegen/CodegenRust.py

@@ -1533,7 +1533,7 @@ for (uint32_t i = 0; i < length; ++i) {
             if descriptor.pointerType == '':
                 wrap = "%s.wrap(cx, ${obj}, ${jsvalPtr} as *mut JSVal)" % result
             else:
-                wrap = "%s(cx, ${obj}, %s as @mut CacheableWrapper, ${jsvalPtr} as *mut JSVal)" % (wrapMethod, result)
+                wrap = "%s(cx, ${obj}, %s as @mut Reflectable, ${jsvalPtr} as *mut JSVal)" % (wrapMethod, result)
             # We don't support prefable stuff in workers.
             assert(not descriptor.prefable or not descriptor.workers)
             if not descriptor.prefable:
@@ -1555,7 +1555,7 @@ for (uint32_t i = 0; i < length; ++i) {
             if descriptor.pointerType == '':
                 wrap = "(%s.wrap(cx, ${obj}, ${jsvalPtr}) != 0)" % result
             else:
-                wrap = "if WrapNewBindingObject(cx, ${obj}, %s as @mut CacheableWrapper, ${jsvalPtr}) { 1 } else { 0 };" % result
+                wrap = "if WrapNewBindingObject(cx, ${obj}, %s as @mut Reflectable, ${jsvalPtr}) { 1 } else { 0 };" % result
             wrappingCode += wrapAndSetPtr(wrap)
         return (wrappingCode, False)
 
@@ -2464,7 +2464,7 @@ class CGAbstractMethod(CGThing):
 
 def CreateBindingJSObject(descriptor, parent=None):
     if descriptor.proxy:
-        handler = """  //let cache = ptr::to_unsafe_ptr(aObject.get_wrappercache());
+        handler = """  //let reflector = ptr::to_unsafe_ptr(aObject.reflector());
 
   let page = page_from_context(aCx);
   let handler = (*page).js_info.get_ref().dom_static.proxy_handlers.get(&(PrototypeList::id::%s as uint));
@@ -2520,20 +2520,20 @@ class CGWrapWithCacheMethod(CGAbstractMethod):
     return ptr::null();
   }
 
-  let cache = ptr::to_mut_unsafe_ptr(aObject.get_wrappercache());
+  let reflector = ptr::to_mut_unsafe_ptr(aObject.reflector());
 %s
 
   //NS_ADDREF(aObject);
 
-  (*cache).set_wrapper(obj);
+  (*reflector).set_jsobject(obj);
 
   return obj;""" % (CreateBindingJSObject(self.descriptor, "parent"))
         else:
-            return """    let cache = ptr::to_mut_unsafe_ptr(aObject.get_wrappercache());
+            return """    let reflector = ptr::to_mut_unsafe_ptr(aObject.reflector());
 %s
   let proto = GetProtoObject(aCx, obj, obj);
   JS_SetPrototype(aCx, obj, proto);
-  (*cache).set_wrapper(obj);
+  (*reflector).set_jsobject(obj);
   return obj;""" % CreateBindingJSObject(self.descriptor)
 
 class CGWrapMethod(CGAbstractMethod):
@@ -4077,7 +4077,7 @@ class CGClassConstructHook(CGAbstractExternMethod):
   //       from the context for now. 
   let page = page_from_context(cx);
   let global = (*page).frame.get_ref().window;
-  let obj = global.get_wrappercache().get_wrapper();
+  let obj = global.reflector().get_jsobject();
 """
             preArgs = ["global"]
 

src/components/script/dom/bindings/domparser.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::DOMParserBinding;
-use dom::bindings::utils::{CacheableWrapper, WrapperCache};
+use dom::bindings::utils::{Reflectable, Reflector};
 use dom::bindings::utils::{BindingObject, DerivedWrapper};
 use dom::domparser::DOMParser;
 
@@ -12,9 +12,9 @@ use js::glue::{RUST_OBJECT_TO_JSVAL};
 
 use std::cast;
 
-impl CacheableWrapper for DOMParser {
+impl Reflectable for DOMParser {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        unsafe { cast::transmute(&self.wrapper) }
+        unsafe { cast::transmute(&self.reflector_) }
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -24,8 +24,8 @@ impl CacheableWrapper for DOMParser {
 }
 
 impl BindingObject for DOMParser {
-    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut Reflectable> {
-        Some(self.owner as @mut CacheableWrapper)
+        Some(self.owner as @mut Reflectable)
     }
 }
 

src/components/script/dom/bindings/element.rs

@@ -4,16 +4,16 @@
 
 use dom::types::*;
 use dom::bindings::codegen::*;
-use dom::bindings::utils::{BindingObject, WrapperCache, CacheableWrapper, Traceable};
+use dom::bindings::utils::{BindingObject, Reflector, Reflectable, Traceable};
 use dom::node::ScriptView;
 
 use js::jsapi::{JSContext, JSObject, JSTracer};
 
 macro_rules! generate_cacheable_wrapper(
     ($name: path, $wrap: path) => (
-        impl CacheableWrapper for $name {
+        impl Reflectable for $name {
-            fn get_wrappercache(&mut self) -> &mut WrapperCache {
+            fn reflector(&mut self) -> &mut Reflector {
-                self.element.get_wrappercache()
+                self.element.reflector()
             }
 
             fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -26,9 +26,9 @@ macro_rules! generate_cacheable_wrapper(
 
 macro_rules! generate_cacheable_wrapper_htmlelement(
     ($name: path, $wrap: path) => (
-        impl CacheableWrapper for $name {
+        impl Reflectable for $name {
-            fn get_wrappercache(&mut self) -> &mut WrapperCache {
+            fn reflector(&mut self) -> &mut Reflector {
-                self.htmlelement.get_wrappercache()
+                self.htmlelement.reflector()
             }
 
             fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -41,9 +41,9 @@ macro_rules! generate_cacheable_wrapper_htmlelement(
 
 macro_rules! generate_cacheable_wrapper_node(
     ($name: path, $wrap: path) => (
-        impl CacheableWrapper for $name {
+        impl Reflectable for $name {
-            fn get_wrappercache(&mut self) -> &mut WrapperCache {
+            fn reflector(&mut self) -> &mut Reflector {
-                self.node.get_wrappercache()
+                self.node.reflector()
             }
 
             fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -57,7 +57,7 @@ macro_rules! generate_cacheable_wrapper_node(
 macro_rules! generate_binding_object(
     ($name: path) => (
         impl BindingObject for $name {
-            fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+            fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
                 self.element.GetParentObject(cx)
             }
         }
@@ -67,7 +67,7 @@ macro_rules! generate_binding_object(
 macro_rules! generate_binding_object_htmlelement(
     ($name: path) => (
         impl BindingObject for $name {
-            fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+            fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
                 self.htmlelement.GetParentObject(cx)
             }
         }
@@ -77,7 +77,7 @@ macro_rules! generate_binding_object_htmlelement(
 macro_rules! generate_binding_object_node(
     ($name: path) => (
         impl BindingObject for $name {
-            fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+            fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
                 self.node.GetParentObject(cx)
             }
         }

src/components/script/dom/bindings/node.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{CacheableWrapper, WrapperCache, Traceable};
+use dom::bindings::utils::{Reflectable, Reflector, Traceable};
 use dom::element::*;
 use dom::types::*;
 use dom::node::{AbstractNode, ElementNodeTypeId, TextNodeTypeId, CommentNodeTypeId};
@@ -95,11 +95,11 @@ pub fn create(cx: *JSContext, node: &mut AbstractNode<ScriptView>) -> *JSObject
      }
 }
 
-impl CacheableWrapper for AbstractNode<ScriptView> {
+impl Reflectable for AbstractNode<ScriptView> {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
         do self.with_mut_base |base| {
             unsafe {
-                cast::transmute(&base.wrapper)
+                cast::transmute(&base.reflector_)
             }
         }
     }
@@ -118,19 +118,18 @@ impl Traceable for Node<ScriptView> {
             }
             debug!("tracing %s", name);
             let mut node = node.unwrap();
-            let cache = node.get_wrappercache();
+            let obj = node.reflector().get_jsobject();
-            let wrapper = cache.get_wrapper();
+            assert!(obj.is_not_null());
-            assert!(wrapper.is_not_null());
             unsafe {
                 (*tracer).debugPrinter = ptr::null();
                 (*tracer).debugPrintIndex = -1;
                 do name.to_c_str().with_ref |name| {
                     (*tracer).debugPrintArg = name as *libc::c_void;
-                    JS_CallTracer(cast::transmute(tracer), wrapper, JSTRACE_OBJECT as u32);
+                    JS_CallTracer(cast::transmute(tracer), obj, JSTRACE_OBJECT as u32);
                 }
             }
         }
-        debug!("tracing %p?:", self.wrapper.get_wrapper());
+        debug!("tracing %p?:", self.reflector_.get_jsobject());
         trace_node(tracer, self.parent_node, "parent");
         trace_node(tracer, self.first_child, "first child");
         trace_node(tracer, self.last_child, "last child");

src/components/script/dom/bindings/utils.rs

@@ -527,42 +527,42 @@ pub fn initialize_global(global: *JSObject) {
     }
 }
 
-pub trait CacheableWrapper {
+pub trait Reflectable {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache;
+    fn reflector(&mut self) -> &mut Reflector;
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject;
 }
 
-pub struct WrapperCache {
+pub struct Reflector {
-    wrapper: *JSObject
+    object: *JSObject
 }
 
-impl WrapperCache {
+impl Reflector {
-    pub fn get_wrapper(&self) -> *JSObject {
+    pub fn get_jsobject(&self) -> *JSObject {
-        unsafe { cast::transmute(self.wrapper) }
+        unsafe { cast::transmute(self.object) }
     }
 
-    pub fn set_wrapper(&mut self, wrapper: *JSObject) {
+    pub fn set_jsobject(&mut self, object: *JSObject) {
-        self.wrapper = wrapper;
+        self.object = object;
     }
 
     pub fn get_rootable(&self) -> **JSObject {
-        return to_unsafe_ptr(&self.wrapper);
+        return to_unsafe_ptr(&self.object);
     }
 
-    pub fn new() -> WrapperCache {
+    pub fn new() -> Reflector {
-        WrapperCache {
+        Reflector {
-            wrapper: ptr::null()
+            object: ptr::null()
         }
     }
 }
 
 #[fixed_stack_segment]
 pub fn WrapNewBindingObject(cx: *JSContext, scope: *JSObject,
-                            value: @mut CacheableWrapper,
+                            value: @mut Reflectable,
                             vp: *mut JSVal) -> JSBool {
   unsafe {
-    let cache = value.get_wrappercache();
+    let reflector = value.reflector();
-    let obj = cache.get_wrapper();
+    let obj = reflector.get_jsobject();
     if obj.is_not_null() /*&& js::GetObjectCompartment(obj) == js::GetObjectCompartment(scope)*/ {
         *vp = RUST_OBJECT_TO_JSVAL(obj);
         return 1; // JS_TRUE
@@ -574,31 +574,30 @@ pub fn WrapNewBindingObject(cx: *JSContext, scope: *JSObject,
     }
 
     //  MOZ_ASSERT(js::IsObjectInContextCompartment(scope, cx));
-      cache.set_wrapper(obj);
+    reflector.set_jsobject(obj);
     *vp = RUST_OBJECT_TO_JSVAL(obj);
     return JS_WrapValue(cx, cast::transmute(vp));
   }
 }
 
 #[fixed_stack_segment]
-pub fn WrapNativeParent(cx: *JSContext, scope: *JSObject, mut p: Option<@mut CacheableWrapper>) -> *JSObject {
+pub fn WrapNativeParent(cx: *JSContext, scope: *JSObject, mut p: Option<@mut Reflectable>) -> *JSObject {
     match p {
         Some(ref mut p) => {
-            let cache = p.get_wrappercache();
+            let obj = p.reflector().get_jsobject();
-            let wrapper = cache.get_wrapper();
+            if obj.is_not_null() {
-            if wrapper.is_not_null() {
+                return obj;
-                return wrapper;
             }
-            let wrapper = p.wrap_object_shared(cx, scope);
+            let obj = p.wrap_object_shared(cx, scope);
-            cache.set_wrapper(wrapper);
+            p.reflector().set_jsobject(obj);
-            wrapper
+            obj
         }
         None => unsafe { JS_GetGlobalObject(cx) }
     }
 }
 
 pub trait BindingObject {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper>;
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable>;
 }
 
 #[fixed_stack_segment]
@@ -734,8 +733,8 @@ pub trait DerivedWrapper {
 impl DerivedWrapper for AbstractNode<ScriptView> {
     #[fixed_stack_segment]
     fn wrap(&mut self, cx: *JSContext, _scope: *JSObject, vp: *mut JSVal) -> i32 {
-        let cache = self.get_wrappercache();
+        let cache = self.reflector();
-        let wrapper = cache.get_wrapper();
+        let wrapper = cache.get_jsobject();
         if wrapper.is_not_null() {
             unsafe { *vp = RUST_OBJECT_TO_JSVAL(wrapper) };
             return 1;

src/components/script/dom/blob.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{WrapperCache, BindingObject, CacheableWrapper};
+use dom::bindings::utils::{Reflector, BindingObject, Reflectable};
 use dom::bindings::codegen::BlobBinding;
 use script_task::{page_from_context};
 
@@ -11,20 +11,20 @@ use js::jsapi::{JSContext, JSObject};
 use std::cast;
 
 pub struct Blob {
-    wrapper: WrapperCache
+    reflector_: Reflector
 }
 
 impl Blob {
     pub fn new() -> @mut Blob {
         @mut Blob {
-            wrapper: WrapperCache::new()
+            reflector_: Reflector::new()
         }
     }
 }
 
-impl CacheableWrapper for Blob {
+impl Reflectable for Blob {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        unsafe { cast::transmute(&self.wrapper) }
+        unsafe { cast::transmute(&self.reflector_) }
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -34,10 +34,10 @@ impl CacheableWrapper for Blob {
 }
 
 impl BindingObject for Blob {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }

src/components/script/dom/characterdata.rs

@@ -5,7 +5,7 @@
 //! DOM bindings for `CharacterData`.
 
 use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
-use dom::bindings::utils::{BindingObject, CacheableWrapper, WrapperCache};
+use dom::bindings::utils::{BindingObject, Reflectable, Reflector};
 use dom::node::{Node, NodeTypeId, ScriptView};
 use js::jsapi::{JSObject, JSContext};
 
@@ -57,9 +57,9 @@ impl CharacterData {
     }
 }
 
-impl CacheableWrapper for CharacterData {
+impl Reflectable for CharacterData {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        self.node.get_wrappercache()
+        self.node.reflector()
     }
 
     fn wrap_object_shared(@mut self, _cx: *JSContext, _scope: *JSObject) -> *JSObject {
@@ -68,7 +68,7 @@ impl CacheableWrapper for CharacterData {
 }
 
 impl BindingObject for CharacterData {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         self.node.GetParentObject(cx)
     }
 }

src/components/script/dom/clientrect.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{CacheableWrapper, WrapperCache, BindingObject, DerivedWrapper};
+use dom::bindings::utils::{Reflectable, Reflector, BindingObject, DerivedWrapper};
 use dom::bindings::codegen::ClientRectBinding;
 use script_task::page_from_context;
 
@@ -12,7 +12,7 @@ use js::glue::RUST_OBJECT_TO_JSVAL;
 use std::cast;
 
 pub struct ClientRect {
-    wrapper: WrapperCache,
+    reflector_: Reflector,
     top: f32,
     bottom: f32,
     left: f32,
@@ -26,7 +26,7 @@ impl ClientRect {
             bottom: bottom,
             left: left,
             right: right,
-            wrapper: WrapperCache::new()
+            reflector_: Reflector::new()
         };
         rect.init_wrapper(cx, scope);
         rect
@@ -61,10 +61,10 @@ impl ClientRect {
     }
 }
 
-impl CacheableWrapper for ClientRect {
+impl Reflectable for ClientRect {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
         unsafe {
-            cast::transmute(&self.wrapper)
+            cast::transmute(&self.reflector_)
         }
     }
 
@@ -75,10 +75,10 @@ impl CacheableWrapper for ClientRect {
 }
 
 impl BindingObject for ClientRect {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }

src/components/script/dom/clientrectlist.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::ClientRectListBinding;
-use dom::bindings::utils::{WrapperCache, CacheableWrapper, BindingObject};
+use dom::bindings::utils::{Reflector, Reflectable, BindingObject};
 use dom::clientrect::ClientRect;
 use script_task::page_from_context;
 
@@ -12,14 +12,14 @@ use js::jsapi::{JSObject, JSContext};
 use std::cast;
 
 pub struct ClientRectList {
-    wrapper: WrapperCache,
+    reflector_: Reflector,
     rects: ~[@mut ClientRect]
 }
 
 impl ClientRectList {
     pub fn new(rects: ~[@mut ClientRect], cx: *JSContext, scope: *JSObject) -> @mut ClientRectList {
         let list = @mut ClientRectList {
-            wrapper: WrapperCache::new(),
+            reflector_: Reflector::new(),
             rects: rects
         };
         list.init_wrapper(cx, scope);
@@ -48,10 +48,10 @@ impl ClientRectList {
     }
 }
 
-impl CacheableWrapper for ClientRectList {
+impl Reflectable for ClientRectList {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
         unsafe {
-            cast::transmute(&self.wrapper)
+            cast::transmute(&self.reflector_)
         }
     }
 
@@ -62,10 +62,10 @@ impl CacheableWrapper for ClientRectList {
 }
 
 impl BindingObject for ClientRectList {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }

src/components/script/dom/document.rs

@@ -3,8 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::DocumentBinding;
-use dom::bindings::utils::{DOMString, WrapperCache, ErrorResult, Fallible};
+use dom::bindings::utils::{DOMString, Reflector, ErrorResult, Fallible};
-use dom::bindings::utils::{BindingObject, CacheableWrapper, DerivedWrapper};
+use dom::bindings::utils::{BindingObject, Reflectable, DerivedWrapper};
 use dom::bindings::utils::{is_valid_element_name, InvalidCharacter, Traceable, null_str_as_empty};
 use dom::element::{Element};
 use dom::element::{HTMLHtmlElementTypeId, HTMLHeadElementTypeId, HTMLTitleElementTypeId};
@@ -31,8 +31,8 @@ use std::libc;
 use std::ascii::StrAsciiExt;
 use std::unstable::raw::Box;
 
-pub trait WrappableDocument {
+pub trait ReflectableDocument {
-    fn init_wrapper(@mut self, cx: *JSContext);
+    fn init_reflector(@mut self, cx: *JSContext);
 }
 
 #[deriving(Eq)]
@@ -41,8 +41,8 @@ pub struct AbstractDocument {
 }
 
 impl AbstractDocument {
-    pub fn as_abstract<T: WrappableDocument>(cx: *JSContext, doc: @mut T) -> AbstractDocument {
+    pub fn as_abstract<T: ReflectableDocument>(cx: *JSContext, doc: @mut T) -> AbstractDocument {
-        doc.init_wrapper(cx);
+        doc.init_reflector(cx);
         AbstractDocument {
             document: unsafe { cast::transmute(doc) }
         }
@@ -92,7 +92,7 @@ pub enum DocumentType {
 
 pub struct Document {
     root: Option<AbstractNode<ScriptView>>,
-    wrapper: WrapperCache,
+    reflector_: Reflector,
     window: Option<@mut Window>,
     doctype: DocumentType,
     title: ~str
@@ -103,7 +103,7 @@ impl Document {
     pub fn new(window: Option<@mut Window>, doctype: DocumentType) -> Document {
         Document {
             root: None,
-            wrapper: WrapperCache::new(),
+            reflector_: Reflector::new(),
             window: window,
             doctype: doctype,
             title: ~""
@@ -125,16 +125,16 @@ impl Document {
     }
 }
 
-impl WrappableDocument for Document {
+impl ReflectableDocument for Document {
-    fn init_wrapper(@mut self, cx: *JSContext) {
+    fn init_reflector(@mut self, cx: *JSContext) {
         self.wrap_object_shared(cx, ptr::null()); //XXXjdm a proper scope would be nice
     }
 }
 
-impl CacheableWrapper for AbstractDocument {
+impl Reflectable for AbstractDocument {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
         do self.with_mut_base |doc| {
-            doc.get_wrappercache()
+            doc.reflector()
         }
     }
 
@@ -152,7 +152,7 @@ impl CacheableWrapper for AbstractDocument {
 }
 
 impl BindingObject for AbstractDocument {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         do self.with_mut_base |doc| {
             doc.GetParentObject(cx)
         }
@@ -162,9 +162,7 @@ impl BindingObject for AbstractDocument {
 impl DerivedWrapper for AbstractDocument {
     #[fixed_stack_segment]
     fn wrap(&mut self, _cx: *JSContext, _scope: *JSObject, vp: *mut JSVal) -> i32 {
-        let cache = self.get_wrappercache();
+        unsafe { *vp = RUST_OBJECT_TO_JSVAL(self.reflector().get_jsobject()) };
-        let wrapper = cache.get_wrapper();
-        unsafe { *vp = RUST_OBJECT_TO_JSVAL(wrapper) };
         return 1;
     }
 
@@ -174,10 +172,10 @@ impl DerivedWrapper for AbstractDocument {
 }
 
 
-impl CacheableWrapper for Document {
+impl Reflectable for Document {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
         unsafe {
-            cast::transmute(&self.wrapper)
+            cast::transmute(&self.reflector_)
         }
     }
 
@@ -188,9 +186,9 @@ impl CacheableWrapper for Document {
 }
 
 impl BindingObject for Document {
-    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut Reflectable> {
         match self.window {
-            Some(win) => Some(win as @mut CacheableWrapper),
+            Some(win) => Some(win as @mut Reflectable),
             None => None
         }
     }
@@ -229,9 +227,7 @@ impl Document {
     fn get_scope_and_cx(&self) -> (*JSObject, *JSContext) {
         let win = self.window.get_ref();
         let cx = win.page.js_info.get_ref().js_compartment.cx.ptr;
-        let cache = win.get_wrappercache();
+        (win.reflector().get_jsobject(), cx)
-        let scope = cache.get_wrapper();
-        (scope, cx)
     }
 
     pub fn GetElementsByTagName(&self, tag: &DOMString) -> @mut HTMLCollection {
@@ -506,7 +502,7 @@ impl Traceable for Document {
                         debug!("tracing root node");
                         do root.with_base |node| {
                             JS_CallTracer(tracer as *JSTracer,
-                                          node.wrapper.wrapper,
+                                          node.reflector_.object,
                                           JSTRACE_OBJECT as u32);
                         }
                     }

src/components/script/dom/domparser.rs

@@ -4,7 +4,7 @@
 
 use dom::bindings::codegen::DOMParserBinding;
 use dom::bindings::codegen::DOMParserBinding::SupportedTypeValues::{Text_html, Text_xml};
-use dom::bindings::utils::{DOMString, Fallible, WrapperCache, CacheableWrapper};
+use dom::bindings::utils::{DOMString, Fallible, Reflector, Reflectable};
 use dom::document::{AbstractDocument, Document, XML};
 use dom::element::HTMLHtmlElementTypeId;
 use dom::htmldocument::HTMLDocument;
@@ -15,20 +15,19 @@ use dom::window::Window;
 
 pub struct DOMParser {
     owner: @mut Window, //XXXjdm Document instead?
-    wrapper: WrapperCache
+    reflector_: Reflector
 }
 
 impl DOMParser {
     pub fn new(owner: @mut Window) -> @mut DOMParser {
         let parser = @mut DOMParser {
             owner: owner,
-            wrapper: WrapperCache::new()
+            reflector_: Reflector::new()
         };
 
         // TODO(tkuehn): This just handles the top-level page. Need to handle subframes.
         let cx = owner.page.js_info.get_ref().js_compartment.cx.ptr;
-        let cache = owner.get_wrappercache();
+        let scope = owner.reflector().get_jsobject();
-        let scope = cache.get_wrapper();
         parser.wrap_object_shared(cx, scope);
         parser
     }

src/components/script/dom/element.rs

@@ -4,7 +4,7 @@
 
 //! Element nodes.
 
-use dom::bindings::utils::{BindingObject, CacheableWrapper, DOMString, ErrorResult, Fallible, WrapperCache};
+use dom::bindings::utils::{BindingObject, Reflectable, DOMString, ErrorResult, Fallible, Reflector};
 use dom::bindings::utils::{null_str_as_empty, null_str_as_empty_ref};
 use dom::htmlcollection::HTMLCollection;
 use dom::clientrect::ClientRect;
@@ -28,9 +28,9 @@ pub struct Element {
     style_attribute: Option<Stylesheet>,
 }
 
-impl CacheableWrapper for Element {
+impl Reflectable for Element {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        self.node.get_wrappercache()
+        self.node.reflector()
     }
 
     fn wrap_object_shared(@mut self, _cx: *JSContext, _scope: *JSObject) -> *JSObject {
@@ -39,7 +39,7 @@ impl CacheableWrapper for Element {
 }
 
 impl BindingObject for Element {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         self.node.GetParentObject(cx)
     }
 }
@@ -191,8 +191,7 @@ impl<'self> Element {
         let doc = self.node.owner_doc.unwrap();
         let win = doc.with_base(|doc| doc.window.unwrap());
         let cx = win.page.js_info.get_ref().js_compartment.cx.ptr;
-        let cache = win.get_wrappercache();
+        let scope = win.reflector().get_jsobject();
-        let scope = cache.get_wrapper();
         (scope, cx)
     }
 }
@@ -287,8 +286,7 @@ impl Element {
             match page.query_layout(ContentBoxesQuery(node, chan), port) {
                 ContentBoxesResponse(rects) => {
                     let cx = page.js_info.get_ref().js_compartment.cx.ptr;
-                    let cache = win.get_wrappercache();
+                    let scope = win.reflector().get_jsobject();
-                    let scope = cache.get_wrapper();
                     let rects = do rects.map |r| {
                         ClientRect::new(
                              r.origin.y.to_f32(),
@@ -315,8 +313,7 @@ impl Element {
         match page.query_layout(ContentBoxQuery(node, chan), port) {
             ContentBoxResponse(rect) => {
                 let cx = page.js_info.get_ref().js_compartment.cx.ptr;
-                let cache = win.get_wrappercache();
+                let scope = win.reflector().get_jsobject();
-                let scope = cache.get_wrapper();
                 ClientRect::new(
                     rect.origin.y.to_f32(),
                     (rect.origin.y + rect.size.height).to_f32(),

src/components/script/dom/event.rs

@@ -5,8 +5,8 @@
 use dom::eventtarget::EventTarget;
 use dom::window::Window;
 use dom::bindings::codegen::EventBinding;
-use dom::bindings::utils::{CacheableWrapper, BindingObject, DerivedWrapper};
+use dom::bindings::utils::{Reflectable, BindingObject, DerivedWrapper};
-use dom::bindings::utils::{DOMString, ErrorResult, Fallible, WrapperCache};
+use dom::bindings::utils::{DOMString, ErrorResult, Fallible, Reflector};
 
 use geom::point::Point2D;
 use js::glue::RUST_OBJECT_TO_JSVAL;
@@ -26,7 +26,7 @@ pub enum Event_ {
 }
 
 pub struct Event {
-    wrapper: WrapperCache,
+    reflector_: Reflector,
     type_: DOMString,
     default_prevented: bool,
     cancelable: bool,
@@ -37,7 +37,7 @@ pub struct Event {
 impl Event {
     pub fn new(type_: &DOMString) -> Event {
         Event {
-            wrapper: WrapperCache::new(),
+            reflector_: Reflector::new(),
             type_: (*type_).clone(),
             default_prevented: false,
             cancelable: true,
@@ -113,9 +113,9 @@ impl Event {
     }
 }
 
-impl CacheableWrapper for Event {
+impl Reflectable for Event {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        unsafe { cast::transmute(&self.wrapper) }
+        unsafe { cast::transmute(&self.reflector_) }
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -125,10 +125,10 @@ impl CacheableWrapper for Event {
 }
 
 impl BindingObject for Event {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }

src/components/script/dom/eventtarget.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::EventTargetBinding;
-use dom::bindings::utils::{CacheableWrapper, WrapperCache, BindingObject, DerivedWrapper};
+use dom::bindings::utils::{Reflectable, Reflector, BindingObject, DerivedWrapper};
 use script_task::page_from_context;
 
 use js::glue::RUST_OBJECT_TO_JSVAL;
@@ -12,13 +12,13 @@ use js::jsapi::{JSObject, JSContext, JSVal};
 use std::cast;
 
 pub struct EventTarget {
-    wrapper: WrapperCache
+    reflector_: Reflector
 }
 
 impl EventTarget {
     pub fn new() -> ~EventTarget {
         ~EventTarget {
-            wrapper: WrapperCache::new()
+            reflector_: Reflector::new()
         }
     }
 
@@ -27,9 +27,9 @@ impl EventTarget {
     }
 }
 
-impl CacheableWrapper for EventTarget {
+impl Reflectable for EventTarget {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        unsafe { cast::transmute(&self.wrapper) }
+        unsafe { cast::transmute(&self.reflector_) }
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -39,11 +39,11 @@ impl CacheableWrapper for EventTarget {
 }
 
 impl BindingObject for EventTarget {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         // TODO(tkuehn): This only handles top-level pages. Needs to handle subframes.
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }

src/components/script/dom/formdata.rs

@@ -2,8 +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 dom::bindings::utils::{CacheableWrapper, BindingObject, DerivedWrapper};
+use dom::bindings::utils::{Reflectable, BindingObject, DerivedWrapper};
-use dom::bindings::utils::{WrapperCache, DOMString, null_str_as_empty};
+use dom::bindings::utils::{Reflector, DOMString, null_str_as_empty};
 use dom::bindings::codegen::FormDataBinding;
 use dom::blob::Blob;
 use script_task::{page_from_context};
@@ -21,14 +21,14 @@ enum FormDatum {
 
 pub struct FormData {
     data: HashMap<~str, FormDatum>,
-    wrapper: WrapperCache
+    reflector_: Reflector
 }
 
 impl FormData {
     pub fn new() -> @mut FormData {
         @mut FormData {
             data: HashMap::new(),
-            wrapper: WrapperCache::new()
+            reflector_: Reflector::new()
         }
     }
 
@@ -49,10 +49,10 @@ impl FormData {
     }
 }
 
-impl CacheableWrapper for FormData {
+impl Reflectable for FormData {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
         unsafe {
-            cast::transmute(&self.wrapper)
+            cast::transmute(&self.reflector_)
         }
     }
 
@@ -63,10 +63,10 @@ impl CacheableWrapper for FormData {
 }
 
 impl BindingObject for FormData {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }

src/components/script/dom/htmlcollection.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::HTMLCollectionBinding;
-use dom::bindings::utils::{CacheableWrapper, BindingObject, WrapperCache};
+use dom::bindings::utils::{Reflectable, BindingObject, Reflector};
 use dom::bindings::utils::{DOMString, Fallible};
 use dom::node::{AbstractNode, ScriptView};
 use script_task::page_from_context;
@@ -15,14 +15,14 @@ use std::ptr;
 
 pub struct HTMLCollection {
     elements: ~[AbstractNode<ScriptView>],
-    wrapper: WrapperCache
+    reflector_: Reflector
 }
 
 impl HTMLCollection {
     pub fn new(elements: ~[AbstractNode<ScriptView>], cx: *JSContext, scope: *JSObject) -> @mut HTMLCollection {
         let collection = @mut HTMLCollection {
             elements: elements,
-            wrapper: WrapperCache::new()
+            reflector_: Reflector::new()
         };
         collection.init_wrapper(cx, scope);
         collection
@@ -59,19 +59,19 @@ impl HTMLCollection {
 }
 
 impl BindingObject for HTMLCollection {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         // TODO(tkuehn): This only handles the top-level frame. Need to grab subframes.
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }
 
-impl CacheableWrapper for HTMLCollection {
+impl Reflectable for HTMLCollection {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
         unsafe {
-            cast::transmute(&self.wrapper)
+            cast::transmute(&self.reflector_)
         }
     }
 

src/components/script/dom/htmldatalistelement.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::CacheableWrapper;
+use dom::bindings::utils::Reflectable;
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlelement::HTMLElement;
 
@@ -17,8 +17,7 @@ impl HTMLDataListElement {
         let doc = self.htmlelement.element.node.owner_doc.unwrap();
         let win = doc.with_base(|doc| doc.window.unwrap());
         let cx = win.page.js_info.get_ref().js_compartment.cx.ptr;
-        let cache = win.get_wrappercache();
+        let scope = win.reflector().get_jsobject();
-        let scope = cache.get_wrapper();
         (scope, cx)
     }
 

src/components/script/dom/htmldocument.rs

@@ -4,8 +4,8 @@
 
 use dom::bindings::codegen::HTMLDocumentBinding;
 use dom::bindings::utils::{DOMString, ErrorResult, Fallible, Traceable};
-use dom::bindings::utils::{CacheableWrapper, BindingObject, WrapperCache};
+use dom::bindings::utils::{Reflectable, BindingObject, Reflector};
-use dom::document::{AbstractDocument, Document, WrappableDocument, HTML};
+use dom::document::{AbstractDocument, Document, ReflectableDocument, HTML};
 use dom::element::HTMLHeadElementTypeId;
 use dom::htmlcollection::HTMLCollection;
 use dom::node::{AbstractNode, ScriptView, ElementNodeTypeId};
@@ -36,14 +36,13 @@ impl HTMLDocument {
     fn get_scope_and_cx(&self) -> (*JSObject, *JSContext) {
         let win = self.parent.window.get_ref();
         let cx = win.page.js_info.get_ref().js_compartment.cx.ptr;
-        let cache = win.get_wrappercache();
+        let scope = win.reflector().get_jsobject();
-        let scope = cache.get_wrapper();
         (scope, cx)
     }
 }
 
-impl WrappableDocument for HTMLDocument {
+impl ReflectableDocument for HTMLDocument {
-    fn init_wrapper(@mut self, cx: *JSContext) {
+    fn init_reflector(@mut self, cx: *JSContext) {
         self.wrap_object_shared(cx, ptr::null()); //XXXjdm a proper scope would be nice
     }
 }
@@ -200,9 +199,9 @@ impl HTMLDocument {
     }
 }
 
-impl CacheableWrapper for HTMLDocument {
+impl Reflectable for HTMLDocument {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        self.parent.get_wrappercache()
+        self.parent.reflector()
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -212,7 +211,7 @@ impl CacheableWrapper for HTMLDocument {
 }
 
 impl BindingObject for HTMLDocument {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         self.parent.GetParentObject(cx)
     }
 }

src/components/script/dom/htmlelement.rs

@@ -4,7 +4,7 @@
 
 use dom::bindings::codegen::HTMLElementBinding;
 use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
-use dom::bindings::utils::{CacheableWrapper, BindingObject, WrapperCache};
+use dom::bindings::utils::{Reflectable, BindingObject, Reflector};
 use dom::element::{Element, ElementTypeId};
 use dom::node::{AbstractNode, ScriptView};
 use js::jsapi::{JSObject, JSContext, JSVal};
@@ -148,9 +148,9 @@ impl HTMLElement {
     }
 }
 
-impl CacheableWrapper for HTMLElement {
+impl Reflectable for HTMLElement {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        self.element.get_wrappercache()
+        self.element.reflector()
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -160,7 +160,7 @@ impl CacheableWrapper for HTMLElement {
 }
 
 impl BindingObject for HTMLElement {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         self.element.GetParentObject(cx)
     }
 }

src/components/script/dom/htmlfieldsetelement.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{DOMString, ErrorResult, CacheableWrapper};
+use dom::bindings::utils::{DOMString, ErrorResult, Reflectable};
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlelement::HTMLElement;
 use dom::node::{AbstractNode, ScriptView};
@@ -43,8 +43,7 @@ impl HTMLFieldSetElement {
         let doc = self.htmlelement.element.node.owner_doc.unwrap();
         let win = doc.with_base(|doc| doc.window.unwrap());
         let cx = win.page.js_info.get_ref().js_compartment.cx.ptr;
-        let cache = win.get_wrappercache();
+        let scope = win.reflector().get_jsobject();
-        let scope = cache.get_wrapper();
         (scope, cx)
     }
 

src/components/script/dom/htmlformelement.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{CacheableWrapper, DOMString, ErrorResult};
+use dom::bindings::utils::{Reflectable, DOMString, ErrorResult};
 use dom::element::HTMLFormElementTypeId;
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlelement::HTMLElement;
@@ -19,8 +19,7 @@ impl HTMLFormElement {
         let doc = self.htmlelement.element.node.owner_doc.unwrap();
         let win = doc.with_base(|doc| doc.window.unwrap());
         let cx = win.page.js_info.get_ref().js_compartment.cx.ptr;
-        let cache = win.get_wrappercache();
+        let scope = win.reflector().get_jsobject();
-        let scope = cache.get_wrapper();
         (scope, cx)
     }
 

src/components/script/dom/htmlmapelement.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{DOMString, ErrorResult, CacheableWrapper};
+use dom::bindings::utils::{DOMString, ErrorResult, Reflectable};
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlelement::HTMLElement;
 use js::jsapi::{JSObject, JSContext};
@@ -24,8 +24,7 @@ impl HTMLMapElement {
         let doc = self.htmlelement.element.node.owner_doc.unwrap();
         let win = doc.with_base(|doc| doc.window.unwrap());
         let cx = win.page.js_info.get_ref().js_compartment.cx.ptr;
-        let cache = win.get_wrappercache();
+        let scope = win.reflector().get_jsobject();
-        let scope = cache.get_wrapper();
         (scope, cx)
     }
 

src/components/script/dom/mouseevent.rs

@@ -4,7 +4,7 @@
 
 use dom::bindings::codegen::MouseEventBinding;
 use dom::bindings::utils::{ErrorResult, Fallible, DOMString};
-use dom::bindings::utils::{CacheableWrapper, WrapperCache, BindingObject, DerivedWrapper};
+use dom::bindings::utils::{Reflectable, Reflector, BindingObject, DerivedWrapper};
 use dom::eventtarget::EventTarget;
 use dom::uievent::UIEvent;
 use dom::window::Window;
@@ -142,9 +142,9 @@ impl MouseEvent {
     }
 }
 
-impl CacheableWrapper for MouseEvent {
+impl Reflectable for MouseEvent {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        return self.parent.get_wrappercache()
+        return self.parent.reflector()
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -154,7 +154,7 @@ impl CacheableWrapper for MouseEvent {
 }
 
 impl BindingObject for MouseEvent {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         self.parent.GetParentObject(cx)
     }
 }

src/components/script/dom/navigator.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{WrapperCache, BindingObject, CacheableWrapper};
+use dom::bindings::utils::{Reflector, BindingObject, Reflectable};
 use dom::bindings::utils::{DOMString, Fallible};
 use dom::bindings::codegen::NavigatorBinding;
 use script_task::{page_from_context};
@@ -12,13 +12,13 @@ use js::jsapi::{JSContext, JSObject};
 use std::cast;
 
 pub struct Navigator {
-    wrapper: WrapperCache
+    reflector_: Reflector
 }
 
 impl Navigator {
     pub fn new() -> @mut Navigator {
         @mut Navigator {
-            wrapper: WrapperCache::new()
+            reflector_: Reflector::new()
         }
     }
 
@@ -87,9 +87,9 @@ impl Navigator {
     }
 }
 
-impl CacheableWrapper for Navigator {
+impl Reflectable for Navigator {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        unsafe { cast::transmute(&self.wrapper) }
+        unsafe { cast::transmute(&self.reflector_) }
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -99,10 +99,10 @@ impl CacheableWrapper for Navigator {
 }
 
 impl BindingObject for Navigator {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }

src/components/script/dom/node.rs

@@ -5,8 +5,8 @@
 //! The core DOM types. Defines the basic DOM hierarchy as well as all the HTML elements.
 
 use dom::bindings::node;
-use dom::bindings::utils::{WrapperCache, DOMString, ErrorResult, Fallible, NotFound, HierarchyRequest};
+use dom::bindings::utils::{Reflector, DOMString, ErrorResult, Fallible, NotFound, HierarchyRequest};
-use dom::bindings::utils::{BindingObject, CacheableWrapper, null_str_as_empty};
+use dom::bindings::utils::{BindingObject, Reflectable, null_str_as_empty};
 use dom::characterdata::CharacterData;
 use dom::document::AbstractDocument;
 use dom::element::{Element, ElementTypeId, HTMLImageElementTypeId, HTMLIframeElementTypeId};
@@ -62,8 +62,8 @@ pub struct AbstractNodeChildrenIterator<View> {
 /// the script task, this is the unit type `()`. For the layout task, this is
 /// `LayoutData`.
 pub struct Node<View> {
-    /// The JavaScript wrapper for this node.
+    /// The JavaScript reflector for this node.
-    wrapper: WrapperCache,
+    reflector_: Reflector,
 
     /// The type of node that this is.
     type_id: NodeTypeId,
@@ -155,11 +155,11 @@ impl<View> TreeNode<AbstractNode<View>> for Node<View> { }
 impl<'self, View> AbstractNode<View> {
     // Unsafe accessors
 
-    pub unsafe fn as_cacheable_wrapper(&self) -> @mut CacheableWrapper {
+    pub unsafe fn as_cacheable_wrapper(&self) -> @mut Reflectable {
         match self.type_id() {
             TextNodeTypeId => {
                 let node: @mut Text = cast::transmute(self.obj);
-                node as @mut CacheableWrapper
+                node as @mut Reflectable
             }
             _ => {
                 fail!("unsupported node type")
@@ -465,7 +465,7 @@ impl Node<ScriptView> {
 
     pub fn new(type_id: NodeTypeId) -> Node<ScriptView> {
         Node {
-            wrapper: WrapperCache::new(),
+            reflector_: Reflector::new(),
             type_id: type_id,
 
             abstract: None,
@@ -789,9 +789,9 @@ impl VoidPtrLike for AbstractNode<LayoutView> {
     }
 }
 
-impl CacheableWrapper for Node<ScriptView> {
+impl Reflectable for Node<ScriptView> {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        unsafe { cast::transmute(&mut self.wrapper) }
+        unsafe { cast::transmute(&mut self.reflector_) }
     }
 
     fn wrap_object_shared(@mut self, _cx: *JSContext, _scope: *JSObject) -> *JSObject {
@@ -800,7 +800,7 @@ impl CacheableWrapper for Node<ScriptView> {
 }
 
 impl BindingObject for Node<ScriptView> {
-    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut Reflectable> {
         match self.parent_node {
             Some(node) => Some(unsafe {node.as_cacheable_wrapper()}),
             None => None

src/components/script/dom/uievent.rs

@@ -4,7 +4,7 @@
 
 use dom::bindings::codegen::UIEventBinding;
 use dom::bindings::utils::{DOMString, Fallible};
-use dom::bindings::utils::{CacheableWrapper, WrapperCache, BindingObject, DerivedWrapper};
+use dom::bindings::utils::{Reflectable, Reflector, BindingObject, DerivedWrapper};
 use dom::node::{AbstractNode, ScriptView};
 use dom::event::Event;
 use dom::window::Window;
@@ -115,9 +115,9 @@ impl UIEvent {
     }
 }
 
-impl CacheableWrapper for UIEvent {
+impl Reflectable for UIEvent {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        return self.parent.get_wrappercache()
+        return self.parent.reflector()
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -127,7 +127,7 @@ impl CacheableWrapper for UIEvent {
 }
 
 impl BindingObject for UIEvent {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         self.parent.GetParentObject(cx)
     }
 }

src/components/script/dom/validitystate.rs

@@ -2,20 +2,20 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{WrapperCache, BindingObject, CacheableWrapper};
+use dom::bindings::utils::{Reflector, BindingObject, Reflectable};
 use dom::bindings::codegen::ValidityStateBinding;
 use js::jsapi::{JSContext, JSObject};
 use std::cast;
 
 pub struct ValidityState {
-    wrapper: WrapperCache,
+    reflector_: Reflector,
     state: u8
 }
 
 impl ValidityState {
     pub fn valid() -> ValidityState {
         ValidityState {
-            wrapper: WrapperCache::new(),
+            reflector_: Reflector::new(),
             state: 0
         }
     }
@@ -59,9 +59,9 @@ impl ValidityState {
     }
 }
 
-impl CacheableWrapper for ValidityState {
+impl Reflectable for ValidityState {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        unsafe { cast::transmute(&self.wrapper) }
+        unsafe { cast::transmute(&self.reflector_) }
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -71,7 +71,7 @@ impl CacheableWrapper for ValidityState {
 }
 
 impl BindingObject for ValidityState {
-    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut Reflectable> {
         None
     }
 }

src/components/script/dom/window.rs

@@ -3,8 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::WindowBinding;
-use dom::bindings::utils::{WrapperCache, DOMString, Traceable};
+use dom::bindings::utils::{Reflector, DOMString, Traceable};
-use dom::bindings::utils::{CacheableWrapper, BindingObject, null_str_as_empty};
+use dom::bindings::utils::{Reflectable, BindingObject, null_str_as_empty};
 use dom::document::AbstractDocument;
 use dom::node::{AbstractNode, ScriptView};
 use dom::navigator::Navigator;
@@ -43,7 +43,7 @@ pub struct Window {
     page: @mut Page,
     script_chan: ScriptChan,
     compositor: @ScriptListener,
-    wrapper: WrapperCache,
+    reflector_: Reflector,
     timer_chan: SharedChan<TimerControlMsg>,
     navigator: Option<@mut Navigator>,
     image_cache_task: ImageCacheTask,
@@ -135,9 +135,9 @@ impl Window {
     }
 }
 
-impl CacheableWrapper for Window {
+impl Reflectable for Window {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        unsafe { cast::transmute(&self.wrapper) }
+        unsafe { cast::transmute(&self.reflector_) }
     }
 
     fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject {
@@ -147,7 +147,7 @@ impl CacheableWrapper for Window {
 }
 
 impl BindingObject for Window {
-    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut Reflectable> {
         None
     }
 }
@@ -203,7 +203,7 @@ impl Window {
             page: page,
             script_chan: script_chan.clone(),
             compositor: compositor,
-            wrapper: WrapperCache::new(),
+            reflector_: Reflector::new(),
             timer_chan: {
                 let (timer_port, timer_chan) = comm::stream::<TimerControlMsg>();
                 let id = page.id.clone();
@@ -225,9 +225,9 @@ impl Window {
         };
 
         unsafe {
-            let cache = ptr::to_unsafe_ptr(win.get_wrappercache());
+            let reflector = ptr::to_unsafe_ptr(win.reflector());
             win.wrap_object_shared(cx, ptr::null()); //XXXjdm proper scope
-            let global = (*cache).wrapper;
+            let global = (*reflector).object;
             do "window".to_c_str().with_ref |name| {
                 JS_DefineProperty(cx, global,  name,
                                   RUST_OBJECT_TO_JSVAL(global),
@@ -254,7 +254,7 @@ impl Traceable for Window {
                             (*tracer).debugPrintArg = name as *libc::c_void;
                             debug!("tracing document");
                             JS_CallTracer(tracer as *JSTracer,
-                                          doc.wrapper.wrapper,
+                                          doc.reflector_.object,
                                           JSTRACE_OBJECT as u32);
                         }
                     }

src/components/script/dom/windowproxy.rs

@@ -2,19 +2,19 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use dom::bindings::utils::{CacheableWrapper, WrapperCache, BindingObject};
+use dom::bindings::utils::{Reflectable, Reflector, BindingObject};
 use script_task::page_from_context;
 
 use js::jsapi::{JSContext, JSObject};
 
 pub struct WindowProxy {
-    wrapper: WrapperCache
+    reflector_: Reflector
 }
 
 impl WindowProxy {
     pub fn new() -> @mut WindowProxy {
         @mut WindowProxy {
-            wrapper: WrapperCache::new()
+            reflector_: Reflector::new()
         }
     }
 
@@ -24,17 +24,17 @@ impl WindowProxy {
 }
 
 impl BindingObject for WindowProxy {
-    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut CacheableWrapper> {
+    fn GetParentObject(&self, cx: *JSContext) -> Option<@mut Reflectable> {
         let page = page_from_context(cx);
         unsafe {
-            Some((*page).frame.get_ref().window as @mut CacheableWrapper)
+            Some((*page).frame.get_ref().window as @mut Reflectable)
         }
     }
 }
 
-impl CacheableWrapper for WindowProxy {
+impl Reflectable for WindowProxy {
-    fn get_wrappercache(&mut self) -> &mut WrapperCache {
+    fn reflector(&mut self) -> &mut Reflector {
-        return self.get_wrappercache()
+        return self.reflector()
     }
 
     fn wrap_object_shared(@mut self, _cx: *JSContext, _scope: *JSObject) -> *JSObject {

src/components/script/script_task.rs

@@ -8,7 +8,7 @@
 use servo_msg::compositor_msg::{ScriptListener, Loading, PerformingLayout};
 use servo_msg::compositor_msg::FinishedLoading;
 use dom::bindings::codegen::RegisterBindings;
-use dom::bindings::utils::{CacheableWrapper, GlobalStaticData};
+use dom::bindings::utils::{Reflectable, GlobalStaticData};
 use dom::document::AbstractDocument;
 use dom::element::Element;
 use dom::event::{Event_, ResizeEvent, ReflowEvent, ClickEvent, MouseDownEvent, MouseUpEvent};
@@ -707,7 +707,7 @@ impl ScriptTask {
                                  self.chan.clone(),
                                  self.compositor,
                                  self.image_cache_task.clone());
-        page.initialize_js_info(cx, window.get_wrappercache().get_wrapper());
+        page.initialize_js_info(cx, window.reflector().get_jsobject());
 
         RegisterBindings::Register(page.js_info.get_ref().js_compartment);