From 25af99884210e40c1d5828757d272f977dfdefe0 Mon Sep 17 00:00:00 2001
From: Manish Goregaokar <manishsmail@gmail.com>
Date: Mon, 29 Sep 2014 04:15:43 +0530
Subject: [PATCH] Remove Traceable from eventtarget.rs

---
 components/script/dom/eventtarget.rs | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/components/script/dom/eventtarget.rs b/components/script/dom/eventtarget.rs
index 8ab66699d6e..0abe98975e5 100644
--- a/components/script/dom/eventtarget.rs
+++ b/components/script/dom/eventtarget.rs
@@ -8,7 +8,6 @@ use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
 use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
 use dom::bindings::error::{Fallible, InvalidState, report_pending_exception};
 use dom::bindings::js::JSRef;
-use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::event::Event;
 use dom::eventdispatcher::dispatch_event;
@@ -70,7 +69,7 @@ pub struct EventListenerEntry {
 pub struct EventTarget {
     pub type_id: EventTargetTypeId,
     reflector_: Reflector,
-    handlers: Traceable<RefCell<HashMap<DOMString, Vec<EventListenerEntry>>>>,
+    handlers: RefCell<HashMap<DOMString, Vec<EventListenerEntry>>>,
 }
 
 impl EventTarget {
@@ -78,19 +77,19 @@ impl EventTarget {
         EventTarget {
             type_id: type_id,
             reflector_: Reflector::new(),
-            handlers: Traceable::new(RefCell::new(HashMap::new())),
+            handlers: RefCell::new(HashMap::new()),
         }
     }
 
     pub fn get_listeners(&self, type_: &str) -> Option<Vec<EventListener>> {
-        self.handlers.deref().borrow().find_equiv(&type_).map(|listeners| {
+        self.handlers.borrow().find_equiv(&type_).map(|listeners| {
             listeners.iter().map(|entry| entry.listener.get_listener()).collect()
         })
     }
 
     pub fn get_listeners_for(&self, type_: &str, desired_phase: ListenerPhase)
         -> Option<Vec<EventListener>> {
-        self.handlers.deref().borrow().find_equiv(&type_).map(|listeners| {
+        self.handlers.borrow().find_equiv(&type_).map(|listeners| {
             let filtered = listeners.iter().filter(|entry| entry.phase == desired_phase);
             filtered.map(|entry| entry.listener.get_listener()).collect()
         })
@@ -131,7 +130,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     fn set_inline_event_listener(self,
                                  ty: DOMString,
                                  listener: Option<EventListener>) {
-        let mut handlers = self.handlers.deref().borrow_mut();
+        let mut handlers = self.handlers.borrow_mut();
         let entries = handlers.find_or_insert_with(ty, |_| vec!());
         let idx = entries.iter().position(|&entry| {
             match entry.listener {
@@ -161,7 +160,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     }
 
     fn get_inline_event_listener(self, ty: DOMString) -> Option<EventListener> {
-        let handlers = self.handlers.deref().borrow();
+        let handlers = self.handlers.borrow();
         let entries = handlers.find(&ty);
         entries.and_then(|entries| entries.iter().find(|entry| {
             match entry.listener {
@@ -224,7 +223,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     }
 
     fn has_handlers(self) -> bool {
-        !self.handlers.deref().borrow().is_empty()
+        !self.handlers.borrow().is_empty()
     }
 }
 
@@ -235,7 +234,7 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
                         capture: bool) {
         match listener {
             Some(listener) => {
-                let mut handlers = self.handlers.deref().borrow_mut();
+                let mut handlers = self.handlers.borrow_mut();
                 let entry = handlers.find_or_insert_with(ty, |_| vec!());
                 let phase = if capture { Capturing } else { Bubbling };
                 let new_entry = EventListenerEntry {
@@ -256,7 +255,7 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
                            capture: bool) {
         match listener {
             Some(listener) => {
-                let mut handlers = self.handlers.deref().borrow_mut();
+                let mut handlers = self.handlers.borrow_mut();
                 let mut entry = handlers.find_mut(&ty);
                 for entry in entry.iter_mut() {
                     let phase = if capture { Capturing } else { Bubbling };