LibCore: Remove unused "visible for timer purposes" concept

This was a long-unused leftover from SerenityOS.

Libraries/LibCore/EventLoop.cpp

@@ -122,9 +122,9 @@ void EventLoop::unregister_signal(int handler_id)
     EventLoopManager::the().unregister_signal(handler_id);
 }
 
-intptr_t EventLoop::register_timer(EventReceiver& object, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible fire_when_not_visible)
+intptr_t EventLoop::register_timer(EventReceiver& object, int milliseconds, bool should_reload)
 {
-    return EventLoopManager::the().register_timer(object, milliseconds, should_reload, fire_when_not_visible);
+    return EventLoopManager::the().register_timer(object, milliseconds, should_reload);
 }
 
 void EventLoop::unregister_timer(intptr_t timer_id)

Libraries/LibCore/EventLoop.h

@@ -81,7 +81,7 @@ public:
     bool was_exit_requested();
 
     // The registration functions act upon the current loop of the current thread.
-    static intptr_t register_timer(EventReceiver&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible);
+    static intptr_t register_timer(EventReceiver&, int milliseconds, bool should_reload);
     static void unregister_timer(intptr_t timer_id);
 
     static void register_notifier(Badge<Notifier>, Notifier&);

Libraries/LibCore/EventLoopImplementation.h

@@ -23,7 +23,7 @@ public:
 
     virtual NonnullOwnPtr<EventLoopImplementation> make_implementation() = 0;
 
-    virtual intptr_t register_timer(EventReceiver&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible) = 0;
+    virtual intptr_t register_timer(EventReceiver&, int milliseconds, bool should_reload) = 0;
     virtual void unregister_timer(intptr_t timer_id) = 0;
 
     virtual void register_notifier(Notifier&) = 0;

Libraries/LibCore/EventLoopImplementationUnix.cpp

@@ -201,18 +201,11 @@ public:
             }
         }
 
-        // FIXME: While TimerShouldFireWhenNotVisible::Yes prevents the timer callback from being
-        //        called, it doesn't allow event loop to sleep since it needs to constantly check if
-        //        is_visible_for_timer_purposes changed. A better solution will be to unregister a
-        //        timer and register it back again when needed. This also has an added benefit of
-        //        making fire_when_not_visible and is_visible_for_timer_purposes obsolete.
-        if (fire_when_not_visible == TimerShouldFireWhenNotVisible::Yes || strong_owner->is_visible_for_timer_purposes())
         ThreadEventQueue::current().post_event(*strong_owner, make<TimerEvent>());
     }
 
     AK::Duration interval;
     bool should_reload { false };
-    TimerShouldFireWhenNotVisible fire_when_not_visible { TimerShouldFireWhenNotVisible::No };
     WeakPtr<EventReceiver> owner;
     pthread_t owner_thread { 0 };
     Atomic<bool> is_being_deleted { false };
@@ -618,7 +611,7 @@ void EventLoopManagerUnix::unregister_signal(int handler_id)
         info.signal_handlers.remove(remove_signal_number);
 }
 
-intptr_t EventLoopManagerUnix::register_timer(EventReceiver& object, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible fire_when_not_visible)
+intptr_t EventLoopManagerUnix::register_timer(EventReceiver& object, int milliseconds, bool should_reload)
 {
     VERIFY(milliseconds >= 0);
     auto& thread_data = ThreadData::the();
@@ -628,7 +621,6 @@ intptr_t EventLoopManagerUnix::register_timer(EventReceiver& object, int millise
     timer->interval = AK::Duration::from_milliseconds(milliseconds);
     timer->reload(MonotonicTime::now_coarse());
     timer->should_reload = should_reload;
-    timer->fire_when_not_visible = fire_when_not_visible;
     thread_data.timeouts.schedule_absolute(timer);
     return bit_cast<intptr_t>(timer);
 }

Libraries/LibCore/EventLoopImplementationUnix.h

@@ -17,7 +17,7 @@ public:
 
     virtual NonnullOwnPtr<EventLoopImplementation> make_implementation() override;
 
-    virtual intptr_t register_timer(EventReceiver&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible) override;
+    virtual intptr_t register_timer(EventReceiver&, int milliseconds, bool should_reload) override;
     virtual void unregister_timer(intptr_t timer_id) override;
 
     virtual void register_notifier(Notifier&) override;

Libraries/LibCore/EventLoopImplementationWindows.cpp

@@ -53,7 +53,6 @@ namespace Core {
 
 struct EventLoopTimer {
     WeakPtr<EventReceiver> owner;
-    TimerShouldFireWhenNotVisible fire_when_not_visible = TimerShouldFireWhenNotVisible::No;
 };
 
 struct ThreadData {
@@ -135,7 +134,6 @@ size_t EventLoopImplementationWindows::pump(PumpMode)
                 } else {
                     auto& timer = *timers.get(event_handles[i]);
                     if (auto strong_owner = timer.owner.strong_ref())
-                        if (timer.fire_when_not_visible == TimerShouldFireWhenNotVisible::Yes || strong_owner->is_visible_for_timer_purposes())
                         event_queue.post_event(*strong_owner, make<TimerEvent>());
                 }
             }
@@ -195,7 +193,7 @@ void EventLoopManagerWindows::unregister_notifier(Notifier& notifier)
         ThreadData::the()->notifiers.remove_all_matching([&](auto&, auto value) { return value == &notifier; });
 }
 
-intptr_t EventLoopManagerWindows::register_timer(EventReceiver& object, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible fire_when_not_visible)
+intptr_t EventLoopManagerWindows::register_timer(EventReceiver& object, int milliseconds, bool should_reload)
 {
     VERIFY(milliseconds >= 0);
     // FIXME: This is a temporary fix for issue #3641
@@ -211,7 +209,7 @@ intptr_t EventLoopManagerWindows::register_timer(EventReceiver& object, int mill
 
     auto& timers = ThreadData::the()->timers;
     VERIFY(!timers.get(timer).has_value());
-    timers.set(Handle(timer), { object, fire_when_not_visible });
+    timers.set(Handle(timer), { object });
     return reinterpret_cast<intptr_t>(timer);
 }
 

Libraries/LibCore/EventLoopImplementationWindows.h

@@ -17,7 +17,7 @@ public:
 
     virtual NonnullOwnPtr<EventLoopImplementation> make_implementation() override;
 
-    virtual intptr_t register_timer(EventReceiver&, int milliseconds, bool should_reload, TimerShouldFireWhenNotVisible) override;
+    virtual intptr_t register_timer(EventReceiver&, int milliseconds, bool should_reload) override;
     virtual void unregister_timer(intptr_t timer_id) override;
 
     virtual void register_notifier(Notifier&) override;

Libraries/LibCore/EventReceiver.cpp

@@ -46,14 +46,14 @@ void EventReceiver::custom_event(CustomEvent&)
 {
 }
 
-void EventReceiver::start_timer(int ms, TimerShouldFireWhenNotVisible fire_when_not_visible)
+void EventReceiver::start_timer(int ms)
 {
     if (m_timer_id) {
         dbgln("{} {:p} already has a timer!", class_name(), this);
         VERIFY_NOT_REACHED();
     }
 
-    m_timer_id = Core::EventLoop::register_timer(*this, ms, true, fire_when_not_visible);
+    m_timer_id = Core::EventLoop::register_timer(*this, ms, true);
 }
 
 void EventReceiver::stop_timer()
@@ -74,9 +74,4 @@ void EventReceiver::dispatch_event(Core::Event& e)
     event(e);
 }
 
-bool EventReceiver::is_visible_for_timer_purposes() const
-{
-    return true;
-}
-
 }

Libraries/LibCore/EventReceiver.h

@@ -19,11 +19,6 @@
 
 namespace Core {
 
-enum class TimerShouldFireWhenNotVisible {
-    No = 0,
-    Yes
-};
-
 #define C_OBJECT(klass)                                                                    \
 public:                                                                                    \
     virtual StringView class_name() const override                                         \
@@ -64,7 +59,7 @@ public:
     template<typename T>
     bool fast_is() const = delete;
 
-    void start_timer(int ms, TimerShouldFireWhenNotVisible = TimerShouldFireWhenNotVisible::No);
+    void start_timer(int ms);
     void stop_timer();
     bool has_timer() const { return m_timer_id; }
 
@@ -72,8 +67,6 @@ public:
 
     void dispatch_event(Core::Event&);
 
-    virtual bool is_visible_for_timer_purposes() const;
-
 protected:
     EventReceiver();
 

Libraries/LibCore/Forward.h

@@ -50,8 +50,6 @@ class UDPSocket;
 
 struct ProxyData;
 
-enum class TimerShouldFireWhenNotVisible;
-
 #ifdef AK_OS_MACH
 class MachPort;
 #endif

Libraries/LibWebView/EventLoop/EventLoopImplementationMacOS.h

@@ -16,7 +16,7 @@ class EventLoopManagerMacOS final : public Core::EventLoopManager {
 public:
     virtual NonnullOwnPtr<Core::EventLoopImplementation> make_implementation() override;
 
-    virtual intptr_t register_timer(Core::EventReceiver&, int interval_milliseconds, bool should_reload, Core::TimerShouldFireWhenNotVisible) override;
+    virtual intptr_t register_timer(Core::EventReceiver&, int interval_milliseconds, bool should_reload) override;
     virtual void unregister_timer(intptr_t timer_id) override;
 
     virtual void register_notifier(Core::Notifier&) override;

Libraries/LibWebView/EventLoop/EventLoopImplementationMacOS.mm

@@ -207,7 +207,7 @@ NonnullOwnPtr<Core::EventLoopImplementation> EventLoopManagerMacOS::make_impleme
     return EventLoopImplementationMacOS::create();
 }
 
-intptr_t EventLoopManagerMacOS::register_timer(Core::EventReceiver& receiver, int interval_milliseconds, bool should_reload, Core::TimerShouldFireWhenNotVisible should_fire_when_not_visible)
+intptr_t EventLoopManagerMacOS::register_timer(Core::EventReceiver& receiver, int interval_milliseconds, bool should_reload)
 {
     auto& thread_data = ThreadData::the();
 
@@ -225,12 +225,6 @@ intptr_t EventLoopManagerMacOS::register_timer(Core::EventReceiver& receiver, in
                 return;
             }
 
-            if (should_fire_when_not_visible == Core::TimerShouldFireWhenNotVisible::No) {
-                if (!receiver->is_visible_for_timer_purposes()) {
-                    return;
-                }
-            }
-
             Core::TimerEvent event;
             receiver->dispatch_event(event);
         });

Libraries/LibWebView/EventLoop/EventLoopImplementationQt.cpp

@@ -244,28 +244,24 @@ void EventLoopImplementationQt::set_main_loop()
     event_loop_manager.set_main_loop_signal_notifiers({});
 }
 
-static void qt_timer_fired(Core::TimerShouldFireWhenNotVisible should_fire_when_not_visible, Core::EventReceiver& object)
+static void qt_timer_fired(Core::EventReceiver& object)
 {
-    if (should_fire_when_not_visible == Core::TimerShouldFireWhenNotVisible::No) {
-        if (!object.is_visible_for_timer_purposes())
-            return;
-    }
     Core::TimerEvent event;
     object.dispatch_event(event);
 }
 
-intptr_t EventLoopManagerQt::register_timer(Core::EventReceiver& object, int milliseconds, bool should_reload, Core::TimerShouldFireWhenNotVisible should_fire_when_not_visible)
+intptr_t EventLoopManagerQt::register_timer(Core::EventReceiver& object, int milliseconds, bool should_reload)
 {
     auto timer = new QTimer;
     timer->setTimerType(Qt::PreciseTimer);
     timer->setInterval(milliseconds);
     timer->setSingleShot(!should_reload);
     auto weak_object = object.make_weak_ptr();
-    QObject::connect(timer, &QTimer::timeout, [should_fire_when_not_visible, weak_object = move(weak_object)] {
+    QObject::connect(timer, &QTimer::timeout, [weak_object = move(weak_object)] {
         auto object = weak_object.strong_ref();
         if (!object)
             return;
-        qt_timer_fired(should_fire_when_not_visible, *object);
+        qt_timer_fired(*object);
     });
     timer->start();
     return bit_cast<intptr_t>(timer);

Libraries/LibWebView/EventLoop/EventLoopImplementationQt.h

@@ -25,7 +25,7 @@ public:
     virtual ~EventLoopManagerQt() override;
     virtual NonnullOwnPtr<Core::EventLoopImplementation> make_implementation() override;
 
-    virtual intptr_t register_timer(Core::EventReceiver&, int milliseconds, bool should_reload, Core::TimerShouldFireWhenNotVisible) override;
+    virtual intptr_t register_timer(Core::EventReceiver&, int milliseconds, bool should_reload) override;
     virtual void unregister_timer(intptr_t timer_id) override;
 
     virtual void register_notifier(Core::Notifier&) override;

UI/Android/src/main/cpp/ALooperEventLoopImplementation.cpp

@@ -85,7 +85,7 @@ NonnullOwnPtr<Core::EventLoopImplementation> ALooperEventLoopManager::make_imple
     return ALooperEventLoopImplementation::create();
 }
 
-intptr_t ALooperEventLoopManager::register_timer(Core::EventReceiver& receiver, int milliseconds, bool should_reload, Core::TimerShouldFireWhenNotVisible visibility)
+intptr_t ALooperEventLoopManager::register_timer(Core::EventReceiver& receiver, int milliseconds, bool should_reload)
 {
     JavaEnvironment env(global_vm);
     auto& thread_data = EventLoopThreadData::the();
@@ -96,7 +96,7 @@ intptr_t ALooperEventLoopManager::register_timer(Core::EventReceiver& receiver,
     long timer_id = env.get()->CallLongMethod(m_timer_service, m_register_timer, timer, !should_reload, millis);
 
     // FIXME: Is there a race condition here? Maybe we should take a lock on the timers...
-    thread_data.timers.set(timer_id, { receiver.make_weak_ptr(), visibility });
+    thread_data.timers.set(timer_id, { receiver.make_weak_ptr() });
 
     return timer_id;
 }

UI/Android/src/main/cpp/ALooperEventLoopImplementation.h

@@ -23,7 +23,7 @@ public:
     virtual ~ALooperEventLoopManager() override;
     virtual NonnullOwnPtr<Core::EventLoopImplementation> make_implementation() override;
 
-    virtual intptr_t register_timer(Core::EventReceiver&, int milliseconds, bool should_reload, Core::TimerShouldFireWhenNotVisible) override;
+    virtual intptr_t register_timer(Core::EventReceiver&, int milliseconds, bool should_reload) override;
     virtual void unregister_timer(intptr_t timer_id) override;
 
     virtual void register_notifier(Core::Notifier&) override;
@@ -49,7 +49,6 @@ private:
 
 struct TimerData {
     WeakPtr<Core::EventReceiver> receiver;
-    Core::TimerShouldFireWhenNotVisible visibility;
 };
 
 struct EventLoopThreadData {

UI/Android/src/main/cpp/TimerExecutorService.cpp

@@ -25,10 +25,6 @@ Java_org_serenityos_ladybird_TimerExecutorService_00024Timer_nativeRun(JNIEnv*,
         if (!receiver)
             return;
 
-        if (timer_data->visibility == Core::TimerShouldFireWhenNotVisible::No)
-            if (!receiver->is_visible_for_timer_purposes())
-                return;
-
         event_loop_impl.post_event(*receiver, make<Core::TimerEvent>());
     }
     // Flush the event loop on this thread to keep any garbage from building up