zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/ConnectionI.h

@@ -1,389 +1,429 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_CONNECTION_I_H
 #define ICE_CONNECTION_I_H
 
-#include <IceUtil/Mutex.h>
-#include <IceUtil/Monitor.h>
-#include <IceUtil/Time.h>
-#include <IceUtil/StopWatch.h>
-#include <IceUtil/Timer.h>
-#include <Ice/UniquePtr.h>
-
-#include <Ice/CommunicatorF.h>
-#include <Ice/Connection.h>
-#include <Ice/ConnectionIF.h>
-#include <Ice/ConnectionFactoryF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/TransceiverF.h>
-#include <Ice/ObjectAdapterF.h>
-#include <Ice/ServantManagerF.h>
-#include <Ice/EndpointIF.h>
-#include <Ice/ConnectorF.h>
-#include <Ice/LoggerF.h>
-#include <Ice/TraceLevelsF.h>
-#include <Ice/OutgoingAsync.h>
-#include <Ice/EventHandler.h>
-#include <Ice/RequestHandler.h>
-#include <Ice/ResponseHandler.h>
-#include <Ice/Dispatcher.h>
-#include <Ice/ObserverHelper.h>
-#include <Ice/ConnectionAsync.h>
-#include <Ice/BatchRequestQueueF.h>
-#include <Ice/ACM.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-
+#include "ConnectionFactoryF.h"
+#include "ConnectionOptions.h"
+#include "ConnectorF.h"
+#include "EndpointIF.h"
+#include "EventHandler.h"
+#include "Ice/BatchRequestQueueF.h"
+#include "Ice/CommunicatorF.h"
+#include "Ice/Connection.h"
+#include "Ice/ConnectionIF.h"
+#include "Ice/InputStream.h"
+#include "Ice/InstanceF.h"
+#include "Ice/Logger.h"
+#include "Ice/ObjectAdapterF.h"
+#include "Ice/ObserverHelper.h"
+#include "Ice/OutgoingAsync.h"
+#include "Ice/OutgoingResponse.h"
+#include "Ice/OutputStream.h"
+#include "RequestHandler.h"
+#include "Timer.h"
+#include "TraceLevelsF.h"
+#include "TransceiverF.h"
+
+#include <chrono>
+#include <condition_variable>
 #include <deque>
+#include <list>
+#include <mutex>
 
 #ifndef ICE_HAS_BZIP2
-#   define ICE_HAS_BZIP2
+#    define ICE_HAS_BZIP2
 #endif
 
-namespace Ice
+namespace IceInternal
 {
+    class IdleTimeoutTransceiverDecorator;
 
-class LocalException;
-class ObjectAdapterI;
-ICE_DEFINE_PTR(ObjectAdapterIPtr, ObjectAdapterI);
+    template<typename T> class ThreadPoolMessage;
+}
 
-class ConnectionI : public Connection,
-                    public IceInternal::EventHandler,
-                    public IceInternal::ResponseHandler,
-                    public IceInternal::CancellationHandler,
-                    public IceUtil::Monitor<IceUtil::Mutex>
+namespace Ice
 {
-    class Observer : public IceInternal::ObserverHelperT<Ice::Instrumentation::ConnectionObserver>
-    {
-    public:
-
-        Observer();
+    class LocalException;
+    class ObjectAdapterI;
+    using ObjectAdapterIPtr = std::shared_ptr<ObjectAdapterI>;
 
-        void startRead(const IceInternal::Buffer&);
-        void finishRead(const IceInternal::Buffer&);
-        void startWrite(const IceInternal::Buffer&);
-        void finishWrite(const IceInternal::Buffer&);
+    class ConnectionI final : public Connection,
+                              public IceInternal::EventHandler,
+                              public IceInternal::CancellationHandler
+    {
+        class Observer : public IceInternal::ObserverHelperT<Ice::Instrumentation::ConnectionObserver>
+        {
+        public:
+            Observer();
 
-        void attach(const Ice::Instrumentation::ConnectionObserverPtr&);
+            void startRead(const IceInternal::Buffer&);
+            void finishRead(const IceInternal::Buffer&);
+            void startWrite(const IceInternal::Buffer&);
+            void finishWrite(const IceInternal::Buffer&);
 
-    private:
+            void attach(const Ice::Instrumentation::ConnectionObserverPtr&);
 
-        Ice::Byte* _readStreamPos;
-        Ice::Byte* _writeStreamPos;
-    };
+        private:
+            std::byte* _readStreamPos{nullptr};
+            std::byte* _writeStreamPos{nullptr};
+        };
 
-public:
-
-#ifdef ICE_CPP11_MAPPING
-    std::shared_ptr<ConnectionI> shared_from_this()
-    {
-        return std::dynamic_pointer_cast<ConnectionI>(VirtualEnableSharedFromThisBase::shared_from_this());
-    }
-#endif
-
-    struct OutgoingMessage
-    {
-        OutgoingMessage(Ice::OutputStream* str, bool comp) :
-            stream(str), compress(comp), requestId(0), adopted(false)
-#if defined(ICE_USE_IOCP)
-            , isSent(false), invokeSent(false), receivedReply(false)
-#endif
+    public:
+        std::shared_ptr<ConnectionI> shared_from_this()
         {
+            return std::dynamic_pointer_cast<ConnectionI>(IceInternal::EventHandler::shared_from_this());
         }
 
-        OutgoingMessage(const IceInternal::OutgoingAsyncBasePtr& o, Ice::OutputStream* str,
-                        bool comp, int rid) :
-            stream(str), outAsync(o), compress(comp), requestId(rid), adopted(false)
+        struct OutgoingMessage
+        {
+            OutgoingMessage(Ice::OutputStream* str, bool comp)
+                : stream(str),
+                  compress(comp),
+                  requestId(0),
+                  adopted(false)
 #if defined(ICE_USE_IOCP)
-            , isSent(false), invokeSent(false), receivedReply(false)
+                  ,
+                  isSent(false),
+                  invokeSent(false),
+                  receivedReply(false)
 #endif
-        {
-        }
-
-        void adopt(Ice::OutputStream*);
-        void canceled(bool);
-        bool sent();
-        void completed(const Ice::LocalException&);
-
-        Ice::OutputStream* stream;
-        IceInternal::OutgoingAsyncBasePtr outAsync;
-        bool compress;
-        int requestId;
-        bool adopted;
+            {
+                assert(stream);
+                // The outgoing message can be sent asynchronously. If the stream doesn't own its memory, the memory
+                // owner could release it before the message is sent.
+                assert(stream->b.ownsMemory());
+            }
+
+            OutgoingMessage(IceInternal::OutgoingAsyncBasePtr o, Ice::OutputStream* str, bool comp, int rid)
+                : stream(str),
+                  outAsync(std::move(o)),
+                  compress(comp),
+                  requestId(rid),
+                  adopted(false)
 #if defined(ICE_USE_IOCP)
-        bool isSent;
-        bool invokeSent;
-        bool receivedReply;
+                  ,
+                  isSent(false),
+                  invokeSent(false),
+                  receivedReply(false)
 #endif
-    };
-
-#ifdef ICE_CPP11_MAPPING
-    class StartCallback
-    {
-    public:
+            {
+                assert(stream);
+                assert(stream->b.ownsMemory());
+            }
+
+            void adopt(Ice::OutputStream*);
+            void canceled(bool);
+            bool sent();
+            void completed(std::exception_ptr);
+
+            Ice::OutputStream* stream;
+            IceInternal::OutgoingAsyncBasePtr outAsync;
+            bool compress;
+            int requestId;
+            bool adopted;
+#if defined(ICE_USE_IOCP)
+            bool isSent;
+            bool invokeSent;
+            bool receivedReply;
+#endif
+        };
 
-        virtual void connectionStartCompleted(const ConnectionIPtr&) = 0;
-        virtual void connectionStartFailed(const ConnectionIPtr&, const Ice::LocalException&) = 0;
-    };
-    using StartCallbackPtr = ::std::shared_ptr<StartCallback>;
-#else
-    class StartCallback : public virtual IceUtil::Shared
-    {
-    public:
+        enum DestructionReason
+        {
+            ObjectAdapterDeactivated,
+            CommunicatorDestroyed
+        };
 
-        virtual void connectionStartCompleted(const ConnectionIPtr&) = 0;
-        virtual void connectionStartFailed(const ConnectionIPtr&, const Ice::LocalException&) = 0;
-    };
-    typedef IceUtil::Handle<StartCallback> StartCallbackPtr;
-#endif
+        void startAsync(
+            std::function<void(const ConnectionIPtr&)>,
+            std::function<void(const ConnectionIPtr&, std::exception_ptr)>);
+        void activate();
+        void hold();
+        void destroy(DestructionReason);
 
-    enum DestructionReason
-    {
-        ObjectAdapterDeactivated,
-        CommunicatorDestroyed
-    };
+        void abort() noexcept final;
+        void close(std::function<void()> response, std::function<void(std::exception_ptr)> exception) noexcept final;
 
-    void start(const StartCallbackPtr&);
-    void activate();
-    void hold();
-    void destroy(DestructionReason);
-    virtual void close(ConnectionClose) ICE_NOEXCEPT; // From Connection.
+        [[nodiscard]] bool isActiveOrHolding() const;
+        [[nodiscard]] bool isFinished() const;
 
-    bool isActiveOrHolding() const;
-    bool isFinished() const;
+        void throwException() const final; // From Connection. Throws the connection exception if destroyed.
 
-    virtual void throwException() const; // From Connection. Throws the connection exception if destroyed.
+        void waitUntilHolding() const;
+        void waitUntilFinished(); // Not const, as this might close the connection upon timeout.
 
-    void waitUntilHolding() const;
-    void waitUntilFinished(); // Not const, as this might close the connection upon timeout.
+        void updateObserver();
 
-    void updateObserver();
+        /// Sends a request.
+        /// @param out The outgoing request.
+        /// @param compress True to compress the request; otherwise, false.
+        /// @param response True for a two-way request; false for a one-way request.
+        /// @param batchRequestCount The number of requests in the batch (for one-way requests); ignored for two-way
+        /// requests.
+        /// @return The sent status.
+        IceInternal::AsyncStatus sendAsyncRequest(
+            const IceInternal::OutgoingAsyncBasePtr& out,
+            bool compress,
+            bool response,
+            int batchRequestCount);
 
-    void monitor(const IceUtil::Time&, const IceInternal::ACMConfig&);
+        [[nodiscard]] const IceInternal::BatchRequestQueuePtr& getBatchRequestQueue() const;
 
-    IceInternal::AsyncStatus sendAsyncRequest(const IceInternal::OutgoingAsyncBasePtr&, bool, bool, int);
+        std::function<void()> flushBatchRequestsAsync(
+            CompressBatch,
+            std::function<void(std::exception_ptr)>,
+            std::function<void(bool)> = nullptr) final;
 
-    IceInternal::BatchRequestQueuePtr getBatchRequestQueue() const;
+        void setCloseCallback(CloseCallback) final;
 
-#ifdef ICE_CPP11_MAPPING
-    virtual std::function<void()>
-    flushBatchRequestsAsync(CompressBatch,
-                            ::std::function<void(::std::exception_ptr)>,
-                            ::std::function<void(bool)> = nullptr);
-#else
-    virtual void flushBatchRequests(CompressBatch);
-    virtual AsyncResultPtr begin_flushBatchRequests(CompressBatch);
-    virtual AsyncResultPtr begin_flushBatchRequests(CompressBatch, const CallbackPtr&, const LocalObjectPtr& = 0);
-    virtual AsyncResultPtr begin_flushBatchRequests(CompressBatch,
-                                                    const Callback_Connection_flushBatchRequestsPtr&,
-                                                    const LocalObjectPtr& = 0);
+        void disableInactivityCheck() noexcept final;
 
-    virtual void end_flushBatchRequests(const AsyncResultPtr&);
-#endif
+        void asyncRequestCanceled(const IceInternal::OutgoingAsyncBasePtr&, std::exception_ptr) final;
 
-    virtual void setCloseCallback(ICE_IN(ICE_DELEGATE(CloseCallback)));
-    virtual void setHeartbeatCallback(ICE_IN(ICE_DELEGATE(HeartbeatCallback)));
+        [[nodiscard]] IceInternal::EndpointIPtr endpoint() const;
+        [[nodiscard]] IceInternal::ConnectorPtr connector() const;
 
-    virtual void heartbeat();
+        void setAdapter(const ObjectAdapterPtr&) final;                   // From Connection.
+        [[nodiscard]] ObjectAdapterPtr getAdapter() const noexcept final; // From Connection.
+        [[nodiscard]] EndpointPtr getEndpoint() const noexcept final;     // From Connection.
+        [[nodiscard]] ObjectPrx _createProxy(Identity ident) const final; // From Connection.
 
-#ifdef ICE_CPP11_MAPPING
-    virtual std::function<void()>
-    heartbeatAsync(::std::function<void(::std::exception_ptr)>, ::std::function<void(bool)> = nullptr);
-#else
-    virtual AsyncResultPtr begin_heartbeat();
-    virtual AsyncResultPtr begin_heartbeat(const CallbackPtr&, const LocalObjectPtr& = 0);
-    virtual AsyncResultPtr begin_heartbeat(const Callback_Connection_heartbeatPtr&, const LocalObjectPtr& = 0);
+        void setAdapterFromAdapter(const ObjectAdapterIPtr&); // From ObjectAdapterI.
 
-    virtual void end_heartbeat(const AsyncResultPtr&);
+        //
+        // Operations from EventHandler
+        //
+#if defined(ICE_USE_IOCP)
+        bool startAsync(IceInternal::SocketOperation);
+        bool finishAsync(IceInternal::SocketOperation);
 #endif
 
-    virtual void setACM(const IceUtil::Optional<int>&,
-                        const IceUtil::Optional<ACMClose>&,
-                        const IceUtil::Optional<ACMHeartbeat>&);
-    virtual ACM getACM() ICE_NOEXCEPT;
+        void message(IceInternal::ThreadPoolCurrent&) final;
+        void finished(IceInternal::ThreadPoolCurrent&, bool) final;
+        [[nodiscard]] std::string toString() const final; // From Connection and EventHandler.
+        IceInternal::NativeInfoPtr getNativeInfo() final;
 
-    virtual void asyncRequestCanceled(const IceInternal::OutgoingAsyncBasePtr&, const LocalException&);
+        [[nodiscard]] const std::string& type() const noexcept final; // From Connection.
+        [[nodiscard]] ConnectionInfoPtr getInfo() const final;        // From Connection
 
-    virtual void sendResponse(Int, Ice::OutputStream*, Byte, bool);
-    virtual void sendNoResponse();
-    virtual bool systemException(Int, const SystemException&, bool);
-    virtual void invokeException(Ice::Int, const LocalException&, int, bool);
+        void setBufferSize(std::int32_t rcvSize, std::int32_t sndSize) final; // From Connection
 
-    IceInternal::EndpointIPtr endpoint() const;
-    IceInternal::ConnectorPtr connector() const;
+        void exception(std::exception_ptr);
 
-    virtual void setAdapter(const ObjectAdapterPtr&); // From Connection.
-    virtual ObjectAdapterPtr getAdapter() const ICE_NOEXCEPT; // From Connection.
-    virtual EndpointPtr getEndpoint() const ICE_NOEXCEPT; // From Connection.
-    virtual ObjectPrxPtr createProxy(const Identity& ident) const; // From Connection.
+        // This method is called to execute user code (connection start completion callback, invocation sent callbacks,
+        // or an upcall issued from an incoming message). The invocation sent callbacks and the message upcall might
+        // both be set.
+        void upcall(
+            const std::function<void(ConnectionIPtr)>& connectionStartCompleted,
+            const std::vector<OutgoingMessage>& sentMessages,
+            const std::function<bool(InputStream&)>& messageUpcall,
+            InputStream& messageStream);
+        void finish(bool);
 
-    void setAdapterAndServantManager(const ObjectAdapterPtr&, const IceInternal::ServantManagerPtr&);
+        void closeCallback(const CloseCallback&);
 
-    //
-    // Operations from EventHandler
-    //
-#if defined(ICE_USE_IOCP)
-    bool startAsync(IceInternal::SocketOperation);
-    bool finishAsync(IceInternal::SocketOperation);
-#endif
+        /// Aborts the connection with a ConnectionAbortedException if the connection is active and did not receive
+        /// a byte for some time. See the IdleTimeoutTransceiverDecorator.
+        void idleCheck(const std::chrono::seconds& idleTimeout) noexcept;
 
-    virtual void message(IceInternal::ThreadPoolCurrent&);
-    virtual void finished(IceInternal::ThreadPoolCurrent&, bool);
-    virtual std::string toString() const ICE_NOEXCEPT; // From Connection and EvantHandler.
-    virtual IceInternal::NativeInfoPtr getNativeInfo();
+        /// Shuts down the connection gracefully if it's at rest when this function is called.
+        void inactivityCheck() noexcept;
 
-    void timedOut();
+        /// Aborts the connection if its state is < StateActive.
+        void connectTimedOut() noexcept;
 
-    virtual std::string type() const ICE_NOEXCEPT; // From Connection.
-    virtual Ice::Int timeout() const ICE_NOEXCEPT; // From Connection.
-    virtual ConnectionInfoPtr getInfo() const; // From Connection
+        /// Aborts the connection if its state is < StateClosed.
+        void closeTimedOut() noexcept;
 
-    virtual void setBufferSize(Ice::Int rcvSize, Ice::Int sndSize); // From Connection
+        /// Sends a heartbeat.
+        void sendHeartbeat() noexcept;
 
-    void exception(const LocalException&);
+        ~ConnectionI() final;
 
-    void dispatch(const StartCallbackPtr&, const std::vector<OutgoingMessage>&, Byte, Int, Int,
-                  const IceInternal::ServantManagerPtr&, const ObjectAdapterPtr&,
-                  const IceInternal::OutgoingAsyncBasePtr&,
-                  const ICE_DELEGATE(HeartbeatCallback)&, Ice::InputStream&);
-    void finish(bool);
+    private:
+        ConnectionI(
+            Ice::CommunicatorPtr,
+            const IceInternal::InstancePtr&,
+            const IceInternal::TransceiverPtr&,
+            const IceInternal::ConnectorPtr&,
+            const IceInternal::EndpointIPtr&,
+            const std::shared_ptr<ObjectAdapterI>&,
+            std::function<void(const ConnectionIPtr&)>,
+            const ConnectionOptions&) noexcept;
+
+        static ConnectionIPtr create(
+            const Ice::CommunicatorPtr&,
+            const IceInternal::InstancePtr&,
+            const IceInternal::TransceiverPtr&,
+            const IceInternal::ConnectorPtr&,
+            const IceInternal::EndpointIPtr&,
+            const std::shared_ptr<ObjectAdapterI>&,
+            std::function<void(const ConnectionIPtr&)>,
+            const ConnectionOptions&);
+
+        enum State
+        {
+            StateNotInitialized,
+            StateNotValidated,
+            StateActive,
+            StateHolding,
+            StateClosing,
+            StateClosingPending,
+            StateClosed,
+            StateFinished
+        };
+
+        friend class IceInternal::IncomingConnectionFactory;
+        friend class IceInternal::OutgoingConnectionFactory;
+
+        void setState(State, std::exception_ptr);
+        void setState(State);
+
+        void initiateShutdown();
+
+        void sendResponse(OutgoingResponse, std::uint8_t compress);
+        void dispatchException(std::exception_ptr, int);
+
+        bool initialize(IceInternal::SocketOperation = IceInternal::SocketOperationNone);
+        bool validate(IceInternal::SocketOperation = IceInternal::SocketOperationNone);
+
+        /// Sends the next queued messages. This method is called by message() once the message which is being sent
+        /// (_sendStreams.First) is fully sent. Before sending the next message, this message is removed from
+        /// _sendsStream. If any, its sent callback is also queued in given callback queue.
+        ///
+        /// @param callbacks The sent callbacks to call for the messages that were sent.
+        /// @return The socket operation to register with the thread pool's selector to send the remainder of the
+        /// pending message being sent (_sendStreams.First).
+        IceInternal::SocketOperation sendNextMessages(std::vector<OutgoingMessage>& callbacks);
+
+        /// Sends or queues the given message.
+        ///
+        /// @param message The message to send.
+        /// @return The send status.
+        IceInternal::AsyncStatus sendMessage(OutgoingMessage& message);
 
-    void closeCallback(const ICE_DELEGATE(CloseCallback)&);
+#ifdef ICE_HAS_BZIP2
+        void doCompress(Ice::OutputStream&, Ice::OutputStream&);
+        void doUncompress(Ice::InputStream&, Ice::InputStream&);
+#endif
 
-    virtual ~ConnectionI();
+        IceInternal::SocketOperation parseMessage(
+            std::int32_t& upcallCount,
+            std::function<bool(InputStream&)>& messageUpcall,
+            Ice::InputStream& messageStream);
 
-private:
+        void dispatchAll(Ice::InputStream&, std::int32_t, std::int32_t, std::uint8_t, const ObjectAdapterIPtr&);
 
-    ConnectionI(const Ice::CommunicatorPtr&, const IceInternal::InstancePtr&, const IceInternal::ACMMonitorPtr&,
-                const IceInternal::TransceiverPtr&, const IceInternal::ConnectorPtr&,
-                const IceInternal::EndpointIPtr&, const ObjectAdapterIPtr&);
+        [[nodiscard]] Ice::ConnectionInfoPtr initConnectionInfo() const;
+        [[nodiscard]] Ice::Instrumentation::ConnectionState toConnectionState(State) const;
 
-    static ConnectionIPtr
-    create(const Ice::CommunicatorPtr&, const IceInternal::InstancePtr&, const IceInternal::ACMMonitorPtr&,
-           const IceInternal::TransceiverPtr&, const IceInternal::ConnectorPtr&,
-           const IceInternal::EndpointIPtr&, const ObjectAdapterIPtr&);
+        IceInternal::SocketOperation read(IceInternal::Buffer&);
+        IceInternal::SocketOperation write(IceInternal::Buffer&);
 
-    enum State
-    {
-        StateNotInitialized,
-        StateNotValidated,
-        StateActive,
-        StateHolding,
-        StateClosing,
-        StateClosingPending,
-        StateClosed,
-        StateFinished
-    };
-
-    friend class IceInternal::IncomingConnectionFactory;
-    friend class IceInternal::OutgoingConnectionFactory;
+        void scheduleInactivityTimerTask();
+        void cancelInactivityTimerTask() noexcept;
 
-    void setState(State, const LocalException&);
-    void setState(State);
+        void scheduleCloseTimerTask();
+        void doApplicationClose() noexcept;
 
-    void initiateShutdown();
-    void sendHeartbeatNow();
+        Ice::CommunicatorPtr _communicator;
+        const IceInternal::InstancePtr _instance;
+        const IceInternal::TransceiverPtr _transceiver;
+        const std::shared_ptr<IceInternal::IdleTimeoutTransceiverDecorator> _idleTimeoutTransceiver; // can be null
 
-    bool initialize(IceInternal::SocketOperation = IceInternal::SocketOperationNone);
-    bool validate(IceInternal::SocketOperation = IceInternal::SocketOperationNone);
-    IceInternal::SocketOperation sendNextMessage(std::vector<OutgoingMessage>&);
-    IceInternal::AsyncStatus sendMessage(OutgoingMessage&);
+        const std::string _desc;
+        const std::string _type;
+        const IceInternal::ConnectorPtr _connector;
+        const IceInternal::EndpointIPtr _endpoint;
 
-#ifdef ICE_HAS_BZIP2
-    void doCompress(Ice::OutputStream&, Ice::OutputStream&);
-    void doUncompress(Ice::InputStream&, Ice::InputStream&);
-#endif
+        mutable Ice::ConnectionInfoPtr _info;
 
-    IceInternal::SocketOperation parseMessage(Ice::InputStream&, Int&, Int&, Byte&,
-                                              IceInternal::ServantManagerPtr&, ObjectAdapterPtr&,
-                                              IceInternal::OutgoingAsyncBasePtr&, ICE_DELEGATE(HeartbeatCallback)&, int&);
+        ObjectAdapterIPtr _adapter;
 
-    void invokeAll(Ice::InputStream&, Int, Int, Byte,
-                   const IceInternal::ServantManagerPtr&, const ObjectAdapterPtr&);
+        const bool _hasExecutor;
 
-    void scheduleTimeout(IceInternal::SocketOperation status);
-    void unscheduleTimeout(IceInternal::SocketOperation status);
+        const LoggerPtr _logger;
+        const IceInternal::TraceLevelsPtr _traceLevels;
+        const IceInternal::ThreadPoolPtr _threadPool;
 
-    Ice::ConnectionInfoPtr initConnectionInfo() const;
-    Ice::Instrumentation::ConnectionState toConnectionState(State) const;
+        const IceInternal::TimerPtr _timer;
 
-    IceInternal::SocketOperation read(IceInternal::Buffer&);
-    IceInternal::SocketOperation write(IceInternal::Buffer&);
+        const std::chrono::seconds _connectTimeout;
+        const std::chrono::seconds _closeTimeout;
+        const std::chrono::seconds _inactivityTimeout;
 
-    void reap();
+        IceInternal::TimerTaskPtr _inactivityTimerTask;
+        bool _inactivityTimerTaskScheduled{false};
 
-#ifndef ICE_CPP11_MAPPING
-    AsyncResultPtr _iceI_begin_flushBatchRequests(CompressBatch,
-                                                  const IceInternal::CallbackBasePtr&,
-                                                  const LocalObjectPtr&);
-    AsyncResultPtr _iceI_begin_heartbeat(const IceInternal::CallbackBasePtr&, const LocalObjectPtr&);
-#endif
+        std::function<void(ConnectionIPtr)> _connectionStartCompleted;
+        std::function<void(ConnectionIPtr, std::exception_ptr)> _connectionStartFailed;
 
-    Ice::CommunicatorPtr _communicator;
-    const IceInternal::InstancePtr _instance;
-    IceInternal::ACMMonitorPtr _monitor;
-    const IceInternal::TransceiverPtr _transceiver;
-    const std::string _desc;
-    const std::string _type;
-    const IceInternal::ConnectorPtr _connector;
-    const IceInternal::EndpointIPtr _endpoint;
+        // This function must be called outside the ConnectionI lock to avoid lock acquisition deadlocks.
+        const std::function<void(const ConnectionIPtr&)> _removeFromFactory;
 
-    mutable Ice::ConnectionInfoPtr _info;
+        const bool _warn;
+        const bool _warnUdp;
 
-    ObjectAdapterPtr _adapter;
-    IceInternal::ServantManagerPtr _servantManager;
+        const int _compressionLevel{1};
 
-    const bool _dispatcher;
-    const LoggerPtr _logger;
-    const IceInternal::TraceLevelsPtr _traceLevels;
-    const IceInternal::ThreadPoolPtr _threadPool;
+        std::int32_t _nextRequestId{1};
 
-    const IceUtil::TimerPtr _timer;
-    const IceUtil::TimerTaskPtr _writeTimeout;
-    bool _writeTimeoutScheduled;
-    const IceUtil::TimerTaskPtr _readTimeout;
-    bool _readTimeoutScheduled;
+        std::map<std::int32_t, IceInternal::OutgoingAsyncBasePtr> _asyncRequests;
+        std::map<std::int32_t, IceInternal::OutgoingAsyncBasePtr>::iterator _asyncRequestsHint;
 
-    StartCallbackPtr _startCallback;
+        std::exception_ptr _exception;
 
-    const bool _warn;
-    const bool _warnUdp;
+        const std::int32_t _messageSizeMax;
+        IceInternal::BatchRequestQueuePtr _batchRequestQueue;
 
-    IceUtil::Time _acmLastActivity;
+        std::deque<OutgoingMessage> _sendStreams;
 
-    const int _compressionLevel;
+        // Contains the message which is being received. If the connection is waiting to receive a message (_readHeader
+        // == true), its size is Protocol.headerSize. Otherwise, its size is the message size specified in the received
+        // message header.
+        Ice::InputStream _readStream;
 
-    Int _nextRequestId;
+        // When _readHeader is true, the next bytes we'll read are the header of a new message. When false, we're
+        // reading next the remainder of a message that was already partially received.
+        bool _readHeader{false};
 
-    std::map<Int, IceInternal::OutgoingAsyncBasePtr> _asyncRequests;
-    std::map<Int, IceInternal::OutgoingAsyncBasePtr>::iterator _asyncRequestsHint;
+        // Contains the message which is being sent. The write stream buffer is empty if no message is being sent.
+        Ice::OutputStream _writeStream;
 
-    IceInternal::UniquePtr<LocalException> _exception;
+        Observer _observer;
 
-    const size_t _messageSizeMax;
-    IceInternal::BatchRequestQueuePtr _batchRequestQueue;
+        // The upcall count keeps track of the number of dispatches, AMI (response) continuations, sent callbacks and
+        // connection establishment callbacks that have been started (or are about to be started) by a thread of the
+        // thread pool associated with this connection, and have not completed yet. All these operations except the
+        // connection establishment callbacks execute application code or code generated from Slice definitions.
+        int _upcallCount{0};
 
-    std::deque<OutgoingMessage> _sendStreams;
+        // The number of outstanding dispatches. Maintained only while state is StateActive or StateHolding.
+        int _dispatchCount = 0;
 
-    Ice::InputStream _readStream;
-    bool _readHeader;
-    Ice::OutputStream _writeStream;
+        // When we dispatch _maxDispatches concurrent requests, we stop reading the connection to back-pressure the
+        // peer. _maxDispatches <= 0 means no limit.
+        int _maxDispatches;
 
-    Observer _observer;
+        State _state{StateNotInitialized}; // The current state.
+        bool _shutdownInitiated{false};
+        bool _initialized{false};
+        bool _validated{false};
 
-    int _dispatchCount;
+        // When true, the application called close and Connection must close the connection when it receives the reply
+        // for the last outstanding invocation.
+        bool _closeRequested = false;
 
-    State _state; // The current state.
-    bool _shutdownInitiated;
-    bool _initialized;
-    bool _validated;
+        CloseCallback _closeCallback;
+        std::list<std::pair<std::function<void()>, std::function<void(std::exception_ptr)>>> _onClosedList;
 
-    ICE_DELEGATE(CloseCallback) _closeCallback;
-    ICE_DELEGATE(HeartbeatCallback) _heartbeatCallback;
-};
+        mutable std::mutex _mutex;
+        mutable std::condition_variable _conditionVariable;
 
+        // For locking the _mutex
+        template<typename T> friend class IceInternal::ThreadPoolMessage;
+    };
 }
 
 #endif