| // 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_INJECTED_EVENT_HANDLER_H_ |
| #define SERVICES_WS_INJECTED_EVENT_HANDLER_H_ |
| |
| #include <memory> |
| |
| #include "base/callback.h" |
| #include "base/macros.h" |
| #include "services/ws/window_service_observer.h" |
| #include "ui/aura/window_event_dispatcher_observer.h" |
| #include "ui/aura/window_observer.h" |
| #include "ui/events/event_handler.h" |
| |
| namespace aura { |
| class WindowTreeHost; |
| } |
| |
| namespace ui { |
| |
| class Event; |
| } |
| |
| namespace ws { |
| |
| class WindowService; |
| |
| // InjectedEventHandler is responsible for injecting a single event from a |
| // remote client and notifying a callback when the client acks the event (or |
| // it is determined the client will never ack the event). |
| // |
| // Exported for tests. |
| // |
| // Implementation note: an event may be handled in any of the following |
| // ways: |
| // . It may be dispatched to remote client. This is detected by way of |
| // OnWillSendEventToClient(). |
| // . It may be handled locally. |
| // . It may be held and processed later on. This happens if pointer events are |
| // being held if WindowEventDispatcher. See |
| // WindowEventDispatcher::HoldPointerMoves() for details. |
| // For the case of the event being sent to a remote client this has to ensure |
| // if the remote client, or WindowTreeHost is destroyed, then no ack is |
| // received. |
| class COMPONENT_EXPORT(WINDOW_SERVICE) InjectedEventHandler |
| : public aura::WindowEventDispatcherObserver, |
| public WindowServiceObserver, |
| public aura::WindowObserver, |
| public ui::EventHandler { |
| public: |
| using ResultCallback = base::OnceClosure; |
| |
| InjectedEventHandler(WindowService* window_service, |
| aura::WindowTreeHost* window_tree_host); |
| ~InjectedEventHandler() override; |
| |
| // Injects the event. This should be called only once. This synchronously |
| // dispatches the event. If the event is completely processed synchronously, |
| // then |result_callback| is run immediately. Otherwise |result_callback| is |
| // run when the client acks the event, or it's known that the client will |
| // never ack event event. If the InjectedEventHandler is destroyed before the |
| // ack, then |result_callback| is never run. |
| void Inject(std::unique_ptr<ui::Event> event, ResultCallback result_callback); |
| |
| private: |
| // Tracks the client and identifier for an event that this object is waiting |
| // on. |
| struct EventId { |
| // Uniquely identifies the client. |
| ClientSpecificId client_id = 0u; |
| |
| // Assigned by the WindowTree whose id matches |client_id| for the event. |
| uint32_t event_id = 0u; |
| }; |
| |
| // Called when the event has been acked, or it's known an event will never be |
| // received. |
| void NotifyCallback(); |
| |
| // Removes the observers installed in the constructor. This is called when |
| // its known this object no longer is waiting for the event to be acked. |
| void RemoveObservers(); |
| |
| // aura::WindowEventDispatcherObserver: |
| void OnWindowEventDispatcherFinishedProcessingEvent( |
| aura::WindowEventDispatcher* dispatcher) override; |
| void OnWindowEventDispatcherDispatchedHeldEvents( |
| aura::WindowEventDispatcher* dispatcher) override; |
| |
| // aura::WindowObserver: |
| void OnWindowDestroying(aura::Window* window) override; |
| |
| // WindowServiceObserver: |
| void OnWillSendEventToClient(ClientSpecificId client_id, |
| uint32_t event_id) override; |
| void OnClientAckedEvent(ClientSpecificId client_id, |
| uint32_t event_id) override; |
| void OnWillDestroyClient(ClientSpecificId client_id) override; |
| |
| // EventHandler: |
| void OnEvent(ui::Event* event) override; |
| |
| WindowService* window_service_; |
| aura::WindowTreeHost* window_tree_host_; |
| ResultCallback result_callback_; |
| |
| // Non-null if waiting on an ack from a client. |
| std::unique_ptr<EventId> event_id_; |
| |
| bool event_dispatched_ = false; |
| |
| DISALLOW_COPY_AND_ASSIGN(InjectedEventHandler); |
| }; |
| |
| } // namespace ws |
| |
| #endif // SERVICES_WS_INJECTED_EVENT_HANDLER_H_ |