get_executor() works on initiation objects

This is required for the new `asio::cancel_at` and `asio::cancel_after`
completion token adapters to work.

include/boost/beast/_experimental/http/impl/icy_stream.hpp

@@ -167,11 +167,20 @@ public:
 
 struct run_read_op
 {
+    icy_stream* self;
+
+    using executor_type = typename icy_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<class ReadHandler, class Buffers>
     void
     operator()(
         ReadHandler&& h,
-        icy_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -186,7 +195,7 @@ struct run_read_op
         read_op<
             Buffers,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h), *s, b);
+                std::forward<ReadHandler>(h), *self, b);
     }
 };
 
@@ -292,9 +301,8 @@ async_read_some(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            typename ops::run_read_op{},
+            typename ops::run_read_op{this},
             handler,
-            this,
             buffers);
 }
 

include/boost/beast/_experimental/test/impl/stream.hpp

@@ -27,7 +27,27 @@ namespace boost {
 namespace beast {
 namespace test {
 
-//------------------------------------------------------------------------------
+namespace detail
+{
+template<class To>
+struct extract_executor_op
+{
+    To operator()(net::any_io_executor& ex) const
+    {
+        assert(ex.template target<To>());
+        return *ex.template target<To>();
+    }
+};
+
+template<>
+struct extract_executor_op<net::any_io_executor>
+{
+    net::any_io_executor operator()(net::any_io_executor& ex) const
+    {
+        return ex;
+    }
+};
+} // detail
 
 template<class Executor>
 template<class Handler, class Buffers>
@@ -163,13 +183,22 @@ public:
 template<class Executor>
 struct basic_stream<Executor>::run_read_op
 {
+    boost::shared_ptr<detail::stream_state> const& in;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return detail::extract_executor_op<Executor>()(in->exec);
+    }
+
     template<
         class ReadHandler,
         class MutableBufferSequence>
     void
     operator()(
         ReadHandler&& h,
-        boost::shared_ptr<detail::stream_state> const& in,
         MutableBufferSequence const& buffers)
     {
         // If you get an error on the following line it means
@@ -197,13 +226,22 @@ struct basic_stream<Executor>::run_read_op
 template<class Executor>
 struct basic_stream<Executor>::run_write_op
 {
+    boost::shared_ptr<detail::stream_state> const& in_;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return detail::extract_executor_op<Executor>()(in_->exec);
+    }
+
     template<
         class WriteHandler,
         class ConstBufferSequence>
     void
     operator()(
         WriteHandler&& h,
-        boost::shared_ptr<detail::stream_state> in_,
         boost::weak_ptr<detail::stream_state> out_,
         ConstBufferSequence const& buffers)
     {
@@ -336,9 +374,8 @@ async_read_some(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            run_read_op{},
+            run_read_op{in_},
             handler,
-            in_,
             buffers);
 }
 
@@ -420,9 +457,8 @@ async_write_some(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            run_write_op{},
+            run_write_op{in_},
             handler,
-            in_,
             out_,
             buffers);
 }
@@ -467,28 +503,6 @@ connect(stream& to, Arg1&& arg1, ArgN&&... argn)
     return from;
 }
 
-namespace detail
-{
-template<class To>
-struct extract_executor_op
-{
-    To operator()(net::any_io_executor& ex) const
-    {
-        assert(ex.template target<To>());
-        return *ex.template target<To>();
-    }
-};
-
-template<>
-struct extract_executor_op<net::any_io_executor>
-{
-    net::any_io_executor operator()(net::any_io_executor& ex) const
-    {
-        return ex;
-    }
-};
-}
-
 template<class Executor>
 auto basic_stream<Executor>::get_executor() noexcept -> executor_type
 {

include/boost/beast/core/detail/impl/read.hpp

@@ -104,17 +104,26 @@ public:
 
 //------------------------------------------------------------------------------
 
+template <typename AsyncReadStream>
 struct run_read_op
 {
+    AsyncReadStream* stream;
+
+    using executor_type = typename AsyncReadStream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
     template<
-        class AsyncReadStream,
         class DynamicBuffer,
         class Condition,
         class ReadHandler>
     void
     operator()(
         ReadHandler&& h,
-        AsyncReadStream* s,
         DynamicBuffer* b,
         Condition&& c)
     {
@@ -133,7 +142,7 @@ struct run_read_op
             typename std::decay<Condition>::type,
             typename std::decay<ReadHandler>::type>(
                 std::forward<ReadHandler>(h),
-                *s,
+                *stream,
                 *b,
                 std::forward<Condition>(c));
     }
@@ -234,9 +243,8 @@ async_read(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            typename dynamic_read_ops::run_read_op{},
+            typename dynamic_read_ops::run_read_op<AsyncReadStream>{&stream},
             handler,
-            &stream,
             &buffer,
             std::forward<CompletionCondition>(cond));
 }

include/boost/beast/core/detect_ssl.hpp

@@ -348,6 +348,7 @@ class detect_ssl_op;
 // authors of composed operations need to write it this way to get the
 // very best performance, for example when using Coroutines TS (`co_await`).
 
+template <typename AsyncReadStream>
 struct run_detect_ssl_op
 {
     // The implementation of `net::async_initiate` captures the
@@ -361,20 +362,29 @@ struct run_detect_ssl_op
     // token into the "real handler" which must have the correct
     // signature, in this case `void(error_code, boost::tri_bool)`.
 
+    AsyncReadStream* stream;
+
+    using executor_type = typename AsyncReadStream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
     template<
         class DetectHandler,
-        class AsyncReadStream,
         class DynamicBuffer>
-    void operator()(
+    void
+    operator()(
         DetectHandler&& h,
-        AsyncReadStream* s, // references are passed as pointers
         DynamicBuffer* b)
     {
         detect_ssl_op<
             typename std::decay<DetectHandler>::type,
             AsyncReadStream,
             DynamicBuffer>(
-                std::forward<DetectHandler>(h), *s, *b);
+                std::forward<DetectHandler>(h), *stream, *b);
     }
 };
 
@@ -423,9 +433,8 @@ async_detect_ssl(
     return net::async_initiate<
         CompletionToken,
         void(error_code, bool)>(
-            detail::run_detect_ssl_op{},
+            detail::run_detect_ssl_op<AsyncReadStream>{&stream},
             token,
-            &stream, // pass the reference by pointer
             &buffer);
 }
 

include/boost/beast/core/impl/basic_stream.hpp

@@ -606,11 +606,20 @@ public:
 
 struct run_read_op
 {
+    basic_stream* self;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<class ReadHandler, class Buffers>
     void
     operator()(
         ReadHandler&& h,
-        basic_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -626,17 +635,26 @@ struct run_read_op
             true,
             Buffers,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h), *s, b);
+                std::forward<ReadHandler>(h), *self, b);
     }
 };
 
 struct run_write_op
 {
+    basic_stream* self;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<class WriteHandler, class Buffers>
     void
     operator()(
         WriteHandler&& h,
-        basic_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -652,17 +670,26 @@ struct run_write_op
             false,
             Buffers,
             typename std::decay<WriteHandler>::type>(
-                std::forward<WriteHandler>(h), *s, b);
+                std::forward<WriteHandler>(h), *self, b);
     }
 };
 
 struct run_connect_op
 {
+    basic_stream* self;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<class ConnectHandler>
     void
     operator()(
         ConnectHandler&& h,
-        basic_stream* s,
         endpoint_type const& ep)
     {
         // If you get an error on the following line it means
@@ -675,12 +702,22 @@ struct run_connect_op
             "ConnectHandler type requirements not met");
 
         connect_op<typename std::decay<ConnectHandler>::type>(
-            std::forward<ConnectHandler>(h), *s, ep);
+            std::forward<ConnectHandler>(h), *self, ep);
     }
 };
 
 struct run_connect_range_op
 {
+    basic_stream* self;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<
         class RangeConnectHandler,
         class EndpointSequence,
@@ -688,7 +725,6 @@ struct run_connect_range_op
     void
     operator()(
         RangeConnectHandler&& h,
-        basic_stream* s,
         EndpointSequence const& eps,
         Condition const& cond)
     {
@@ -702,12 +738,22 @@ struct run_connect_range_op
             "RangeConnectHandler type requirements not met");
 
         connect_op<typename std::decay<RangeConnectHandler>::type>(
-            std::forward<RangeConnectHandler>(h), *s, eps, cond);
+            std::forward<RangeConnectHandler>(h), *self, eps, cond);
     }
 };
 
 struct run_connect_iter_op
 {
+    basic_stream* self;
+
+    using executor_type = typename basic_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<
         class IteratorConnectHandler,
         class Iterator,
@@ -715,7 +761,6 @@ struct run_connect_iter_op
     void
     operator()(
         IteratorConnectHandler&& h,
-        basic_stream* s,
         Iterator begin, Iterator end,
         Condition const& cond)
     {
@@ -729,7 +774,7 @@ struct run_connect_iter_op
             "IteratorConnectHandler type requirements not met");
 
         connect_op<typename std::decay<IteratorConnectHandler>::type>(
-            std::forward<IteratorConnectHandler>(h), *s, begin, end, cond);
+            std::forward<IteratorConnectHandler>(h), *self, begin, end, cond);
     }
 };
 
@@ -895,9 +940,8 @@ async_connect(
     return net::async_initiate<
         ConnectHandler,
         void(error_code)>(
-            typename ops::run_connect_op{},
+            typename ops::run_connect_op{this},
             handler,
-            this,
             ep);
 }
 
@@ -916,9 +960,8 @@ async_connect(
     return net::async_initiate<
         RangeConnectHandler,
         void(error_code, typename Protocol::endpoint)>(
-            typename ops::run_connect_range_op{},
+            typename ops::run_connect_range_op{this},
             handler,
-            this,
             endpoints,
             detail::any_endpoint{});
 }
@@ -940,9 +983,8 @@ async_connect(
     return net::async_initiate<
         RangeConnectHandler,
         void(error_code, typename Protocol::endpoint)>(
-            typename ops::run_connect_range_op{},
+            typename ops::run_connect_range_op{this},
             handler,
-            this,
             endpoints,
             connect_condition);
 }
@@ -961,9 +1003,8 @@ async_connect(
     return net::async_initiate<
         IteratorConnectHandler,
         void(error_code, Iterator)>(
-            typename ops::run_connect_iter_op{},
+            typename ops::run_connect_iter_op{this},
             handler,
-            this,
             begin, end,
             detail::any_endpoint{});
 }
@@ -984,9 +1025,8 @@ async_connect(
     return net::async_initiate<
         IteratorConnectHandler,
         void(error_code, Iterator)>(
-            typename ops::run_connect_iter_op{},
+            typename ops::run_connect_iter_op{this},
             handler,
-            this,
             begin, end,
             connect_condition);
 }
@@ -1007,9 +1047,8 @@ async_read_some(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            typename ops::run_read_op{},
+            typename ops::run_read_op{this},
             handler,
-            this,
             buffers);
 }
 
@@ -1027,9 +1066,8 @@ async_write_some(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            typename ops::run_write_op{},
+            typename ops::run_write_op{this},
             handler,
-            this,
             buffers);
 }
 

include/boost/beast/core/impl/buffered_read_stream.hpp

@@ -106,11 +106,20 @@ public:
 
 struct run_read_op
 {
+    buffered_read_stream* self;
+
+    using executor_type = typename buffered_read_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<class ReadHandler, class Buffers>
     void
     operator()(
         ReadHandler&& h,
-        buffered_read_stream* s,
         Buffers const* b)
     {
         // If you get an error on the following line it means
@@ -125,7 +134,7 @@ struct run_read_op
         read_op<
             Buffers,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h), *s, *b);
+                std::forward<ReadHandler>(h), *self, *b);
     }
 };
 
@@ -231,9 +240,8 @@ async_read_some(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            typename ops::run_read_op{},
+            typename ops::run_read_op{this},
             handler,
-            this,
             &buffers);
 }
 

include/boost/beast/core/impl/flat_stream.hpp

@@ -85,11 +85,20 @@ public:
 
 struct run_write_op
 {
+    flat_stream* self;
+
+    using executor_type = typename flat_stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->get_executor();
+    }
+
     template<class WriteHandler, class Buffers>
     void
     operator()(
         WriteHandler&& h,
-        flat_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -103,7 +112,7 @@ struct run_write_op
 
         write_op<
             typename std::decay<WriteHandler>::type>(
-                std::forward<WriteHandler>(h), *s, b);
+                std::forward<WriteHandler>(h), *self, b);
     }
 };
 
@@ -250,9 +259,8 @@ async_write_some(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            typename ops::run_write_op{},
+            typename ops::run_write_op{this},
             handler,
-            this,
             buffers);
 }
 

include/boost/beast/http/impl/file_body_win32.hpp

@@ -509,17 +509,23 @@ public:
     }
 };
 
+template<class Protocol, class Executor>
 struct run_write_some_win32_op
 {
-    template<
+    net::basic_stream_socket<Protocol, Executor>* stream;
-        class Protocol, class Executor,
+
-        bool isRequest, class Fields,
+    using executor_type = typename net::basic_stream_socket<Protocol, Executor>::executor_type;
-        class WriteHandler>
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
+    template<bool isRequest, class Fields, class WriteHandler>
     void
     operator()(
         WriteHandler&& h,
-        net::basic_stream_socket<
-            Protocol, Executor>* s,
         serializer<isRequest,
             basic_file_body<file_win32>, Fields>* sr)
     {
@@ -536,7 +542,7 @@ struct run_write_some_win32_op
             Protocol, Executor,
             isRequest, Fields,
             typename std::decay<WriteHandler>::type>(
-                std::forward<WriteHandler>(h), *s, *sr);
+                std::forward<WriteHandler>(h), *stream, *sr);
     }
 };
 
@@ -629,9 +635,8 @@ async_write_some(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            detail::run_write_some_win32_op{},
+            detail::run_write_some_win32_op<Protocol, Executor>{&sock},
             handler,
-            &sock,
             &sr);
 }
 

include/boost/beast/http/impl/read.hpp

@@ -116,17 +116,26 @@ public:
     }
 };
 
+template <typename AsyncReadStream>
 struct run_read_msg_op
 {
+    AsyncReadStream* stream;
+
+    using executor_type = typename AsyncReadStream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
     template<
         class ReadHandler,
-        class AsyncReadStream,
         class DynamicBuffer,
         bool isRequest, class Body, class Allocator>
     void
     operator()(
         ReadHandler&& h,
-        AsyncReadStream* s,
         DynamicBuffer* b,
         message<isRequest, Body,
             basic_fields<Allocator>>* m)
@@ -145,7 +154,7 @@ struct run_read_msg_op
             DynamicBuffer,
             isRequest, Body, Allocator,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h), *s, *b, *m);
+                std::forward<ReadHandler>(h), *stream, *b, *m);
     }
 };
 
@@ -710,8 +719,8 @@ async_read(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            detail::run_read_msg_op{},
+            detail::run_read_msg_op<AsyncReadStream>{&stream},
-                handler, &stream, &buffer, &msg);
+                handler, &buffer, &msg);
 }
 
 } // http

include/boost/beast/http/impl/write.hpp

@@ -299,16 +299,25 @@ public:
     }
 };
 
+template <typename AsyncWriteStream>
 struct run_write_some_op
 {
+    AsyncWriteStream* stream;
+
+    using executor_type = typename AsyncWriteStream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
     template<
         class WriteHandler,
-        class Stream,
         bool isRequest, class Body, class Fields>
     void
     operator()(
         WriteHandler&& h,
-        Stream* s,
         serializer<isRequest, Body, Fields>* sr)
     {
         // If you get an error on the following line it means
@@ -322,23 +331,32 @@ struct run_write_some_op
 
         write_some_op<
             typename std::decay<WriteHandler>::type,
-            Stream,
+            AsyncWriteStream,
             isRequest, Body, Fields>(
-                std::forward<WriteHandler>(h), *s, *sr);
+                std::forward<WriteHandler>(h), *stream, *sr);
     }
 };
 
+template <typename AsyncWriteStream>
 struct run_write_op
 {
+    AsyncWriteStream* stream;
+
+    using executor_type = typename AsyncWriteStream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
     template<
         class WriteHandler,
-        class Stream,
         class Predicate,
         bool isRequest, class Body, class Fields>
     void
     operator()(
         WriteHandler&& h,
-        Stream* s,
         Predicate const&,
         serializer<isRequest, Body, Fields>* sr)
     {
@@ -353,24 +371,33 @@ struct run_write_op
 
         write_op<
             typename std::decay<WriteHandler>::type,
-            Stream,
+            AsyncWriteStream,
             Predicate,
             isRequest, Body, Fields>(
-                std::forward<WriteHandler>(h), *s, *sr);
+                std::forward<WriteHandler>(h), *stream, *sr);
     }
 };
 
+template <typename AsyncWriteStream>
 struct run_write_msg_op
 {
+    AsyncWriteStream* stream;
+
+    using executor_type = typename AsyncWriteStream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return stream->get_executor();
+    }
+
     template<
         class WriteHandler,
-        class Stream,
         bool isRequest, class Body, class Fields,
         class... Args>
     void
     operator()(
         WriteHandler&& h,
-        Stream* s,
         message<isRequest, Body, Fields>* m,
         std::false_type,
         Args&&... args)
@@ -386,21 +413,19 @@ struct run_write_msg_op
 
         write_msg_op<
             typename std::decay<WriteHandler>::type,
-            Stream,
+            AsyncWriteStream,
             isRequest, Body, Fields>(
-                std::forward<WriteHandler>(h), *s, *m,
+                std::forward<WriteHandler>(h), *stream, *m,
                 std::forward<Args>(args)...);
     }
 
     template<
         class WriteHandler,
-        class Stream,
         bool isRequest, class Body, class Fields,
         class... Args>
     void
     operator()(
         WriteHandler&& h,
-        Stream* s,
         message<isRequest, Body, Fields> const* m,
         std::true_type,
         Args&&... args)
@@ -416,9 +441,9 @@ struct run_write_msg_op
 
         write_msg_op<
             typename std::decay<WriteHandler>::type,
-            Stream,
+            AsyncWriteStream,
             isRequest, Body, Fields>(
-                std::forward<WriteHandler>(h), *s, *m,
+                std::forward<WriteHandler>(h), *stream, *m,
                 std::forward<Args>(args)...);
     }
 };
@@ -513,9 +538,8 @@ async_write_some_impl(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            run_write_some_op{},
+            run_write_some_op<AsyncWriteStream>{&stream},
             handler,
-            &stream,
             &sr);
 }
 
@@ -666,9 +690,8 @@ async_write_header(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            detail::run_write_op{},
+            detail::run_write_op<AsyncWriteStream>{&stream},
             handler,
-            &stream,
             detail::serializer_is_header_done{},
             &sr);
 }
@@ -739,9 +762,8 @@ async_write(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            detail::run_write_op{},
+            detail::run_write_op<AsyncWriteStream>{&stream},
             handler,
-            &stream,
             detail::serializer_is_done{},
             &sr);
 }
@@ -860,9 +882,8 @@ async_write(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            detail::run_write_msg_op{},
+            detail::run_write_msg_op<AsyncWriteStream>{&stream},
             handler,
-            &stream,
             &msg,
             std::false_type{});
 }
@@ -889,9 +910,8 @@ async_write(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            detail::run_write_msg_op{},
+            detail::run_write_msg_op<AsyncWriteStream>{&stream},
             handler,
-            &stream,
             &msg,
             std::true_type{});
 }

include/boost/beast/websocket/impl/accept.hpp

@@ -368,6 +368,16 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_response_op
 {
+    boost::shared_ptr<impl_type> const& self;
+
+    using executor_type = typename stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->stream().get_executor();
+    }
+
     template<
         class AcceptHandler,
         class Body, class Allocator,
@@ -375,7 +385,6 @@ struct stream<NextLayer, deflateSupported>::
     void
     operator()(
         AcceptHandler&& h,
-        boost::shared_ptr<impl_type> const& sp,
         http::request<Body,
             http::basic_fields<Allocator>> const* m,
         Decorator const& d)
@@ -391,7 +400,7 @@ struct stream<NextLayer, deflateSupported>::
 
         response_op<
             typename std::decay<AcceptHandler>::type>(
-                std::forward<AcceptHandler>(h), sp, *m, d);
+                std::forward<AcceptHandler>(h), self, *m, d);
     }
 };
 
@@ -399,6 +408,16 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_accept_op
 {
+    boost::shared_ptr<impl_type> const& self;
+
+    using executor_type = typename stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->stream().get_executor();
+    }
+
     template<
         class AcceptHandler,
         class Decorator,
@@ -406,7 +425,6 @@ struct stream<NextLayer, deflateSupported>::
     void
     operator()(
         AcceptHandler&& h,
-        boost::shared_ptr<impl_type> const& sp,
         Decorator const& d,
         Buffers const& b)
     {
@@ -423,7 +441,7 @@ struct stream<NextLayer, deflateSupported>::
             typename std::decay<AcceptHandler>::type,
             Decorator>(
                 std::forward<AcceptHandler>(h),
-                sp,
+                self,
                 d,
                 b);
     }
@@ -615,9 +633,8 @@ async_accept(
     return net::async_initiate<
         AcceptHandler,
         void(error_code)>(
-            run_accept_op{},
+            run_accept_op{impl_},
             handler,
-            impl_,
             &default_decorate_res,
             net::const_buffer{});
 }
@@ -648,9 +665,8 @@ async_accept(
     return net::async_initiate<
         AcceptHandler,
         void(error_code)>(
-            run_accept_op{},
+            run_accept_op{impl_},
             handler,
-            impl_,
             &default_decorate_res,
             buffers);
 }
@@ -671,9 +687,8 @@ async_accept(
     return net::async_initiate<
         AcceptHandler,
         void(error_code)>(
-            run_response_op{},
+            run_response_op{impl_},
             handler,
-            impl_,
             &req,
             &default_decorate_res);
 }

include/boost/beast/websocket/impl/close.hpp

@@ -302,11 +302,20 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_close_op
 {
+    boost::shared_ptr<impl_type> const& self;
+
+    using executor_type = typename stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->stream().get_executor();
+    }
+
     template<class CloseHandler>
     void
     operator()(
         CloseHandler&& h,
-        boost::shared_ptr<impl_type> const& sp,
         close_reason const& cr)
     {
         // If you get an error on the following line it means
@@ -321,7 +330,7 @@ struct stream<NextLayer, deflateSupported>::
         close_op<
             typename std::decay<CloseHandler>::type>(
                 std::forward<CloseHandler>(h),
-                sp,
+                self,
                 cr);
     }
 };
@@ -458,9 +467,8 @@ async_close(close_reason const& cr, CloseHandler&& handler)
     return net::async_initiate<
         CloseHandler,
         void(error_code)>(
-            run_close_op{},
+            run_close_op{impl_},
             handler,
-            impl_,
             cr);
 }
 

include/boost/beast/websocket/impl/handshake.hpp

@@ -188,10 +188,19 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_handshake_op
 {
+    boost::shared_ptr<impl_type> const& self;
+
+    using executor_type = typename stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->stream().get_executor();
+    }
+
     template<class HandshakeHandler>
     void operator()(
         HandshakeHandler&& h,
-        boost::shared_ptr<impl_type> const& sp,
         request_type&& req,
         detail::sec_ws_key_type key,
         response_type* res_p)
@@ -208,7 +217,7 @@ struct stream<NextLayer, deflateSupported>::
         handshake_op<
             typename std::decay<HandshakeHandler>::type>(
                 std::forward<HandshakeHandler>(h),
-                    sp, std::move(req), key, res_p);
+                    self, std::move(req), key, res_p);
     }
 };
 
@@ -311,9 +320,8 @@ async_handshake(
     return net::async_initiate<
         HandshakeHandler,
         void(error_code)>(
-            run_handshake_op{},
+            run_handshake_op{impl_},
             handler,
-            impl_,
             std::move(req),
             key,
             nullptr);
@@ -338,9 +346,8 @@ async_handshake(
     return net::async_initiate<
         HandshakeHandler,
         void(error_code)>(
-            run_handshake_op{},
+            run_handshake_op{impl_},
             handler,
-            impl_,
             std::move(req),
             key,
             &res);

include/boost/beast/websocket/impl/ping.hpp

@@ -245,11 +245,20 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_ping_op
 {
+    boost::shared_ptr<impl_type> const& self;
+
+    using executor_type = typename stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->stream().get_executor();
+    }
+
     template<class WriteHandler>
     void
     operator()(
         WriteHandler&& h,
-        boost::shared_ptr<impl_type> const& sp,
         detail::opcode op,
         ping_data const& p)
     {
@@ -265,7 +274,7 @@ struct stream<NextLayer, deflateSupported>::
         ping_op<
             typename std::decay<WriteHandler>::type>(
                 std::forward<WriteHandler>(h),
-                sp,
+                self,
                 op,
                 p);
     }
@@ -336,9 +345,8 @@ async_ping(ping_data const& payload, PingHandler&& handler)
     return net::async_initiate<
         PingHandler,
         void(error_code)>(
-            run_ping_op{},
+            run_ping_op{impl_},
             handler,
-            impl_,
             detail::opcode::ping,
             payload);
 }
@@ -354,9 +362,8 @@ async_pong(ping_data const& payload, PongHandler&& handler)
     return net::async_initiate<
         PongHandler,
         void(error_code)>(
-            run_ping_op{},
+            run_ping_op{impl_},
             handler,
-            impl_,
             detail::opcode::pong,
             payload);
 }

include/boost/beast/websocket/impl/read.hpp

@@ -819,13 +819,22 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_read_some_op
 {
+    boost::shared_ptr<impl_type> const& self;
+
+    using executor_type = typename stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->stream().get_executor();
+    }
+
     template<
         class ReadHandler,
         class MutableBufferSequence>
     void
     operator()(
         ReadHandler&& h,
-        boost::shared_ptr<impl_type> const& sp,
         MutableBufferSequence const& b)
     {
         // If you get an error on the following line it means
@@ -841,7 +850,7 @@ struct stream<NextLayer, deflateSupported>::
             typename std::decay<ReadHandler>::type,
             MutableBufferSequence>(
                 std::forward<ReadHandler>(h),
-                sp,
+                self,
                 b);
     }
 };
@@ -850,13 +859,22 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_read_op
 {
+    boost::shared_ptr<impl_type> const& self;
+
+    using executor_type = typename stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->stream().get_executor();
+    }
+
     template<
         class ReadHandler,
         class DynamicBuffer>
     void
     operator()(
         ReadHandler&& h,
-        boost::shared_ptr<impl_type> const& sp,
         DynamicBuffer* b,
         std::size_t limit,
         bool some)
@@ -874,7 +892,7 @@ struct stream<NextLayer, deflateSupported>::
             typename std::decay<ReadHandler>::type,
             DynamicBuffer>(
                 std::forward<ReadHandler>(h),
-                sp,
+                self,
                 *b,
                 limit,
                 some);
@@ -937,9 +955,8 @@ async_read(DynamicBuffer& buffer, ReadHandler&& handler)
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            run_read_op{},
+            run_read_op{impl_},
             handler,
-            impl_,
             &buffer,
             0,
             false);
@@ -1014,9 +1031,8 @@ async_read_some(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            run_read_op{},
+            run_read_op{impl_},
             handler,
-            impl_,
             &buffer,
             limit,
             true);
@@ -1395,9 +1411,8 @@ async_read_some(
     return net::async_initiate<
         ReadHandler,
         void(error_code, std::size_t)>(
-            run_read_some_op{},
+            run_read_some_op{impl_},
             handler,
-            impl_,
             buffers);
 }
 

include/boost/beast/websocket/impl/write.hpp

@@ -559,13 +559,22 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_write_some_op
 {
+    boost::shared_ptr<impl_type> const& self;
+
+    using executor_type = typename stream::executor_type;
+
+    executor_type
+    get_executor() const noexcept
+    {
+        return self->stream().get_executor();
+    }
+
     template<
         class WriteHandler,
         class ConstBufferSequence>
     void
     operator()(
         WriteHandler&& h,
-        boost::shared_ptr<impl_type> const& sp,
         bool fin,
         ConstBufferSequence const& b)
     {
@@ -582,7 +591,7 @@ struct stream<NextLayer, deflateSupported>::
             typename std::decay<WriteHandler>::type,
             ConstBufferSequence>(
                 std::forward<WriteHandler>(h),
-                sp,
+                self,
                 fin,
                 b);
     }
@@ -836,9 +845,8 @@ async_write_some(bool fin,
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            run_write_some_op{},
+            run_write_some_op{impl_},
             handler,
-            impl_,
             fin,
             bs);
 }
@@ -892,9 +900,8 @@ async_write(
     return net::async_initiate<
         WriteHandler,
         void(error_code, std::size_t)>(
-            run_write_some_op{},
+            run_write_some_op{impl_},
             handler,
-            impl_,
             true,
             bs);
 }