Merge pull request #3433 from zwarich/jsref-self-helpers

More progress in the &JSRef -> JSRef conversion

1 files changed, 58 insertions, 58 deletions

diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index 3c3f79d3da3..631dfbec858 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -202,51 +202,51 @@ pub fn base64_atob(atob: DOMString) -> Fallible<DOMString> {
 
 
 impl<'a> WindowMethods for JSRef<'a, Window> {
-    fn Alert(&self, s: DOMString) {
+    fn Alert(self, s: DOMString) {
         // Right now, just print to the console
         println!("ALERT: {:s}", s);
     }
 
-    fn Close(&self) {
+    fn Close(self) {
         let ScriptChan(ref chan) = self.script_chan;
         chan.send(ExitWindowMsg(self.page.id.clone()));
     }
 
-    fn Document(&self) -> Temporary<Document> {
+    fn Document(self) -> Temporary<Document> {
         let frame = self.page().frame();
         Temporary::new(frame.get_ref().document.clone())
     }
 
-    fn Location(&self) -> Temporary<Location> {
+    fn Location(self) -> Temporary<Location> {
         if self.location.get().is_none() {
             let page = self.deref().page.clone();
-            let location = Location::new(*self, page);
+            let location = Location::new(self, page);
             self.location.assign(Some(location));
         }
         Temporary::new(self.location.get().get_ref().clone())
     }
 
-    fn Console(&self) -> Temporary<Console> {
+    fn Console(self) -> Temporary<Console> {
         if self.console.get().is_none() {
-            let console = Console::new(&global::Window(*self));
+            let console = Console::new(&global::Window(self));
             self.console.assign(Some(console));
         }
         Temporary::new(self.console.get().get_ref().clone())
     }
 
-    fn Navigator(&self) -> Temporary<Navigator> {
+    fn Navigator(self) -> Temporary<Navigator> {
         if self.navigator.get().is_none() {
-            let navigator = Navigator::new(*self);
+            let navigator = Navigator::new(self);
             self.navigator.assign(Some(navigator));
         }
         Temporary::new(self.navigator.get().get_ref().clone())
     }
 
-    fn SetTimeout(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
+    fn SetTimeout(self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
         self.set_timeout_or_interval(callback, timeout, false)
     }
 
-    fn ClearTimeout(&self, handle: i32) {
+    fn ClearTimeout(self, handle: i32) {
         let mut timers = self.active_timers.deref().borrow_mut();
         let mut timer_handle = timers.pop(&TimerId(handle));
         match timer_handle {
@@ -256,103 +256,103 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
         timers.remove(&TimerId(handle));
     }
 
-    fn SetInterval(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
+    fn SetInterval(self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
         self.set_timeout_or_interval(callback, timeout, true)
     }
 
-    fn ClearInterval(&self, handle: i32) {
+    fn ClearInterval(self, handle: i32) {
         self.ClearTimeout(handle);
     }
 
-    fn Window(&self) -> Temporary<Window> {
-        Temporary::from_rooted(*self)
+    fn Window(self) -> Temporary<Window> {
+        Temporary::from_rooted(self)
     }
 
-    fn Self(&self) -> Temporary<Window> {
+    fn Self(self) -> Temporary<Window> {
         self.Window()
     }
 
     // http://www.whatwg.org/html/#dom-frames
-    fn Frames(&self) -> Temporary<Window> {
+    fn Frames(self) -> Temporary<Window> {
         self.Window()
     }
 
-    fn Parent(&self) -> Temporary<Window> {
+    fn Parent(self) -> Temporary<Window> {
         //TODO - Once we support iframes correctly this needs to return the parent frame
         self.Window()
     }
 
-    fn Performance(&self) -> Temporary<Performance> {
+    fn Performance(self) -> Temporary<Performance> {
         if self.performance.get().is_none() {
-            let performance = Performance::new(*self);
+            let performance = Performance::new(self);
             self.performance.assign(Some(performance));
         }
         Temporary::new(self.performance.get().get_ref().clone())
     }
 
-    fn GetOnclick(&self) -> Option<EventHandlerNonNull> {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn GetOnclick(self) -> Option<EventHandlerNonNull> {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.get_event_handler_common("click")
     }
 
-    fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn SetOnclick(self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("click", listener)
     }
 
-    fn GetOnload(&self) -> Option<EventHandlerNonNull> {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn GetOnload(self) -> Option<EventHandlerNonNull> {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.get_event_handler_common("load")
     }
 
-    fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn SetOnload(self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("load", listener)
     }
 
-    fn GetOnunload(&self) -> Option<EventHandlerNonNull> {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn GetOnunload(self) -> Option<EventHandlerNonNull> {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.get_event_handler_common("unload")
     }
 
-    fn SetOnunload(&self, listener: Option<EventHandlerNonNull>) {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn SetOnunload(self, listener: Option<EventHandlerNonNull>) {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("unload", listener)
     }
 
-    fn GetOnerror(&self) -> Option<OnErrorEventHandlerNonNull> {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn GetOnerror(self) -> Option<OnErrorEventHandlerNonNull> {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.get_event_handler_common("error")
     }
 
-    fn SetOnerror(&self, listener: Option<OnErrorEventHandlerNonNull>) {
-        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
+    fn SetOnerror(self, listener: Option<OnErrorEventHandlerNonNull>) {
+        let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
         eventtarget.set_event_handler_common("error", listener)
     }
 
-    fn Screen(&self) -> Temporary<Screen> {
+    fn Screen(self) -> Temporary<Screen> {
         if self.screen.get().is_none() {
-            let screen = Screen::new(*self);
+            let screen = Screen::new(self);
             self.screen.assign(Some(screen));
         }
         Temporary::new(self.screen.get().get_ref().clone())
     }
 
-    fn Debug(&self, message: DOMString) {
+    fn Debug(self, message: DOMString) {
         debug!("{:s}", message);
     }
 
-    fn Gc(&self) {
+    fn Gc(self) {
         unsafe {
             JS_GC(JS_GetRuntime(self.get_cx()));
         }
     }
 
-    fn Btoa(&self, btoa: DOMString) -> Fallible<DOMString> {
+    fn Btoa(self, btoa: DOMString) -> Fallible<DOMString> {
         base64_btoa(btoa)
     }
 
-    fn Atob(&self, atob: DOMString) -> Fallible<DOMString> {
+    fn Atob(self, atob: DOMString) -> Fallible<DOMString> {
         base64_atob(atob)
     }
 }
@@ -364,21 +364,21 @@ impl Reflectable for Window {
 }
 
 pub trait WindowHelpers {
-    fn damage_and_reflow(&self, damage: DocumentDamageLevel);
-    fn flush_layout(&self, goal: ReflowGoal);
-    fn wait_until_safe_to_modify_dom(&self);
-    fn init_browser_context(&self, doc: JSRef<Document>);
-    fn load_url(&self, href: DOMString);
-    fn handle_fire_timer(&self, timer_id: TimerId, cx: *mut JSContext);
-    fn evaluate_js_with_result(&self, code: &str) -> JSVal;
+    fn damage_and_reflow(self, damage: DocumentDamageLevel);
+    fn flush_layout(self, goal: ReflowGoal);
+    fn wait_until_safe_to_modify_dom(self);
+    fn init_browser_context(self, doc: JSRef<Document>);
+    fn load_url(self, href: DOMString);
+    fn handle_fire_timer(self, timer_id: TimerId, cx: *mut JSContext);
+    fn evaluate_js_with_result(self, code: &str) -> JSVal;
 }
 
 trait PrivateWindowHelpers {
-    fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
+    fn set_timeout_or_interval(self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
 }
 
 impl<'a> WindowHelpers for JSRef<'a, Window> {
-    fn evaluate_js_with_result(&self, code: &str) -> JSVal {
+    fn evaluate_js_with_result(self, code: &str) -> JSVal {
         let global = self.reflector().get_jsobject();
         let code: Vec<u16> = code.as_slice().utf16_units().collect();
         let mut rval = UndefinedValue();
@@ -397,27 +397,27 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
         })
     }
 
-    fn damage_and_reflow(&self, damage: DocumentDamageLevel) {
+    fn damage_and_reflow(self, damage: DocumentDamageLevel) {
         self.page().damage(damage);
         self.page().avoided_reflows.set(self.page().avoided_reflows.get() + 1);
     }
 
-    fn flush_layout(&self, goal: ReflowGoal) {
+    fn flush_layout(self, goal: ReflowGoal) {
         self.page().flush_layout(goal);
     }
 
-    fn wait_until_safe_to_modify_dom(&self) {
+    fn wait_until_safe_to_modify_dom(self) {
         // FIXME: This disables concurrent layout while we are modifying the DOM, since
         //        our current architecture is entirely unsafe in the presence of races.
         self.page().join_layout();
     }
 
-    fn init_browser_context(&self, doc: JSRef<Document>) {
+    fn init_browser_context(self, doc: JSRef<Document>) {
         *self.browser_context.deref().borrow_mut() = Some(BrowserContext::new(doc));
     }
 
     /// Commence a new URL load which will either replace this window or scroll to a fragment.
-    fn load_url(&self, href: DOMString) {
+    fn load_url(self, href: DOMString) {
         let base_url = self.page().get_url();
         debug!("current page url is {:?}", base_url);
         let url = UrlParser::new().base_url(&base_url).parse(href.as_slice());
@@ -431,7 +431,7 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
         }
     }
 
-    fn handle_fire_timer(&self, timer_id: TimerId, cx: *mut JSContext) {
+    fn handle_fire_timer(self, timer_id: TimerId, cx: *mut JSContext) {
         let this_value = self.reflector().get_jsobject();
 
         let data = match self.active_timers.deref().borrow().find(&timer_id) {
@@ -455,7 +455,7 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
 }
 
 impl<'a> PrivateWindowHelpers for JSRef<'a, Window> {
-    fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
+    fn set_timeout_or_interval(self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
         let timeout = cmp::max(0, timeout) as u64;
         let handle = self.next_timer_handle.deref().get();
         self.next_timer_handle.deref().set(handle + 1);