Remove helper traits

components/script/devtools.rs

@@ -13,9 +13,7 @@ use dom::bindings::conversions::FromJSValConvertible;
 use dom::bindings::conversions::jsstring_to_str;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
-use dom::document::DocumentHelpers;
-use dom::node::{Node, NodeHelpers};
-use dom::window::{WindowHelpers, ScriptHelpers};
+use dom::node::Node;
 use ipc_channel::ipc::IpcSender;
 use js::jsapi::{ObjectClassName, RootedObject, RootedValue};
 use js::jsval::UndefinedValue;

components/script/dom/activation.rs

@@ -4,8 +4,8 @@
 
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
-use dom::element::{Element, ActivationElementHelpers};
-use dom::event::{Event, EventHelpers, EventBubbles, EventCancelable};
+use dom::element::Element;
+use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
 use dom::mouseevent::MouseEvent;
 use dom::node::window_from_node;

components/script/dom/attr.rs

@@ -9,7 +9,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap};
 use dom::bindings::js::{Root, RootedReference, LayoutJS};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
-use dom::element::{Element, AttributeHandlers};
+use dom::element::Element;
 use dom::virtualmethods::vtable_for;
 use dom::window::Window;
 
@@ -234,17 +234,9 @@ impl<'a> AttrMethods for &'a Attr {
     }
 }
 
-pub trait AttrHelpers<'a> {
-    fn set_value(self, set_type: AttrSettingType, value: AttrValue, owner: &Element);
-    fn value(self) -> Ref<'a, AttrValue>;
-    fn local_name(self) -> &'a Atom;
-    fn set_owner(self, owner: Option<&Element>);
-    fn owner(self) -> Option<Root<Element>>;
-    fn summarize(self) -> AttrInfo;
-}
 
-impl<'a> AttrHelpers<'a> for &'a Attr {
-    fn set_value(self, set_type: AttrSettingType, value: AttrValue, owner: &Element) {
+impl Attr {
+    pub fn set_value(&self, set_type: AttrSettingType, value: AttrValue, owner: &Element) {
         assert!(Some(owner) == self.owner().r());
 
         let node = NodeCast::from_ref(owner);
@@ -263,17 +255,17 @@ impl<'a> AttrHelpers<'a> for &'a Attr {
         }
     }
 
-    fn value(self) -> Ref<'a, AttrValue> {
+    pub fn value(&self) -> Ref<AttrValue> {
         self.value.borrow()
     }
 
-    fn local_name(self) -> &'a Atom {
+    pub fn local_name(&self) -> &Atom {
         &self.local_name
     }
 
     /// Sets the owner element. Should be called after the attribute is added
     /// or removed from its older parent.
-    fn set_owner(self, owner: Option<&Element>) {
+    pub fn set_owner(&self, owner: Option<&Element>) {
         let ref ns = self.namespace;
         match (self.owner().r(), owner) {
             (None, Some(new)) => {
@@ -289,11 +281,11 @@ impl<'a> AttrHelpers<'a> for &'a Attr {
         self.owner.set(owner.map(JS::from_ref))
     }
 
-    fn owner(self) -> Option<Root<Element>> {
+    pub fn owner(&self) -> Option<Root<Element>> {
         self.owner.get().map(Root::from_rooted)
     }
 
-    fn summarize(self) -> AttrInfo {
+    pub fn summarize(&self) -> AttrInfo {
         let Namespace(ref ns) = self.namespace;
         AttrInfo {
             namespace: (**ns).to_owned(),

components/script/dom/bindings/global.rs

@@ -12,9 +12,8 @@ use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::conversions::native_from_reflector_jsmanaged;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::utils::{Reflectable, Reflector};
-use dom::document::DocumentHelpers;
-use dom::window::{self, WindowHelpers, ScriptHelpers};
-use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
+use dom::window::{self, ScriptHelpers};
+use dom::workerglobalscope::WorkerGlobalScope;
 use script_task::{ScriptChan, ScriptPort, CommonScriptMsg, ScriptTask};
 
 use msg::constellation_msg::{ConstellationChan, PipelineId, WorkerId};

components/script/dom/blob.rs

@@ -79,12 +79,9 @@ impl Blob {
     }
 }
 
-pub trait BlobHelpers {
-    fn read_out_buffer(self, send: Sender<Vec<u8>>);
-}
 
-impl<'a> BlobHelpers for &'a Blob {
-    fn read_out_buffer(self, send: Sender<Vec<u8>>) {
+impl Blob {
+    pub fn read_out_buffer(&self, send: Sender<Vec<u8>>) {
         send.send(self.bytes.clone().unwrap_or(vec![])).unwrap();
     }
 }

components/script/dom/browsercontext.rs

@@ -8,10 +8,9 @@ use dom::bindings::js::{JS, Root};
 use dom::bindings::proxyhandler::{get_property_descriptor, fill_property_descriptor};
 use dom::bindings::utils::get_array_index_from_id;
 use dom::bindings::utils::{Reflectable, WindowProxyHandler};
-use dom::document::{Document, DocumentHelpers};
+use dom::document::Document;
 use dom::element::Element;
 use dom::window::Window;
-use dom::window::WindowHelpers;
 
 use js::glue::{GetProxyPrivate};
 use js::glue::{WrapperNew, CreateWrapperProxyHandler, ProxyTraps};

components/script/dom/canvasrenderingcontext2d.rs

@@ -17,11 +17,11 @@ use dom::bindings::num::Finite;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::canvasgradient::{CanvasGradient, CanvasGradientStyle, ToFillOrStrokeStyle};
 use dom::canvaspattern::CanvasPattern;
+use dom::htmlcanvaselement::HTMLCanvasElement;
 use dom::htmlcanvaselement::utils as canvas_utils;
-use dom::htmlcanvaselement::{HTMLCanvasElement, HTMLCanvasElementHelpers};
-use dom::htmlimageelement::{HTMLImageElement, HTMLImageElementHelpers};
-use dom::imagedata::{ImageData, ImageDataHelpers};
-use dom::node::{window_from_node, NodeHelpers, NodeDamage};
+use dom::htmlimageelement::HTMLImageElement;
+use dom::imagedata::ImageData;
+use dom::node::{window_from_node, NodeDamage};
 
 use msg::constellation_msg::Msg as ConstellationMsg;
 use net_traits::image::base::PixelFormat;
@@ -409,16 +409,12 @@ impl CanvasRenderingContext2D {
     }
 }
 
-pub trait CanvasRenderingContext2DHelpers {
-    fn get_renderer_id(self) -> usize;
-    fn get_ipc_renderer(self) -> IpcSender<CanvasMsg>;
-}
 
-impl<'a> CanvasRenderingContext2DHelpers for &'a CanvasRenderingContext2D {
-    fn get_renderer_id(self) -> usize {
+impl CanvasRenderingContext2D {
+    pub fn get_renderer_id(&self) -> usize {
         self.renderer_id
     }
-    fn get_ipc_renderer(self) -> IpcSender<CanvasMsg> {
+    pub fn get_ipc_renderer(&self) -> IpcSender<CanvasMsg> {
         self.ipc_renderer.clone()
     }
 }

components/script/dom/characterdata.rs

@@ -15,7 +15,7 @@ use dom::bindings::js::{LayoutJS, Root};
 use dom::document::Document;
 use dom::element::Element;
 use dom::eventtarget::{EventTarget, EventTargetTypeId};
-use dom::node::{Node, NodeHelpers, NodeTypeId};
+use dom::node::{Node, NodeTypeId};
 
 use util::str::{DOMString, slice_chars};
 
@@ -157,18 +157,14 @@ pub enum CharacterDataTypeId {
     ProcessingInstruction,
 }
 
-pub trait CharacterDataHelpers<'a> {
-    fn data(self) -> Ref<'a, DOMString>;
-    fn append_data(self, data: &str);
-}
 
-impl<'a> CharacterDataHelpers<'a> for &'a CharacterData {
+impl CharacterData {
     #[inline]
-    fn data(self) -> Ref<'a, DOMString> {
+    pub fn data(&self) -> Ref<DOMString> {
         self.data.borrow()
     }
     #[inline]
-    fn append_data(self, data: &str) {
+    pub fn append_data(&self, data: &str) {
         self.data.borrow_mut().push_str(data)
     }
 }

components/script/dom/console.rs

@@ -8,7 +8,6 @@ use dom::bindings::codegen::Bindings::ConsoleBinding::ConsoleMethods;
 use dom::bindings::global::{GlobalRef, GlobalField};
 use dom::bindings::js::Root;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
-use dom::window::WindowHelpers;
 use util::str::DOMString;
 
 // https://developer.mozilla.org/en-US/docs/Web/API/Console

components/script/dom/cssstyledeclaration.rs

@@ -8,10 +8,9 @@ use dom::bindings::error::{Error, ErrorResult, Fallible};
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
-use dom::document::DocumentHelpers;
-use dom::element::{ElementHelpers, StylePriority, Element};
-use dom::node::{window_from_node, document_from_node, NodeDamage, NodeHelpers};
-use dom::window::{Window, WindowHelpers};
+use dom::element::{StylePriority, Element};
+use dom::node::{window_from_node, document_from_node, NodeDamage};
+use dom::window::Window;
 use selectors::parser::PseudoElement;
 use string_cache::Atom;
 use style::properties::PropertyDeclaration;

components/script/dom/dedicatedworkerglobalscope.rs

@@ -6,7 +6,6 @@ use devtools;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding;
 use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding::DedicatedWorkerGlobalScopeMethods;
-use dom::bindings::codegen::Bindings::ErrorEventBinding::ErrorEventMethods;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::InheritTypes::DedicatedWorkerGlobalScopeDerived;
 use dom::bindings::codegen::InheritTypes::{EventTargetCast, WorkerGlobalScopeCast};
@@ -16,11 +15,10 @@ use dom::bindings::js::{RootCollection, Root};
 use dom::bindings::refcounted::LiveDOMReferences;
 use dom::bindings::structuredclone::StructuredCloneData;
 use dom::bindings::utils::Reflectable;
-use dom::errorevent::ErrorEvent;
-use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
+use dom::eventtarget::{EventTarget, EventTargetTypeId};
 use dom::messageevent::MessageEvent;
-use dom::worker::{TrustedWorkerAddress, WorkerMessageHandler, WorkerEventHandler, WorkerErrorHandler};
-use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
+use dom::worker::{TrustedWorkerAddress, WorkerMessageHandler, WorkerEventHandler};
+use dom::workerglobalscope::WorkerGlobalScope;
 use dom::workerglobalscope::{WorkerGlobalScopeTypeId, WorkerGlobalScopeInit};
 use script_task::{ScriptTask, ScriptChan, TimerSource, ScriptPort, StackRootTLS, CommonScriptMsg};
 
@@ -245,26 +243,20 @@ impl DedicatedWorkerGlobalScope {
     }
 }
 
-pub trait DedicatedWorkerGlobalScopeHelpers {
-    fn script_chan(self) -> Box<ScriptChan + Send>;
-    fn pipeline(self) -> PipelineId;
-    fn new_script_pair(self) -> (Box<ScriptChan + Send>, Box<ScriptPort + Send>);
-    fn process_event(self, msg: CommonScriptMsg);
-}
 
-impl<'a> DedicatedWorkerGlobalScopeHelpers for &'a DedicatedWorkerGlobalScope {
-    fn script_chan(self) -> Box<ScriptChan + Send> {
+impl DedicatedWorkerGlobalScope {
+    pub fn script_chan(&self) -> Box<ScriptChan + Send> {
         box WorkerThreadWorkerChan {
             sender: self.own_sender.clone(),
             worker: self.worker.borrow().as_ref().unwrap().clone(),
         }
     }
 
-    fn pipeline(self) -> PipelineId {
+    pub fn pipeline(&self) -> PipelineId {
         self.id
     }
 
-    fn new_script_pair(self) -> (Box<ScriptChan + Send>, Box<ScriptPort + Send>) {
+    pub fn new_script_pair(&self) -> (Box<ScriptChan + Send>, Box<ScriptPort + Send>) {
         let (tx, rx) = channel();
         let chan = box SendableWorkerScriptChan {
             sender: tx,
@@ -273,21 +265,15 @@ impl<'a> DedicatedWorkerGlobalScopeHelpers for &'a DedicatedWorkerGlobalScope {
         (chan, box rx)
     }
 
-    fn process_event(self, msg: CommonScriptMsg) {
+    pub fn process_event(&self, msg: CommonScriptMsg) {
         self.handle_script_event(WorkerScriptMsg::Common(msg));
     }
 }
 
-trait PrivateDedicatedWorkerGlobalScopeHelpers {
-    fn handle_script_event(self, msg: WorkerScriptMsg);
-    fn dispatch_error_to_worker(self, &ErrorEvent);
-    fn receive_event(self) -> Result<MixedMessage, RecvError>;
-    fn handle_event(self, event: MixedMessage);
-}
 
-impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for &'a DedicatedWorkerGlobalScope {
+impl DedicatedWorkerGlobalScope {
     #[allow(unsafe_code)]
-    fn receive_event(self) -> Result<MixedMessage, RecvError> {
+    fn receive_event(&self) -> Result<MixedMessage, RecvError> {
         let scope = WorkerGlobalScopeCast::from_ref(self);
         let worker_port = &self.receiver;
         let devtools_port = scope.from_devtools_receiver();
@@ -311,7 +297,7 @@ impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for &'a DedicatedWorkerGlobalS
         }
     }
 
-    fn handle_script_event(self, msg: WorkerScriptMsg) {
+    fn handle_script_event(&self, msg: WorkerScriptMsg) {
         match msg {
             WorkerScriptMsg::DOMMessage(data) => {
                 let scope = WorkerGlobalScopeCast::from_ref(self);
@@ -346,7 +332,7 @@ impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for &'a DedicatedWorkerGlobalS
         }
     }
 
-    fn handle_event(self, event: MixedMessage) {
+    fn handle_event(&self, event: MixedMessage) {
         match event {
             MixedMessage::FromDevtools(msg) => {
                 let global_ref = GlobalRef::Worker(WorkerGlobalScopeCast::from_ref(self));
@@ -366,16 +352,6 @@ impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for &'a DedicatedWorkerGlobalS
             },
         }
     }
-
-    fn dispatch_error_to_worker(self, errorevent: &ErrorEvent) {
-        let msg = errorevent.Message();
-        let file_name = errorevent.Filename();
-        let line_num = errorevent.Lineno();
-        let col_num = errorevent.Colno();
-        let worker = self.worker.borrow().as_ref().unwrap().clone();
-        self.parent_sender.send(CommonScriptMsg::RunnableMsg(
-            box WorkerErrorHandler::new(worker, msg, file_name, line_num, col_num))).unwrap();
- }
 }
 
 impl<'a> DedicatedWorkerGlobalScopeMethods for &'a DedicatedWorkerGlobalScope {