Renaming AutoCancel to CancelOnDrop, also reverting most changes

Author: Pauan

src/lib.rs

@@ -166,7 +166,7 @@ pub use webcore::number::Number;
 pub use webcore::object::Object;
 pub use webcore::array::Array;
 pub use webcore::symbol::Symbol;
-pub use webcore::cancel::{Cancel, AutoCancel};
+pub use webcore::cancel::{Cancel, CancelOnDrop};
 
 pub use webcore::unsafe_typed_array::UnsafeTypedArray;
 pub use webcore::once::Once;
@@ -208,7 +208,7 @@ pub mod web {
     };
     pub use webapi::cross_origin_setting::CrossOriginSetting;
     pub use webapi::date::Date;
-    pub use webapi::event_target::{IEventTarget, EventTarget, EventListener};
+    pub use webapi::event_target::{IEventTarget, EventTarget, EventListenerHandle};
     pub use webapi::window::RequestAnimationFrameHandle;
     pub use webapi::node::{INode, Node, CloneKind};
     pub use webapi::element::{IElement, Element};

src/webapi/event_target.rs

@@ -4,29 +4,28 @@ use webcore::value::Reference;
 use webcore::try_from::TryInto;
 use webcore::reference_type::ReferenceType;
 use webapi::event::{ConcreteEvent, IEvent};
-use webcore::cancel::{Cancel, AutoCancel};
 use private::TODO;
 
 /// A handle to a particular event listener.
-pub struct EventListener {
+pub struct EventListenerHandle {
     event_type: &'static str,
     reference: Reference,
     listener_reference: Reference
 }
 
-impl fmt::Debug for EventListener {
+impl fmt::Debug for EventListenerHandle {
     fn fmt( &self, formatter: &mut fmt::Formatter ) -> fmt::Result {
-        write!( formatter, "EventListener {{ event_type: {}, reference: {:?} }}", self.event_type, self.reference )
+        write!( formatter, "EventListenerHandle {{ event_type: {}, reference: {:?} }}", self.event_type, self.reference )
     }
 }
 
-impl Cancel for EventListener {
+impl EventListenerHandle {
     /// Removes the listener from the [IEventTarget](trait.IEventTarget.html) on
     /// which it was previously registered.
     ///
     /// [(JavaScript docs)](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener)
     // https://dom.spec.whatwg.org/#ref-for-dom-eventtarget-removeeventlistener%E2%91%A0
-    fn cancel( &mut self ) {
+    pub fn remove( self ) {
         js! { @(no_return)
             var listener = @{&self.listener_reference};
             @{&self.reference}.removeEventListener( @{self.event_type}, listener );
@@ -46,7 +45,7 @@ pub trait IEventTarget: ReferenceType {
     ///
     /// [(JavaScript docs)](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
     // https://dom.spec.whatwg.org/#ref-for-dom-eventtarget-addeventlistener%E2%91%A0
-    fn add_event_listener< T, F >( &self, listener: F ) -> AutoCancel< EventListener >
+    fn add_event_listener< T, F >( &self, listener: F ) -> EventListenerHandle
         where T: ConcreteEvent, F: FnMut( T ) + 'static
     {
         let reference = self.as_ref();
@@ -57,11 +56,11 @@ pub trait IEventTarget: ReferenceType {
             return listener;
         }.try_into().unwrap();
 
-        AutoCancel::new( EventListener {
+        EventListenerHandle {
             event_type: T::EVENT_TYPE,
             reference: reference.clone(),
             listener_reference: listener_reference
-        } )
+        }
     }
 
     /// Dispatches an `Event` at this `EventTarget`, invoking the affected event listeners in the

src/webapi/mutation_observer.rs

@@ -3,7 +3,6 @@ use webcore::value::{Reference, Value, ConversionError};
 use webapi::node_list::NodeList;
 use webcore::try_from::{TryFrom, TryInto};
 use webapi::node::{INode, Node};
-use webcore::cancel::{Cancel, AutoCancel};
 use private::TODO;
 
 /// Provides a way to receive notifications about changes to the DOM.
@@ -63,17 +62,17 @@ impl MutationObserver {
     ///
     /// [(JavaScript docs)](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver#Constructor)
     // https://dom.spec.whatwg.org/#ref-for-dom-mutationobserver-mutationobserver
-    pub fn new< F >( callback: F ) -> AutoCancel< MutationObserverHandle >
+    pub fn new< F >( callback: F ) -> MutationObserverHandle
         where F: FnMut( Vec< MutationRecord >, Self ) + 'static {
         let callback_reference: Reference = js! ( return @{callback}; ).try_into().unwrap();
 
-        AutoCancel::new( MutationObserverHandle {
+        MutationObserverHandle {
             callback_reference: callback_reference.clone(),
 
             mutation_observer: js! (
                 return new MutationObserver( @{callback_reference} );
             ).try_into().unwrap(),
-        } )
+        }
     }
 
     /// Starts observing changes to the `target`.
@@ -160,7 +159,7 @@ impl MutationObserver {
 /// This is created by the [`MutationObserver::new`](struct.MutationObserver.html#method.new) method, and
 /// it can use the same methods as [`MutationObserver`](struct.MutationObserver.html).
 ///
-/// When the `MutationObserverHandle` is cancelled, the [`disconnect`](#method.disconnect)
+/// When the `MutationObserverHandle` is dropped, the [`disconnect`](#method.disconnect)
 /// method will automatically be called.
 #[ derive( Debug ) ]
 pub struct MutationObserverHandle {
@@ -177,9 +176,9 @@ impl std::ops::Deref for MutationObserverHandle {
     }
 }
 
-impl Cancel for MutationObserverHandle {
+impl Drop for MutationObserverHandle {
     #[inline]
-    fn cancel( &mut self ) {
+    fn drop( &mut self ) {
         self.disconnect();
 
         js! { @(no_return)

src/webapi/window.rs

@@ -7,17 +7,16 @@ use webapi::location::Location;
 use webapi::history::History;
 use webcore::once::Once;
 use webcore::value::Value;
-use webcore::cancel::{Cancel, AutoCancel};
 
 /// A handle to a pending animation frame request.
 #[derive(Debug)]
 pub struct RequestAnimationFrameHandle(Value);
 
-impl Cancel for RequestAnimationFrameHandle {
+impl RequestAnimationFrameHandle {
     /// Cancels an animation frame request.
     ///
     /// [(Javascript docs)](https://developer.mozilla.org/en-US/docs/Web/API/Window/cancelAnimationFrame)
-    fn cancel( &mut self ) {
+    pub fn cancel( self ) {
         js! { @(no_return)
             var val = @{&self.0};
             val.window.cancelAnimationFrame(val.request);
@@ -124,13 +123,13 @@ impl Window {
     ///
     /// [(JavaScript docs)](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame)
     // https://html.spec.whatwg.org/#the-window-object:dom-window-requestanimationframe
-    pub fn request_animation_frame< F: FnOnce(f64) + 'static>( &self, callback: F) -> AutoCancel< RequestAnimationFrameHandle > {
+    pub fn request_animation_frame< F: FnOnce(f64) + 'static>( &self, callback: F) -> RequestAnimationFrameHandle {
         let values: Value = js!{
             var callback = @{Once(callback)};
             var request = @{self}.requestAnimationFrame(callback);
             return { request: request, callback: callback, window: @{self} };
         };
-        AutoCancel::new( RequestAnimationFrameHandle(values) )
+        RequestAnimationFrameHandle(values)
     }
 
     /// Returns the global [History](struct.History.html) object, which provides methods to

src/webcore/cancel.rs

@@ -11,33 +11,36 @@ pub trait Cancel {
 ///
 #[must_use = "
 
-     The AutoCancel is unused, which causes it to be immediately cancelled.
+     The CancelOnDrop is unused, which causes it to be immediately cancelled.
      You probably don't want that to happen.
 
      How to fix this:
-       1) Store the AutoCancel in a variable or data structure
-       2) Use .leak() which will cause it to not be cancelled (this *will* leak memory!)
+       1) Store the CancelOnDrop in a variable or data structure.
+       2) Use .leak() which will cause it to not be cancelled (this *will* leak memory!).
 
      See the documentation for more details.
 "]
 #[derive(Debug)]
-pub struct AutoCancel< A: Cancel >( Option< A > );
+pub struct CancelOnDrop< A: Cancel >( Option< A > );
 
-impl< A: Cancel > AutoCancel< A > {
+impl< A: Cancel > CancelOnDrop< A > {
     ///
     #[inline]
     pub fn new( canceler: A ) -> Self {
-        AutoCancel( Some( canceler ) )
+        CancelOnDrop( Some( canceler ) )
     }
 
     ///
     #[inline]
     pub fn leak( mut self ) -> A {
-        self.0.take().unwrap()
+        match self.0.take() {
+            Some(value) => value,
+            None => unreachable!(),
+        }
     }
 }
 
-impl< A: Cancel > Drop for AutoCancel< A > {
+impl< A: Cancel > Drop for CancelOnDrop< A > {
     #[inline]
     fn drop( &mut self ) {
         match self.0 {
@@ -47,7 +50,7 @@ impl< A: Cancel > Drop for AutoCancel< A > {
     }
 }
 
-impl< A: Cancel > Deref for AutoCancel< A > {
+impl< A: Cancel > Deref for CancelOnDrop< A > {
     type Target = A;
 
     #[inline]
@@ -59,7 +62,7 @@ impl< A: Cancel > Deref for AutoCancel< A > {
     }
 }
 
-impl< A: Cancel > DerefMut for AutoCancel< A > {
+impl< A: Cancel > DerefMut for CancelOnDrop< A > {
     #[inline]
     fn deref_mut( &mut self ) -> &mut Self::Target {
         match self.0 {
@@ -72,13 +75,13 @@ impl< A: Cancel > DerefMut for AutoCancel< A > {
 
 #[cfg(test)]
 mod tests {
-    use super::{Cancel, AutoCancel};
+    use super::{Cancel, CancelOnDrop};
 
     struct Foo( bool );
 
     impl Foo {
-        fn new() -> AutoCancel< Foo > {
-            AutoCancel::new( Foo( false ) )
+        fn new() -> CancelOnDrop< Foo > {
+            CancelOnDrop::new( Foo( false ) )
         }
     }
 

src/webcore/promise.rs

@@ -2,7 +2,7 @@ use std;
 use webcore::once::Once;
 use webcore::value::{Value, Reference};
 use webcore::try_from::{TryInto, TryFrom};
-use webcore::cancel::{Cancel, AutoCancel};
+use webcore::cancel::{Cancel, CancelOnDrop};
 
 #[cfg(feature = "futures")]
 use futures::unsync::oneshot::channel;
@@ -105,7 +105,7 @@ impl Promise {
     /// no longer interested in the `Promise`'s result.
     ///
     /// But if you *are* interested in the `Promise`'s result, then you either need to make sure to keep the handle
-    /// alive until after the callback is called, or you need to use the [`leak`](struct.AutoCancel.html#method.leak) method.
+    /// alive until after the callback is called, or you need to use the [`leak`](struct.CancelOnDrop.html#method.leak) method.
     ///
     /// Cancelling the [`DoneHandle`](struct.DoneHandle.html) does ***not*** cancel the `Promise`, because promises
     /// do not support cancellation.
@@ -123,7 +123,7 @@ impl Promise {
     ///
     /// [(JavaScript docs)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then)
     // https://www.ecma-international.org/ecma-262/6.0/#sec-performpromisethen
-    pub fn done< A, B, F >( &self, callback: F ) -> AutoCancel< DoneHandle >
+    pub fn done< A, B, F >( &self, callback: F ) -> CancelOnDrop< DoneHandle >
         where A: TryFrom< Value >,
               B: TryFrom< Value >,
               // TODO these Debug constraints are only needed because of unwrap
@@ -166,7 +166,7 @@ impl Promise {
             return done;
         );
 
-        AutoCancel::new( DoneHandle {
+        CancelOnDrop::new( DoneHandle {
             callback,
             done,
         } )

src/webcore/promise_future.rs

@@ -5,7 +5,7 @@ use webapi::error;
 use futures::{Future, Poll, Async};
 use futures::unsync::oneshot::Receiver;
 use webcore::promise_executor::spawn;
-use webcore::cancel::AutoCancel;
+use webcore::cancel::CancelOnDrop;
 use super::promise::{Promise, DoneHandle};
 
 
@@ -22,7 +22,7 @@ use super::promise::{Promise, DoneHandle};
 /// ```
 pub struct PromiseFuture< Value, Error = error::Error > {
     pub(crate) future: Receiver< Result< Value, Error > >,
-    pub(crate) _done_handle: AutoCancel< DoneHandle >,
+    pub(crate) _done_handle: CancelOnDrop< DoneHandle >,
 }
 
 impl PromiseFuture< (), () > {