| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef SERVICES_WS_EVENT_QUEUE_H_ |
| #define SERVICES_WS_EVENT_QUEUE_H_ |
| |
| #include <stdint.h> |
| |
| #include <memory> |
| #include <set> |
| |
| #include "base/callback_forward.h" |
| #include "base/component_export.h" |
| #include "base/containers/circular_deque.h" |
| #include "base/macros.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/optional.h" |
| #include "base/timer/timer.h" |
| #include "services/ws/ids.h" |
| #include "services/ws/window_service_observer.h" |
| |
| namespace aura { |
| class WindowTreeHost; |
| } |
| |
| namespace ui { |
| class Event; |
| } |
| |
| namespace ws { |
| |
| class HostEventDispatcher; |
| class HostEventQueue; |
| class WindowService; |
| |
| // EventQueue handles the actual queuing, waiting and dispatching of events. |
| // HostEventQueues calls into this. EventQueue tracks the dispatch by way of |
| // being a WindowServiceObserver. EventQueue also supports adding a callback |
| // that is notified when the queue is empty. |
| class COMPONENT_EXPORT(WINDOW_SERVICE) EventQueue |
| : public WindowServiceObserver { |
| public: |
| explicit EventQueue(WindowService* service); |
| ~EventQueue() override; |
| |
| // Creates a new HostEventQueue. |
| std::unique_ptr<HostEventQueue> RegisterHostEventDispatcher( |
| aura::WindowTreeHost* window_tree_host, |
| HostEventDispatcher* dispatcher); |
| |
| // Convenience to locate the HostEventDispatcher for |window_tree_host| |
| // and call DispatchOrQueueEvent() on it with |event|. If |honor_rewriters| |
| // is true, the event is passed through EventRewriters first. Events received |
| // from the platform go through EventRewriters, so generally |
| // |honor_rewriters| should be true, remote injection may need to circumvent |
| // that though. |
| static void DispatchOrQueueEvent(WindowService* service, |
| aura::WindowTreeHost* window_tree_host, |
| ui::Event* event, |
| bool honor_rewriters); |
| |
| // Returns true if |event| should be queued at this time. |
| bool ShouldQueueEvent(HostEventQueue* host, const ui::Event& event); |
| |
| // Notifies |closure| when this EventQueue is ready to dispatch an event, |
| // which may be immediately. |
| void NotifyWhenReadyToDispatch(base::OnceClosure closure); |
| |
| // Returns the HostEventQueue associated with the specified display. |
| HostEventQueue* GetHostEventQueueForDisplay(int64_t display_id); |
| |
| private: |
| friend class EventQueueTestHelper; |
| friend class HostEventQueue; |
| |
| struct QueuedEvent; |
| |
| // Tracks an event that was sent to a client. |
| struct InFlightEvent { |
| ClientSpecificId client_id = 0u; |
| uint32_t event_id = 0u; |
| }; |
| |
| // Called by |ack_timer_| if the client does not respond to the event in a |
| // timely manner. |
| void OnClientTookTooLongToAckEvent(); |
| |
| // Called when a HostEventQueue is created/deleted. |
| void OnHostEventQueueCreated(HostEventQueue* host); |
| void OnHostEventQueueDestroyed(HostEventQueue* host); |
| |
| // Adds |event| to |queued_events_|. |
| void QueueEvent(HostEventQueue* host, |
| const ui::Event& event, |
| bool honor_rewriters); |
| |
| // Processes QueuedEvents until |queued_events_| is empty, or there is an |
| // event sent to a client. |
| void DispatchNextQueuedEvent(); |
| |
| // WindowServiceObserver: |
| void OnWillSendEventToClient(ClientSpecificId client_id, |
| uint32_t event_id, |
| const ui::Event& event) override; |
| void OnClientAckedEvent(ClientSpecificId client_id, |
| uint32_t event_id) override; |
| void OnWillDestroyClient(ClientSpecificId client_id) override; |
| |
| WindowService* window_service_; |
| |
| base::circular_deque<std::unique_ptr<QueuedEvent>> queued_events_; |
| |
| // Set when an event has been sent to a client. |
| base::Optional<InFlightEvent> in_flight_event_; |
| |
| // Set of HostEventQueues. |
| std::set<HostEventQueue*> host_event_queues_; |
| |
| base::OneShotTimer ack_timer_; |
| |
| // Because of destruction order HostEventQueues may outlive this. |
| base::WeakPtrFactory<EventQueue> weak_factory_{this}; |
| |
| DISALLOW_COPY_AND_ASSIGN(EventQueue); |
| }; |
| |
| } // namespace ws |
| |
| #endif // SERVICES_WS_EVENT_QUEUE_H_ |