Changes from bitshares repo:

Author: Peter Conrad <cyrano@quisquis.de>
Date:   Thu May 2 16:25:23 2019 +0200

    Moved retain/release to task_base

commit 328ff59e938cbe3af844bd6474069d3608e25d03
Author: Peter Conrad <cyrano@quisquis.de>
Date:   Sat Apr 27 16:29:55 2019 +0200

    Added retain where applicable

commit 147baaea0df5c8b6f3d49395c196f7b99a6073ae
Author: Peter Conrad <cyrano@quisquis.de>
Date:   Fri Apr 26 14:21:11 2019 +0200

    Intermediate

commit 55ad023d9426ce48411cb3490eb9893107ef572e
Author: Dmitry Yakovitsky <d.yakovitsky@aetsoft.by>
Date:   Tue May 14 17:31:28 2019 +0300

    Fix memory leak. Not all tasks are deleted in thread_d dtor.

Author: Mariusz-Trela

libraries/appbase/application.cpp

@@ -376,9 +376,7 @@ void application::finish()
       pre_shutdown( _actual_plugin_name );
       shutdown( _actual_plugin_name );
 
-      fc::promise<void>::ptr quitDone( new fc::promise<void>("Logging thread quit") );
-      my->_logging_thread.quit( quitDone.get() );
-      quitDone->wait();
+      my->_logging_thread.quit();
 
       is_finished = true;
     }

libraries/fc/include/fc/asio.hpp

@@ -101,15 +101,15 @@ namespace asio {
     template<typename AsyncReadStream, typename MutableBufferSequence>
     future<size_t> read_some(AsyncReadStream& s, const MutableBufferSequence& buf)
     {
-      promise<size_t>::ptr completion_promise(new promise<size_t>("fc::asio::async_read_some"));
+      promise<size_t>::ptr completion_promise = promise<size_t>::create("fc::asio::async_read_some");
       s.async_read_some(buf, detail::read_write_handler(completion_promise));
       return completion_promise;//->wait();
     }
 
     template<typename AsyncReadStream>
     future<size_t> read_some(AsyncReadStream& s, char* buffer, size_t length, size_t offset = 0)
     {
-      promise<size_t>::ptr completion_promise(new promise<size_t>("fc::asio::async_read_some"));
+      promise<size_t>::ptr completion_promise = promise<size_t>::create("fc::asio::async_read_some");
       s.async_read_some(boost::asio::buffer(buffer + offset, length), 
                         detail::read_write_handler(completion_promise));
       return completion_promise;//->wait();
@@ -118,7 +118,7 @@ namespace asio {
     template<typename AsyncReadStream>
     future<size_t> read_some(AsyncReadStream& s, const std::shared_ptr<char>& buffer, size_t length, size_t offset)
     {
-      promise<size_t>::ptr completion_promise(new promise<size_t>("fc::asio::async_read_some"));
+      promise<size_t>::ptr completion_promise = promise<size_t>::create("fc::asio::async_read_some");
       s.async_read_some(boost::asio::buffer(buffer.get() + offset, length), 
                         detail::read_write_handler_with_buffer(completion_promise, buffer));
       return completion_promise;//->wait();
@@ -158,7 +158,7 @@ namespace asio {
      */
     template<typename AsyncWriteStream, typename ConstBufferSequence>
     size_t write( AsyncWriteStream& s, const ConstBufferSequence& buf ) {
-        promise<size_t>::ptr p(new promise<size_t>("fc::asio::write"));
+        promise<size_t>::ptr p = promise<size_t>::create("fc::asio::write");
         boost::asio::async_write(s, buf, detail::read_write_handler(p));
         return p->wait();
     }
@@ -170,23 +170,23 @@ namespace asio {
      */
     template<typename AsyncWriteStream, typename ConstBufferSequence>
     future<size_t> write_some( AsyncWriteStream& s, const ConstBufferSequence& buf ) {
-        promise<size_t>::ptr p(new promise<size_t>("fc::asio::write_some"));
+        promise<size_t>::ptr p = promise<size_t>::create("fc::asio::write_some");
         s.async_write_some( buf, detail::read_write_handler(p));
         return p; //->wait();
     }
 
     template<typename AsyncWriteStream>
     future<size_t> write_some( AsyncWriteStream& s, const char* buffer, 
                                size_t length, size_t offset = 0) {
-        promise<size_t>::ptr p(new promise<size_t>("fc::asio::write_some"));
+        promise<size_t>::ptr p = promise<size_t>::create("fc::asio::write_some");
         s.async_write_some( boost::asio::buffer(buffer + offset, length), detail::read_write_handler(p));
         return p; //->wait();
     }
 
     template<typename AsyncWriteStream>
     future<size_t> write_some( AsyncWriteStream& s, const std::shared_ptr<const char>& buffer, 
                                size_t length, size_t offset ) {
-        promise<size_t>::ptr p(new promise<size_t>("fc::asio::write_some"));
+        promise<size_t>::ptr p = promise<size_t>::create("fc::asio::write_some");
         s.async_write_some( boost::asio::buffer(buffer.get() + offset, length), detail::read_write_handler_with_buffer(p, buffer));
         return p; //->wait();
     }
@@ -229,7 +229,7 @@ namespace asio {
         template<typename SocketType, typename AcceptorType>
         void accept( AcceptorType& acc, SocketType& sock ) {
             //promise<boost::system::error_code>::ptr p( new promise<boost::system::error_code>("fc::asio::tcp::accept") );
-            promise<void>::ptr p( new promise<void>("fc::asio::tcp::accept") );
+            promise<void>::ptr p = promise<void>::create("fc::asio::tcp::accept");
             acc.async_accept( sock, boost::bind( fc::asio::detail::error_handler, p, boost::placeholders::_1 ) );
             p->wait();
             //if( ec ) BOOST_THROW_EXCEPTION( boost::system::system_error(ec) );
@@ -241,7 +241,7 @@ namespace asio {
           */
         template<typename AsyncSocket, typename EndpointType>
         void connect( AsyncSocket& sock, const EndpointType& ep ) {
-            promise<void>::ptr p(new promise<void>("fc::asio::tcp::connect"));
+            promise<void>::ptr p = promise<void>::create("fc::asio::tcp::connect");
             sock.async_connect( ep, boost::bind( fc::asio::detail::error_handler, p, boost::placeholders::_1 ) );
             p->wait();
             //if( ec ) BOOST_THROW_EXCEPTION( boost::system::system_error(ec) );

libraries/fc/include/fc/signals.hpp

@@ -36,13 +36,13 @@ namespace fc {
 
    template<typename T>
    inline T wait( boost::signals2::signal<void(T)>& sig, const microseconds& timeout_us=microseconds::maximum() ) {
-     typename promise<T>::ptr p(new promise<T>("fc::signal::wait"));
+     typename promise<T>::ptr p = promise<T>::create("fc::signal::wait");
      boost::signals2::scoped_connection c( sig.connect( [=]( T t ) { p->set_value(t); } )); 
      return p->wait( timeout_us ); 
    }
 
    inline void wait( boost::signals2::signal<void()>& sig, const microseconds& timeout_us=microseconds::maximum() ) {
-     promise<void>::ptr p(new promise<void>("fc::signal::wait"));
+     promise<void>::ptr p = promise<void>::create("fc::signal::wait");
      boost::signals2::scoped_connection c( sig.connect( [=]() { p->set_value(); } )); 
      p->wait( timeout_us ); 
    }

libraries/fc/include/fc/thread/future.hpp

@@ -1,12 +1,11 @@
 #pragma once
-#include <fc/utility.hpp>
 #include <fc/time.hpp>
-#include <fc/shared_ptr.hpp>
 #include <fc/exception/exception.hpp>
 #include <fc/thread/spin_yield_lock.hpp>
 #include <fc/optional.hpp>
+#include <memory>
 
-#include <atomic>
+#include <boost/atomic.hpp>
 
 //#define FC_TASK_NAMES_ARE_MANDATORY 1
 #ifdef FC_TASK_NAMES_ARE_MANDATORY
@@ -23,7 +22,6 @@
 #endif
 
 namespace fc {
-  class abstract_thread;
   struct void_t{};
   class priority;
   class thread;
@@ -34,13 +32,13 @@ namespace fc {
           virtual ~completion_handler(){};
           virtual void on_complete( const void* v, const fc::exception_ptr& e ) = 0;
      };
-
+     
      template<typename Functor, typename T>
      class completion_handler_impl : public completion_handler {
        public:
-         completion_handler_impl( Functor&& f ):_func(fc::move(f)){}
+         completion_handler_impl( Functor&& f ):_func(std::move(f)){}
          completion_handler_impl( const Functor& f ):_func(f){}
-
+     
          virtual void on_complete( const void* v, const fc::exception_ptr& e ) {
            _func( *static_cast<const T*>(v), e);
          }
@@ -50,7 +48,7 @@ namespace fc {
      template<typename Functor>
      class completion_handler_impl<Functor,void> : public completion_handler {
        public:
-         completion_handler_impl( Functor&& f ):_func(fc::move(f)){}
+         completion_handler_impl( Functor&& f ):_func(std::move(f)){}
          completion_handler_impl( const Functor& f ):_func(f){}
          virtual void on_complete( const void* v, const fc::exception_ptr& e ) {
            _func(e);
@@ -60,10 +58,10 @@ namespace fc {
      };
   }
 
-  class promise_base : public virtual retainable{
+  class promise_base : public std::enable_shared_from_this<promise_base> {
     public:
-      typedef fc::shared_ptr<promise_base> ptr;
-      promise_base(const char* desc FC_TASK_NAME_DEFAULT_ARG);
+      typedef std::shared_ptr<promise_base> ptr;
+      virtual ~promise_base();
 
       const char* get_desc()const;
 
@@ -75,6 +73,8 @@ namespace fc {
       void set_exception( const fc::exception_ptr& e );
 
     protected:
+      promise_base(const char* desc FC_TASK_NAME_DEFAULT_ARG);
+
       void _wait( const microseconds& timeout_us );
       void _wait_until( const time_point& timeout_us );
       void _enqueue_thread();
@@ -84,36 +84,46 @@ namespace fc {
       void _set_value(const void* v);
 
       void _on_complete( detail::completion_handler* c );
-      ~promise_base();
 
     private:
       friend class  thread;
       friend struct context;
       friend class  thread_d;
 
-      std::atomic_bool            _ready;
+      bool                        _ready;
       mutable spin_yield_lock     _spin_yield;
       thread*                     _blocked_thread;
       unsigned                    _blocked_fiber_count;
       time_point                  _timeout;
       fc::exception_ptr           _exceptp;
-      std::atomic_bool            _canceled;
+      bool                        _canceled;
 #ifndef NDEBUG
     protected:
       const char*                 _cancellation_reason;
     private:
 #endif
-      const char*                 _desc;
-      detail::completion_handler* _compl;
+      const char*                   _desc;
+      detail::completion_handler*   _compl;
   };
 
-  template<typename T = void>
+  template<typename T = void> 
   class promise : virtual public promise_base {
     public:
-      typedef fc::shared_ptr< promise<T> > ptr;
-      promise( const char* desc FC_TASK_NAME_DEFAULT_ARG):promise_base(desc){}
-      promise( const T& val ){ set_value(val); }
-      promise( T&& val ){ set_value(fc::move(val) ); }
+      typedef std::shared_ptr< promise<T> > ptr;
+      virtual ~promise(){}
+
+      static ptr create( const char* desc FC_TASK_NAME_DEFAULT_ARG )
+      {
+         return ptr( new promise<T>( desc ) );
+      }
+      static ptr create( const T& val )
+      {
+         return ptr( new promise<T>( val ) );
+      }
+      static ptr create( T&& val )
+      {
+         return ptr( new promise<T>( std::move(val) ) );
+      }
 
       const T& wait(const microseconds& timeout = microseconds::maximum() ){
         this->_wait( timeout );
@@ -130,7 +140,7 @@ namespace fc {
       }
 
       void set_value( T&& v ) {
-        result = fc::move(v);
+        result = std::move(v);
         _set_value(&*result);
       }
 
@@ -139,16 +149,28 @@ namespace fc {
         _on_complete( new detail::completion_handler_impl<CompletionHandler,T>(fc::forward<CompletionHandler>(c)) );
       }
     protected:
+      promise( const char* desc ):promise_base(desc){}
+      promise( const T& val ){ set_value(val); }
+      promise( T&& val ){ set_value(std::move(val) ); }
+
       optional<T> result;
-      ~promise(){}
   };
 
   template<>
   class promise<void> : virtual public promise_base {
     public:
-      typedef fc::shared_ptr< promise<void> > ptr;
-      promise( const char* desc FC_TASK_NAME_DEFAULT_ARG):promise_base(desc){}
-      //promise( const void_t& ){ set_value(); }
+      typedef std::shared_ptr< promise<void> > ptr;
+
+      virtual ~promise(){}
+    
+      static ptr create( const char* desc FC_TASK_NAME_DEFAULT_ARG )
+      {
+         return ptr( new promise<void>( desc ) );
+      }
+      static ptr create( bool fulfilled, const char* desc FC_TASK_NAME_DEFAULT_ARG )
+      {
+         return ptr( new promise<void>( fulfilled, desc ) );
+      }
 
       void wait(const microseconds& timeout = microseconds::maximum() ){
         this->_wait( timeout );
@@ -165,34 +187,37 @@ namespace fc {
         _on_complete( new detail::completion_handler_impl<CompletionHandler,void>(fc::forward<CompletionHandler>(c)) );
       }
     protected:
-      ~promise(){}
+      promise( const char* desc ):promise_base(desc){}
+      promise( bool fulfilled, const char* desc ){
+          if( fulfilled ) set_value();
+      }
   };
-
+  
   /**
    *  @brief a placeholder for the result of an asynchronous operation.
    *
-   *  By calling future<T>::wait() you will block the current fiber until
-   *  the asynchronous operation completes.
+   *  By calling future<T>::wait() you will block the current fiber until 
+   *  the asynchronous operation completes.  
    *
    *  If you would like to use an asynchronous interface instead of the synchronous
    *  'wait' method you could specify a CompletionHandler which is a method that takes
    *  two parameters, a const reference to the value and an exception_ptr.  If the
    *  exception_ptr is set, the value reference is invalid and accessing it is
-   *  'undefined'.
+   *  'undefined'.  
    *
    *  Promises have pointer semantics, futures have reference semantics that
    *  contain a shared pointer to a promise.
    */
-  template<typename T>
+  template<typename T> 
   class future {
     public:
-      future( const fc::shared_ptr<promise<T>>& p ):m_prom(p){}
-      future( fc::shared_ptr<promise<T>>&& p ):m_prom(fc::move(p)){}
+      future( const typename promise<T>::ptr& p ):m_prom(p){}
+      future( typename promise<T>::ptr&& p ):m_prom(std::move(p)){}
       future(const future<T>& f ) : m_prom(f.m_prom){}
       future(){}
 
       future& operator=(future<T>&& f ) {
-        fc_swap(m_prom,f.m_prom);
+        std::swap(m_prom,f.m_prom);
         return *this;
       }
 
@@ -240,9 +265,6 @@ namespace fc {
          }
       }
 
-      void set_value( const T& v ) { m_prom->set_value(v); }
-      void set_value( T&& v ) { m_prom->set_value(v); }
-
       /**
        * @pre valid()
        *
@@ -256,19 +278,19 @@ namespace fc {
       }
     private:
       friend class thread;
-      fc::shared_ptr<promise<T>> m_prom;
+      typename promise<T>::ptr m_prom;
   };
 
   template<>
   class future<void> {
     public:
-      future( const fc::shared_ptr<promise<void>>& p ):m_prom(p){}
-      future( fc::shared_ptr<promise<void>>&& p ):m_prom(fc::move(p)){}
+      future( const typename promise<void>::ptr& p ):m_prom(p){}
+      future( typename promise<void>::ptr&& p ):m_prom(std::move(p)){}
       future(const future<void>& f ) : m_prom(f.m_prom){}
       future(){}
 
       future& operator=(future<void>&& f ) {
-        fc_swap(m_prom,f.m_prom);
+        std::swap(m_prom,f.m_prom);
         return *this;
       }
 
@@ -291,7 +313,7 @@ namespace fc {
       bool valid()const    { return !!m_prom;           }
       bool canceled()const { return m_prom ? m_prom->canceled() : true; }
 
-      void cancel_and_wait(const char* reason FC_CANCELATION_REASON_DEFAULT_ARG)
+      void cancel_and_wait(const char* reason FC_CANCELATION_REASON_DEFAULT_ARG) 
       {
         cancel(reason);
         try
@@ -311,17 +333,13 @@ namespace fc {
 
       void cancel(const char* reason FC_CANCELATION_REASON_DEFAULT_ARG) const { if( m_prom ) m_prom->cancel(reason); }
 
-      void set_value(){ m_prom->set_value(); }
-      void set_value( const void_t&  ) { m_prom->set_value(); }
-
       template<typename CompletionHandler>
       void on_complete( CompletionHandler&& c ) {
         m_prom->on_complete( fc::forward<CompletionHandler>(c) );
       }
 
     private:
       friend class thread;
-      fc::shared_ptr<promise<void>> m_prom;
+      typename promise<void>::ptr m_prom;
   };
 }
-