Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 21:50:18 +01:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source 
There are still a few instances of "wrapper"-ish names scattered throughout the code, but this is a good start.
This commit is contained in:
bors-servo 2013-10-09 05:40:12 -07:00
commit 89dd9dd8eb
30 changed files with 238 additions and 253 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/components/script/dom/bindings/codegen/CodegenRust.py
View file

@ -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"]

12
src/components/script/dom/bindings/domparser.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
unsafe { cast::transmute(&self.wrapper) }
impl Reflectable for DOMParser {
fn reflector(&mut self) -> &mut Reflector {
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> {
Some(self.owner as @mut CacheableWrapper)
fn GetParentObject(&self, _cx: *JSContext) -> Option<@mut Reflectable> {
Some(self.owner as @mut Reflectable)
}
}

26
src/components/script/dom/bindings/element.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
self.element.get_wrappercache()
impl Reflectable for $name {
fn reflector(&mut self) -> &mut Reflector {
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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
self.htmlelement.get_wrappercache()
impl Reflectable for $name {
fn reflector(&mut self) -> &mut Reflector {
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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
self.node.get_wrappercache()
impl Reflectable for $name {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}

17
src/components/script/dom/bindings/node.rs
View file

@ -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> {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
impl Reflectable for AbstractNode<ScriptView> {
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 wrapper = cache.get_wrapper();
assert!(wrapper.is_not_null());
let obj = node.reflector().get_jsobject();
assert!(obj.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");

55
src/components/script/dom/bindings/utils.rs
View file

@ -527,42 +527,42 @@ pub fn initialize_global(global: *JSObject) {
}
}
pub trait CacheableWrapper {
fn get_wrappercache(&mut self) -> &mut WrapperCache;
pub trait Reflectable {
fn reflector(&mut self) -> &mut Reflector;
fn wrap_object_shared(@mut self, cx: *JSContext, scope: *JSObject) -> *JSObject;
}
pub struct WrapperCache {
wrapper: *JSObject
pub struct Reflector {
object: *JSObject
}
impl WrapperCache {
pub fn get_wrapper(&self) -> *JSObject {
unsafe { cast::transmute(self.wrapper) }
impl Reflector {
pub fn get_jsobject(&self) -> *JSObject {
unsafe { cast::transmute(self.object) }
}
pub fn set_wrapper(&mut self, wrapper: *JSObject) {
self.wrapper = wrapper;
pub fn set_jsobject(&mut self, object: *JSObject) {
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 {
WrapperCache {
wrapper: ptr::null()
pub fn new() -> Reflector {
Reflector {
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 obj = cache.get_wrapper();
let reflector = value.reflector();
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 wrapper = cache.get_wrapper();
if wrapper.is_not_null() {
return wrapper;
let obj = p.reflector().get_jsobject();
if obj.is_not_null() {
return obj;
}
let wrapper = p.wrap_object_shared(cx, scope);
cache.set_wrapper(wrapper);
wrapper
let obj = p.wrap_object_shared(cx, scope);
p.reflector().set_jsobject(obj);
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 wrapper = cache.get_wrapper();
let cache = self.reflector();
let wrapper = cache.get_jsobject();
if wrapper.is_not_null() {
unsafe { *vp = RUST_OBJECT_TO_JSVAL(wrapper) };
return 1;

16
src/components/script/dom/blob.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
unsafe { cast::transmute(&self.wrapper) }
impl Reflectable for Blob {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}
}

10
src/components/script/dom/characterdata.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
self.node.get_wrappercache()
impl Reflectable for CharacterData {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}

16
src/components/script/dom/clientrect.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
impl Reflectable for ClientRect {
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)
}
}
}

16
src/components/script/dom/clientrectlist.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
impl Reflectable for ClientRectList {
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)
}
}
}

48
src/components/script/dom/document.rs
View file

@ -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::{BindingObject, CacheableWrapper, DerivedWrapper};
use dom::bindings::utils::{DOMString, Reflector, ErrorResult, Fallible};
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 {
fn init_wrapper(@mut self, cx: *JSContext);
pub trait ReflectableDocument {
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 {
doc.init_wrapper(cx);
pub fn as_abstract<T: ReflectableDocument>(cx: *JSContext, doc: @mut T) -> AbstractDocument {
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 {
fn init_wrapper(@mut self, cx: *JSContext) {
impl ReflectableDocument for Document {
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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
impl Reflectable for AbstractDocument {
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();
let wrapper = cache.get_wrapper();
unsafe { *vp = RUST_OBJECT_TO_JSVAL(wrapper) };
unsafe { *vp = RUST_OBJECT_TO_JSVAL(self.reflector().get_jsobject()) };
return 1;
}
@ -174,10 +172,10 @@ impl DerivedWrapper for AbstractDocument {
}
impl CacheableWrapper for Document {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
impl Reflectable for Document {
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();
let scope = cache.get_wrapper();
(scope, cx)
(win.reflector().get_jsobject(), 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);
}
}

9
src/components/script/dom/domparser.rs
View file

@ -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 = cache.get_wrapper();
let scope = owner.reflector().get_jsobject();
parser.wrap_object_shared(cx, scope);
parser
}

19
src/components/script/dom/element.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
self.node.get_wrappercache()
impl Reflectable for Element {
fn reflector(&mut self) -> &mut Reflector {
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 = cache.get_wrapper();
let scope = win.reflector().get_jsobject();
(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 = cache.get_wrapper();
let scope = win.reflector().get_jsobject();
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 = cache.get_wrapper();
let scope = win.reflector().get_jsobject();
ClientRect::new(
rect.origin.y.to_f32(),
(rect.origin.y + rect.size.height).to_f32(),

18
src/components/script/dom/event.rs
View file

@ -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::{DOMString, ErrorResult, Fallible, WrapperCache};
use dom::bindings::utils::{Reflectable, BindingObject, DerivedWrapper};
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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
unsafe { cast::transmute(&self.wrapper) }
impl Reflectable for Event {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}
}

16
src/components/script/dom/eventtarget.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
unsafe { cast::transmute(&self.wrapper) }
impl Reflectable for EventTarget {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}
}

18
src/components/script/dom/formdata.rs
View file

@ -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::{WrapperCache, DOMString, null_str_as_empty};
use dom::bindings::utils::{Reflectable, BindingObject, DerivedWrapper};
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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
impl Reflectable for FormData {
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)
}
}
}

16
src/components/script/dom/htmlcollection.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
impl Reflectable for HTMLCollection {
fn reflector(&mut self) -> &mut Reflector {
unsafe {
cast::transmute(&self.wrapper)
cast::transmute(&self.reflector_)
}
}

5
src/components/script/dom/htmldatalistelement.rs
View file

@ -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 = cache.get_wrapper();
let scope = win.reflector().get_jsobject();
(scope, cx)
}

19
src/components/script/dom/htmldocument.rs
View file

@ -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::document::{AbstractDocument, Document, WrappableDocument, HTML};
use dom::bindings::utils::{Reflectable, BindingObject, Reflector};
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 = cache.get_wrapper();
let scope = win.reflector().get_jsobject();
(scope, cx)
}
}
impl WrappableDocument for HTMLDocument {
fn init_wrapper(@mut self, cx: *JSContext) {
impl ReflectableDocument for HTMLDocument {
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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
self.parent.get_wrappercache()
impl Reflectable for HTMLDocument {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}

10
src/components/script/dom/htmlelement.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
self.element.get_wrappercache()
impl Reflectable for HTMLElement {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}

5
src/components/script/dom/htmlfieldsetelement.rs
View file

@ -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 = cache.get_wrapper();
let scope = win.reflector().get_jsobject();
(scope, cx)
}

5
src/components/script/dom/htmlformelement.rs
View file

@ -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 = cache.get_wrapper();
let scope = win.reflector().get_jsobject();
(scope, cx)
}

5
src/components/script/dom/htmlmapelement.rs
View file

@ -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 = cache.get_wrapper();
let scope = win.reflector().get_jsobject();
(scope, cx)
}

10
src/components/script/dom/mouseevent.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
return self.parent.get_wrappercache()
impl Reflectable for MouseEvent {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}

16
src/components/script/dom/navigator.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
unsafe { cast::transmute(&self.wrapper) }
impl Reflectable for Navigator {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}
}

22
src/components/script/dom/node.rs
View file

@ -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::{BindingObject, CacheableWrapper, null_str_as_empty};
use dom::bindings::utils::{Reflector, DOMString, ErrorResult, Fallible, NotFound, HierarchyRequest};
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.
wrapper: WrapperCache,
/// The JavaScript reflector for this node.
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> {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
unsafe { cast::transmute(&mut self.wrapper) }
impl Reflectable for Node<ScriptView> {
fn reflector(&mut self) -> &mut Reflector {
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

10
src/components/script/dom/uievent.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
return self.parent.get_wrappercache()
impl Reflectable for UIEvent {
fn reflector(&mut self) -> &mut Reflector {
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)
}
}

14
src/components/script/dom/validitystate.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
unsafe { cast::transmute(&self.wrapper) }
impl Reflectable for ValidityState {
fn reflector(&mut self) -> &mut Reflector {
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
}
}

22
src/components/script/dom/window.rs
View file

@ -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::{CacheableWrapper, BindingObject, null_str_as_empty};
use dom::bindings::utils::{Reflector, DOMString, Traceable};
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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
unsafe { cast::transmute(&self.wrapper) }
impl Reflectable for Window {
fn reflector(&mut self) -> &mut Reflector {
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);
}
}

16
src/components/script/dom/windowproxy.rs
View file

@ -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 {
fn get_wrappercache(&mut self) -> &mut WrapperCache {
return self.get_wrappercache()
impl Reflectable for WindowProxy {
fn reflector(&mut self) -> &mut Reflector {
return self.reflector()
}
fn wrap_object_shared(@mut self, _cx: *JSContext, _scope: *JSObject) -> *JSObject {

4
src/components/script/script_task.rs
View file

@ -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);