Move Timer to IceInternal, add InlineTimerTask (#2923)

cpp/include/Ice/Communicator.h

@@ -409,7 +409,7 @@ namespace Ice
         friend ICE_API CommunicatorPtr initialize(StringSeq&, const InitializationData&, std::int32_t);
         friend ICE_API CommunicatorPtr initialize(const InitializationData&, std::int32_t);
         friend ICE_API IceInternal::InstancePtr IceInternal::getInstance(const Ice::CommunicatorPtr&);
-        friend ICE_API ::Ice::TimerPtr IceInternal::getInstanceTimer(const Ice::CommunicatorPtr&);
+        friend ICE_API IceInternal::TimerPtr IceInternal::getInstanceTimer(const Ice::CommunicatorPtr&);
 
         const IceInternal::InstancePtr _instance;
     };

cpp/include/Ice/Initialize.h

@@ -703,7 +703,7 @@ namespace IceInternal
     // to be used by modules such as Freeze.
     //
     ICE_API InstancePtr getInstance(const Ice::CommunicatorPtr&);
-    ICE_API Ice::TimerPtr getInstanceTimer(const Ice::CommunicatorPtr&);
+    ICE_API TimerPtr getInstanceTimer(const Ice::CommunicatorPtr&);
 }
 
 #endif

cpp/include/Ice/OutgoingAsync.h

@@ -144,7 +144,7 @@ namespace IceInternal
     // correct notified of failures and make sure the retry task is
     // correctly canceled when the invocation completes.
     //
-    class ICE_API ProxyOutgoingAsyncBase : public OutgoingAsyncBase, public Ice::TimerTask
+    class ICE_API ProxyOutgoingAsyncBase : public OutgoingAsyncBase, public TimerTask
     {
     public:
         virtual AsyncStatus invokeRemote(const Ice::ConnectionIPtr&, bool, bool) = 0;

cpp/include/Ice/Timer.h

@@ -18,7 +18,7 @@
 #include <stdexcept>
 #include <thread>
 
-namespace Ice
+namespace IceInternal
 {
     class Timer;
     using TimerPtr = std::shared_ptr<Timer>;
@@ -32,6 +32,18 @@ namespace Ice
     };
     using TimerTaskPtr = std::shared_ptr<TimerTask>;
 
+    // Adapts a function<void()> to a TimerTask.
+    class InlineTimerTask final : public TimerTask
+    {
+    public:
+        InlineTimerTask(std::function<void()> function) : _function(std::move(function)) {}
+
+        void runTimerTask() final { _function(); }
+
+    private:
+        std::function<void()> _function;
+    };
+
     // The timer class is used to schedule tasks for one-time execution or repeated execution. Tasks are executed by a
     // dedicated timer thread sequentially.
     class ICE_API Timer
@@ -43,6 +55,13 @@ namespace Ice
         // Destroy the timer and join the timer execution thread. Must not be called from a timer task.
         void destroy();
 
+        // Schedule a function-task for execution after a given delay.
+        template<class Rep, class Period>
+        void schedule(std::function<void()> function, const std::chrono::duration<Rep, Period>& delay)
+        {
+            schedule(std::make_shared<InlineTimerTask>(std::move(function)), delay);
+        }
+
         // Schedule task for execution after a given delay.
         template<class Rep, class Period>
         void schedule(const TimerTaskPtr& task, const std::chrono::duration<Rep, Period>& delay)

cpp/src/DataStorm/Instance.cpp

@@ -100,7 +100,7 @@ Instance::Instance(const Ice::CommunicatorPtr& communicator) : _communicator(com
 
     _executor = make_shared<CallbackExecutor>();
     _connectionManager = make_shared<ConnectionManager>(_executor);
-    _timer = make_shared<Ice::Timer>();
+    _timer = make_shared<IceInternal::Timer>();
     _traceLevels = make_shared<TraceLevels>(_communicator);
 }
 

cpp/src/DataStorm/Instance.h

@@ -93,7 +93,7 @@ namespace DataStormI
             return _executor;
         }
 
-        Ice::TimerPtr getTimer() const
+        IceInternal::TimerPtr getTimer() const
         {
             assert(_timer);
             return _timer;
@@ -126,7 +126,7 @@ namespace DataStormI
         std::optional<DataStormContract::LookupPrx> _lookup;
         std::shared_ptr<TraceLevels> _traceLevels;
         std::shared_ptr<CallbackExecutor> _executor;
-        Ice::TimerPtr _timer;
+        IceInternal::TimerPtr _timer;
         std::chrono::milliseconds _retryDelay;
         int _retryMultiplier;
         int _retryCount;

cpp/src/DataStorm/NodeSessionManager.cpp

@@ -8,7 +8,6 @@
 #include "Instance.h"
 #include "NodeI.h"
 #include "NodeSessionI.h"
-#include "TimerTaskI.h"
 #include "TopicFactoryI.h"
 #include "TraceUtil.h"
 
@@ -423,15 +422,14 @@ NodeSessionManager::disconnected(optional<NodePrx> node, optional<LookupPrx> loo
     else
     {
         instance->getTimer()->schedule(
-            make_shared<TimerTaskI>(
-                [=, this, self = shared_from_this()]
+            [=, this, self = shared_from_this()]
+            {
+                auto instance = _instance.lock();
+                if (instance)
                 {
-                    auto instance = _instance.lock();
-                    if (instance)
-                    {
-                        self->connect(lookup, _nodePrx);
-                    }
-                }),
+                    self->connect(lookup, _nodePrx);
+                }
+            },
             instance->getRetryDelay(_retryCount++));
     }
 }

cpp/src/DataStorm/SessionI.cpp

@@ -7,7 +7,6 @@
 #include "ConnectionManager.h"
 #include "Instance.h"
 #include "NodeI.h"
-#include "TimerTaskI.h"
 #include "TopicFactoryI.h"
 #include "TopicI.h"
 #include "TraceUtil.h"
@@ -693,7 +692,7 @@ SessionI::retry(optional<NodePrx> node, exception_ptr exception)
                 << " (ms) for peer to reconnect";
         }
 
-        _retryTask = make_shared<TimerTaskI>([self = shared_from_this()] { self->remove(); });
+        _retryTask = make_shared<IceInternal::InlineTimerTask>([self = shared_from_this()] { self->remove(); });
         _instance->getTimer()->schedule(_retryTask, delay);
     }
     else
@@ -736,7 +735,8 @@ SessionI::retry(optional<NodePrx> node, exception_ptr exception)
             return false;
         }
 
-        _retryTask = make_shared<TimerTaskI>([node, self = shared_from_this()] { self->reconnect(node); });
+        _retryTask =
+            make_shared<IceInternal::InlineTimerTask>([node, self = shared_from_this()] { self->reconnect(node); });
         _instance->getTimer()->schedule(_retryTask, delay);
     }
     return true;

cpp/src/DataStorm/SessionI.h

@@ -346,7 +346,7 @@ namespace DataStormI
         bool _destroyed;
         int _sessionInstanceId;
         int _retryCount;
-        Ice::TimerTaskPtr _retryTask;
+        IceInternal::TimerTaskPtr _retryTask;
 
         std::map<std::int64_t, TopicSubscribers> _topics;
         std::unique_lock<std::mutex>* _topicLock;

cpp/src/Ice/ConnectionFactory.cpp

@@ -69,7 +69,7 @@ namespace
         return nullptr;
     }
 
-    class StartAcceptor : public Ice::TimerTask, public std::enable_shared_from_this<StartAcceptor>
+    class StartAcceptor : public TimerTask, public std::enable_shared_from_this<StartAcceptor>
     {
     public:
         StartAcceptor(const IncomingConnectionFactoryPtr& factory, const InstancePtr& instance)

cpp/src/Ice/ConnectionI.cpp

@@ -38,7 +38,7 @@ using namespace IceInternal;
 
 namespace
 {
-    class ConnectTimerTask final : public Ice::TimerTask
+    class ConnectTimerTask final : public TimerTask
     {
     public:
         ConnectTimerTask(const Ice::ConnectionIPtr& connection) : _connection(connection) {}
@@ -55,7 +55,7 @@ namespace
         const weak_ptr<Ice::ConnectionI> _connection;
     };
 
-    class CloseTimerTask final : public Ice::TimerTask
+    class CloseTimerTask final : public TimerTask
     {
     public:
         CloseTimerTask(const Ice::ConnectionIPtr& connection) : _connection(connection) {}
@@ -72,7 +72,7 @@ namespace
         const weak_ptr<Ice::ConnectionI> _connection;
     };
 
-    class InactivityTimerTask final : public Ice::TimerTask
+    class InactivityTimerTask final : public TimerTask
     {
     public:
         InactivityTimerTask(const Ice::ConnectionIPtr& connection) : _connection(connection) {}

cpp/src/Ice/ConnectionI.h

@@ -347,13 +347,13 @@ namespace Ice
         const IceInternal::TraceLevelsPtr _traceLevels;
         const IceInternal::ThreadPoolPtr _threadPool;
 
-        const Ice::TimerPtr _timer;
+        const IceInternal::TimerPtr _timer;
 
         const std::chrono::seconds _connectTimeout;
         const std::chrono::seconds _closeTimeout;
         const std::chrono::seconds _inactivityTimeout;
 
-        Ice::TimerTaskPtr _inactivityTimerTask;
+        IceInternal::TimerTaskPtr _inactivityTimerTask;
         bool _inactivityTimerTaskScheduled;
 
         std::function<void(ConnectionIPtr)> _connectionStartCompleted;

cpp/src/Ice/IdleTimeoutTransceiverDecorator.cpp

@@ -13,7 +13,7 @@ using namespace IceInternal;
 
 namespace
 {
-    class HeartbeatTimerTask final : public Ice::TimerTask
+    class HeartbeatTimerTask final : public TimerTask
     {
     public:
         HeartbeatTimerTask(const ConnectionIPtr& connection) : _connection(connection) {}
@@ -31,7 +31,7 @@ namespace
         const weak_ptr<ConnectionI> _connection;
     };
 
-    class IdleCheckTimerTask final : public Ice::TimerTask
+    class IdleCheckTimerTask final : public TimerTask
     {
     public:
         IdleCheckTimerTask(const ConnectionIPtr& connection, const chrono::seconds& idleTimeout)

cpp/src/Ice/IdleTimeoutTransceiverDecorator.h

@@ -21,7 +21,7 @@ namespace IceInternal
         IdleTimeoutTransceiverDecorator(
             const TransceiverPtr& decoratee,
             const std::chrono::seconds& idleTimeout,
-            const Ice::TimerPtr& timer)
+            const IceInternal::TimerPtr& timer)
             : _decoratee(decoratee),
               _idleTimeout(idleTimeout),
               _timer(timer)
@@ -71,13 +71,13 @@ namespace IceInternal
     private:
         const TransceiverPtr _decoratee;
         const std::chrono::seconds _idleTimeout;
-        const Ice::TimerPtr _timer;
+        const IceInternal::TimerPtr _timer;
 
         bool _idleCheckEnabled = false;
 
         // Set by decoratorInit
-        Ice::TimerTaskPtr _heartbeatTimerTask;
-        Ice::TimerTaskPtr _idleCheckTimerTask;
+        IceInternal::TimerTaskPtr _heartbeatTimerTask;
+        IceInternal::TimerTaskPtr _idleCheckTimerTask;
     };
 }
 

cpp/src/Ice/Initialize.cpp

@@ -412,7 +412,7 @@ IceInternal::getInstance(const CommunicatorPtr& communicator)
     return communicator->_instance;
 }
 
-Ice::TimerPtr
+IceInternal::TimerPtr
 IceInternal::getInstanceTimer(const CommunicatorPtr& communicator)
 {
     return communicator->_instance->timer();

cpp/src/Ice/Instance.cpp

@@ -180,15 +180,15 @@ namespace IceInternal // Required because ObserverUpdaterI is a friend of Instan
     //
     // Timer specialization which supports the thread observer
     //
-    class ThreadObserverTimer final : public Ice::Timer
+    class ThreadObserverTimer final : public IceInternal::Timer
     {
     public:
         ThreadObserverTimer() : _hasObserver(false) {}
 
         void updateObserver(const Ice::Instrumentation::CommunicatorObserverPtr&);
 
     private:
-        void runTimerTask(const Ice::TimerTaskPtr&) final;
+        void runTimerTask(const TimerTaskPtr&) final;
 
         std::mutex _mutex;
         std::atomic<bool> _hasObserver;
@@ -210,7 +210,7 @@ ThreadObserverTimer::updateObserver(const Ice::Instrumentation::CommunicatorObse
 }
 
 void
-ThreadObserverTimer::runTimerTask(const Ice::TimerTaskPtr& task)
+ThreadObserverTimer::runTimerTask(const TimerTaskPtr& task)
 {
     if (_hasObserver)
     {
@@ -443,7 +443,7 @@ IceInternal::Instance::retryQueue()
     return _retryQueue;
 }
 
-Ice::TimerPtr
+IceInternal::TimerPtr
 IceInternal::Instance::timer()
 {
     lock_guard lock(_mutex);

cpp/src/Ice/Instance.h

@@ -83,7 +83,7 @@ namespace IceInternal
         EndpointHostResolverPtr endpointHostResolver();
         RetryQueuePtr retryQueue();
         const std::vector<int>& retryIntervals() const { return _retryIntervals; }
-        Ice::TimerPtr timer();
+        IceInternal::TimerPtr timer();
         EndpointFactoryManagerPtr endpointFactoryManager() const;
         Ice::PluginManagerPtr pluginManager() const;
         size_t messageSizeMax() const { return _messageSizeMax; }

cpp/src/Ice/RetryQueue.h

@@ -20,7 +20,7 @@ namespace IceInternal
     using OutgoingAsyncBasePtr = std::shared_ptr<OutgoingAsyncBase>;
     using ProxyOutgoingAsyncBasePtr = std::shared_ptr<ProxyOutgoingAsyncBase>;
 
-    class RetryTask : public Ice::TimerTask, public CancellationHandler, public std::enable_shared_from_this<RetryTask>
+    class RetryTask : public TimerTask, public CancellationHandler, public std::enable_shared_from_this<RetryTask>
     {
     public:
         RetryTask(const InstancePtr&, const RetryQueuePtr&, const ProxyOutgoingAsyncBasePtr&);

cpp/src/IceDiscovery/LookupI.h

@@ -19,7 +19,7 @@ namespace IceDiscovery
 {
     class LookupI;
 
-    class Request : public Ice::TimerTask
+    class Request : public IceInternal::TimerTask
     {
     public:
         Request(const LookupIPtr&, int);
@@ -137,7 +137,7 @@ namespace IceDiscovery
         void objectRequestTimedOut(const ObjectRequestPtr&);
         void objectRequestException(const ObjectRequestPtr&, std::exception_ptr);
 
-        const Ice::TimerPtr& timer() { return _timer; }
+        const IceInternal::TimerPtr& timer() { return _timer; }
 
         int latencyMultiplier() { return _latencyMultiplier; }
 
@@ -150,7 +150,7 @@ namespace IceDiscovery
         const int _latencyMultiplier;
         const std::string _domainId;
 
-        Ice::TimerPtr _timer;
+        IceInternal::TimerPtr _timer;
         bool _warnOnce;
 
         std::map<Ice::Identity, ObjectRequestPtr> _objectRequests;

cpp/src/IceGrid/Allocatable.h

@@ -17,7 +17,7 @@ namespace IceGrid
     class Allocatable;
     class SessionI;
 
-    class AllocationRequest : public Ice::TimerTask, public std::enable_shared_from_this<AllocationRequest>
+    class AllocationRequest : public IceInternal::TimerTask, public std::enable_shared_from_this<AllocationRequest>
     {
     public:
         virtual ~AllocationRequest() = default;