Adding in DoneHandle to clean up memory leaks

Author: Pauan

examples/promise/src/main.rs

@@ -5,7 +5,7 @@ extern crate futures;
 use futures::Future;
 use stdweb::unstable::{TryInto};
 use stdweb::web::error::Error;
-use stdweb::{Null, Promise, PromiseFuture};
+use stdweb::{Null, Promise, PromiseFuture, Value};
 use std::rc::Rc;
 use std::cell::RefCell;
 use futures::{Poll, Async};
@@ -253,6 +253,32 @@ fn test_timeout() {
 }
 
 
+fn test_callback_drop() {
+    let x: Promise = js!( return new Promise( function (yes, no) {} ) ).try_into().unwrap();
+
+    struct Foo( Value );
+
+    impl Drop for Foo {
+        fn drop( &mut self ) {
+            js! { @(no_return)
+                console.log( "Callback dropped" );
+                clearInterval( @{&self.0} );
+            }
+        }
+    }
+
+    let y = Foo( js!(
+        return setInterval( function () {
+            console.log( "Callback drop interval" );
+        }, 1000 );
+    ) );
+
+    x.done( move |_result: Result< (), () >| {
+        let _z = y;
+    } );
+}
+
+
 fn main() {
     stdweb::initialize();
 
@@ -262,6 +288,7 @@ fn main() {
     test_notify();
     test_timeout();
     test_error_conversion();
+    test_callback_drop();
 
     stdweb::event_loop();
 }

src/lib.rs

@@ -131,7 +131,7 @@ pub use webcore::instance_of::InstanceOf;
 pub use webcore::reference_type::ReferenceType;
 pub use webcore::serialization::JsSerialize;
 
-pub use webcore::promise::Promise;
+pub use webcore::promise::{Promise, DoneHandle};
 
 #[cfg(feature = "futures")]
 pub use webcore::promise_future::PromiseFuture;

src/webcore/promise.rs

@@ -10,6 +10,22 @@ use futures::unsync::oneshot::channel;
 use super::promise_future::PromiseFuture;
 
 
+#[derive( Debug, Clone )]
+pub struct DoneHandle {
+    callback: Value,
+    done: Value,
+}
+
+impl Drop for DoneHandle {
+    fn drop( &mut self ) {
+        js! { @(no_return)
+            @{&self.done}[0] = true;
+            @{&self.callback}.drop();
+        }
+    }
+}
+
+
 /// A `Promise` object represents the eventual completion (or failure) of an asynchronous operation, and its resulting value.
 ///
 /// In most situations you shouldn't use this, use [`PromiseFuture`](struct.PromiseFuture.html) instead.
@@ -93,7 +109,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 )
+    pub fn done< A, B, F >( &self, callback: F ) -> DoneHandle
         where A: TryFrom< Value >,
               B: TryFrom< Value >,
               // TODO these Debug constraints are only needed because of unwrap
@@ -106,6 +122,7 @@ impl Promise {
                 // TODO figure out a way to avoid the unwrap
                 let value: A = value.try_into().unwrap();
                 Ok( value )
+
             } else {
                 // TODO figure out a way to avoid the unwrap
                 let value: B = value.try_into().unwrap();
@@ -115,15 +132,29 @@ impl Promise {
             callback( value );
         };
 
-        js! { @(no_return)
-            var callback = @{Once( callback )};
+        let callback = js!( return @{Once( callback )}; );
+
+        let done = js!(
+            var callback = @{&callback};
+            var done = [ false ];
 
             // TODO don't swallow any errors thrown inside callback
             @{self}.then( function ( value ) {
-                callback( value, true );
+                if ( !done[0] ) {
+                    callback( value, true );
+                }
             }, function ( value ) {
-                callback( value, false );
+                if ( !done[0] ) {
+                    callback( value, false );
+                }
             } );
+
+            return done;
+        );
+
+        DoneHandle {
+            callback,
+            done
         }
     }
 
@@ -148,16 +179,15 @@ impl Promise {
 
         let ( sender, receiver ) = channel();
 
-        self.done( |value| {
-            // TODO is this correct ?
-            match sender.send( value ) {
-                Ok( _ ) => {},
-                Err( _ ) => {},
-            };
-        } );
-
         PromiseFuture {
             future: receiver,
+            _done_handle: self.done( |value| {
+                // TODO is this correct ?
+                match sender.send( value ) {
+                    Ok( _ ) => {},
+                    Err( _ ) => {},
+                };
+            } )
         }
     }
 }

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 super::promise::Promise;
+use super::promise::{Promise, DoneHandle};
 
 
 /// This allows you to use a JavaScript [`Promise`](struct.Promise.html) as if it is a Rust [`Future`](https://docs.rs/futures/0.1.18/futures/future/trait.Future.html).
@@ -21,6 +21,7 @@ use super::promise::Promise;
 /// ```
 pub struct PromiseFuture< Value, Error = error::Error > {
     pub(crate) future: Receiver< Result< Value, Error > >,
+    pub(crate) _done_handle: DoneHandle,
 }
 
 impl PromiseFuture< (), () > {