| // 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_WINDOW_TREE_H_ |
| #define SERVICES_WS_WINDOW_TREE_H_ |
| |
| #include <memory> |
| #include <queue> |
| #include <set> |
| #include <unordered_map> |
| #include <vector> |
| |
| #include "base/component_export.h" |
| #include "base/containers/flat_map.h" |
| #include "base/macros.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/optional.h" |
| #include "services/ws/focus_handler.h" |
| #include "services/ws/ids.h" |
| #include "services/ws/public/mojom/window_tree.mojom.h" |
| #include "ui/aura/client/capture_client_observer.h" |
| #include "ui/aura/window_observer.h" |
| #include "ui/aura/window_occlusion_tracker.h" |
| |
| namespace aura { |
| class Window; |
| } |
| |
| namespace gfx { |
| class PointF; |
| } |
| |
| namespace ui { |
| class Event; |
| } |
| |
| namespace ws { |
| |
| class ClientChangeTracker; |
| class ClientRoot; |
| class Embedding; |
| class EventObserverHelper; |
| class FocusHandler; |
| class ProxyWindow; |
| class TopmostWindowObserver; |
| class WindowManagerInterface; |
| class WindowService; |
| |
| // WindowTree manages a client connected to the Window Service. WindowTree |
| // provides the implementation of mojom::WindowTree that the client talks |
| // to. WindowTree implements the mojom::WindowTree interface on top of aura. |
| // That is, changes to the aura Window hierarchy are mirrored to the |
| // mojom::WindowTreeClient interface. Similarly, changes from the client by |
| // way of the mojom::WindowTree interface modify the underlying aura |
| // Windows. |
| // |
| // WindowTree is created in two distinct ways: |
| // . when the client is embedded in a specific aura::Window, by way of |
| // WindowTree::Embed(). Use InitForEmbed(). This configuration has only a |
| // single ClientRoot. |
| // . by way of a WindowTreeFactory. In this mode the client has no initial |
| // roots. To create a root the client requests a top-level window. Use |
| // InitFromFactory() for this. In this configuration there is a ClientRoot |
| // per top-level. |
| // |
| // Typically instances of WindowTree are owned by a WindowTreeBinding that is |
| // created via WindowTreeFactory, but that is not necessary (in particular tests |
| // often do not use WindowTreeBinding). |
| class COMPONENT_EXPORT(WINDOW_SERVICE) WindowTree |
| : public mojom::WindowTree, |
| public aura::WindowObserver, |
| public aura::client::CaptureClientObserver { |
| public: |
| enum class ConnectionType { |
| // This client is the result of an embedding, InitForEmbed() was called. |
| kEmbedding, |
| |
| // This client is not the result of an embedding. More specifically |
| // InitFromFactory() was called. Generally this means the client first |
| // connected to mojom::WindowTreeFactory and then called |
| // mojom::WindowTreeFactory::CreateWindowTree(). |
| kOther, |
| }; |
| |
| WindowTree(WindowService* window_service, |
| ClientSpecificId client_id, |
| mojom::WindowTreeClient* client, |
| const std::string& client_name); |
| ~WindowTree() override; |
| |
| // See class description for details on Init variants. |
| void InitForEmbed(aura::Window* root, mojom::WindowTreePtr window_tree_ptr); |
| void InitFromFactory(); |
| |
| ClientSpecificId client_id() const { return client_id_; } |
| |
| // Notifies the client than an event has been received. |
| void SendEventToClient(aura::Window* window, const ui::Event& event); |
| |
| // Notifies the client that an event matching an observer has been received. |
| void SendObservedEventToClient(int64_t display_id, |
| std::unique_ptr<ui::Event> event); |
| |
| // Returns the aura::Window associated with the specified transport id; null |
| // if |transport_window_id| is not a valid id for a window. |
| aura::Window* GetWindowByTransportId(Id transport_window_id); |
| |
| // Returns true if |window| was created by the client calling |
| // NewTopLevelWindow(). |
| bool IsTopLevel(aura::Window* window); |
| |
| // Asks the client to close |window|. |window| must be a top-level window. |
| void RequestClose(ProxyWindow* window); |
| |
| // Called when an Embedding is destroyed. This is only called for Embeddings |
| // that do not own the WindowTree (see Embedding for more details on when this |
| // happens). |
| void OnEmbeddingDestroyed(Embedding* embedding); |
| |
| // Sends the topmost window information to the client. There can be multiple |
| // windows, as described for OnTopmostWindowChanged() in window_tree.mojom. |
| void SendTopmostWindows(const std::vector<aura::Window*>& topmosts); |
| |
| // Notifies the client that the occlusion state of |windows| have changed. |
| void SendOcclusionStates(const std::set<aura::Window*>& windows); |
| |
| // Called from WindowService to update display id of ClientRoots contained |
| // by the root windows. See WindowService::OnWindowTreeHostsSwappedDisplays |
| // for details. |
| void OnWindowTreeHostsSwappedDisplays(aura::Window* new_primary_root, |
| aura::Window* old_primary_root); |
| |
| WindowService* window_service() { return window_service_; } |
| |
| // Returns the ClientWindowId for the window the client previously supplied |
| // to ScheduleEmbedForExistingClient(). If the client did not call |
| // ScheduleEmbedForExistingClient() with |embed_token|, an invalid |
| // ClientWindowId is returned. |
| ClientWindowId RemoveScheduledEmbedUsingExistingClient( |
| const base::UnguessableToken& embed_token); |
| |
| // Completes a previous call to ScheduleEmbedForExistingClient(). |
| void CompleteScheduleEmbedForExistingClient( |
| aura::Window* window, |
| const ClientWindowId& id, |
| const base::UnguessableToken& token); |
| |
| const std::string& client_name() const { return client_name_; } |
| |
| ConnectionType connection_type() const { return connection_type_; } |
| |
| // Returns the first ClientRoot that has its compositor frame sink created. |
| ClientRoot* GetFirstRootWithCompositorFrameSink(); |
| |
| // Returns true if |window| has been exposed to this client. A client |
| // typically only sees a limited set of windows that may exist. The set of |
| // windows exposed to the client are referred to as the known windows. |
| bool IsWindowKnown(aura::Window* window) const; |
| |
| Id TransportIdForWindow(aura::Window* window) const; |
| |
| ClientWindowId ClientWindowIdForWindow(aura::Window* window) const; |
| |
| // If |window| is a client root, the ClientRoot is returned. This does not |
| // recurse. |
| ClientRoot* GetClientRootForWindow(aura::Window* window); |
| |
| // Converts an Event's root_location as supplied to the window service to be |
| // relative to the nearest client root of |window|. The returned value should |
| // used as the root_location() for Events supplied to clients. |
| gfx::PointF ConvertRootLocationForClient(aura::Window* window, |
| const gfx::PointF& root_location); |
| |
| // Sends CleanupGestureState mojo call for |window| to the window tree client. |
| void CleanupGestureState(aura::Window* window); |
| |
| bool IsMovingWindow() const { return window_moving_ != nullptr; } |
| |
| private: |
| friend class ClientRoot; |
| // TODO(sky): WindowTree should be refactored such that it is not |
| // necessary to friend this. |
| friend class FocusHandler; |
| friend class WindowTreeTestHelper; |
| |
| struct InFlightEvent; |
| |
| using ClientRoots = std::vector<std::unique_ptr<ClientRoot>>; |
| |
| enum class DeleteClientRootReason { |
| // The window is being destroyed. |
| kDeleted, |
| |
| // Another client is being embedded in the window. |
| kEmbed, |
| |
| // The embedded client explicitly asked to be unembedded. |
| kUnembed, |
| |
| // Called when the ClientRoot is deleted from the WindowTree destructor. |
| kDestructor, |
| }; |
| |
| // Used to track every window known to the client. |
| struct KnownWindow { |
| KnownWindow(); |
| ~KnownWindow(); |
| |
| // Id for the window. |
| ClientWindowId client_window_id; |
| |
| // If non-null, the client created the window and owns it. During window |
| // destruction this may be destroyed before the entry is moved. If you need |
| // to know if the client created the window, use the |is_client_created|. |
| std::unique_ptr<aura::Window> owned_window; |
| |
| bool is_client_created = false; |
| }; |
| |
| // Creates a new ClientRoot. The returned ClientRoot is owned by this. |
| // |is_top_level| is true if this is called from |
| // WindowTree::NewTopLevelWindow(). |
| ClientRoot* CreateClientRoot(aura::Window* window, bool is_top_level); |
| void DeleteClientRoot(ClientRoot* client_root, DeleteClientRootReason reason); |
| void DeleteClientRootWithRoot(aura::Window* window); |
| |
| aura::Window* GetWindowByClientId(const ClientWindowId& id); |
| |
| // Returns true if |this| created |window|. |
| bool IsClientCreatedWindow(aura::Window* window); |
| bool IsClientRootWindow(aura::Window* window); |
| |
| // Returns the ClientRoot that |window| is parented to, null if |window| is |
| // not in a ClientRoot. |
| ClientRoot* FindClientRootContaining(aura::Window* window); |
| |
| ClientRoots::iterator FindClientRootWithRoot(aura::Window* window); |
| |
| bool IsWindowRootOfAnotherClient(aura::Window* window) const; |
| |
| // Returns true if |window| has an ancestor that intercepts events. |
| bool DoesAnyAncestorInterceptEvents(ProxyWindow* window); |
| |
| // Called when one of the windows known to the client loses capture. |
| // |lost_capture| is the window that had capture. |
| void OnCaptureLost(aura::Window* lost_capture); |
| |
| // Callback from WindowServiceDelegate::RunWindowMoveLoop(). |change_id| is |
| // the id at the time the move-loop was initiated. |result| is the result of |
| // the move loop (true for success). |
| void OnPerformWindowMoveDone(uint32_t change_id, bool result); |
| |
| // Scheduled from PerformDragDrop to run drag loop with mojo stack unwinded. |
| void DoPerformDragDrop( |
| uint32_t change_id, |
| Id source_window_id, |
| const gfx::Point& screen_location, |
| const base::flat_map<std::string, std::vector<uint8_t>>& drag_data, |
| const gfx::ImageSkia& drag_image, |
| const gfx::Vector2d& drag_image_offset, |
| uint32_t drag_operation, |
| ui::mojom::PointerKind source); |
| |
| // Callback from WindowServiceDelegate::RunDragLoop(). |change_id| is |
| // the id at the time the drag loop was initiated. |result| is the result of |
| // the drag (the final drag operation performed, or DRAG_NONE when the drag |
| // fails or gets canceled). |
| void OnPerformDragDropDone(uint32_t change_id, int drag_result); |
| |
| // Returns the first window in |known_windows_map_| that was created by |
| // the client; null if the client did not create an windows. |
| aura::Window* FindFirstClientCreatedWindow(); |
| |
| // Called for windows created by the client (including top-levels). |
| aura::Window* AddClientCreatedWindow( |
| const ClientWindowId& id, |
| bool is_top_level, |
| std::unique_ptr<aura::Window> window_ptr); |
| |
| // Adds/removes a Window from the set of windows known to the client. This |
| // also adds or removes any observers that may need to be installed. |
| void AddWindowToKnownWindows(aura::Window* window, |
| const ClientWindowId& id, |
| std::unique_ptr<aura::Window> owned_window); |
| |
| // |delete_if_owned| indicates if |window| should be deleted if this client |
| // created it. |delete_if_owned| is false only if the window was externally |
| // deleted. |
| void RemoveWindowFromKnownWindows(aura::Window* window, bool delete_if_owned); |
| |
| // Unregisters |window| and all its descendants. This stops at windows created |
| // by this client, adding to |created_windows|. |
| void RemoveWindowFromKnownWindowsRecursive( |
| aura::Window* window, |
| std::vector<aura::Window*>* created_windows); |
| |
| // Returns true if |id| may be used for a new Window. Clients have certain |
| // restrictions placed on what ids they may use (and that an id isn't |
| // reused). |
| bool IsValidIdForNewWindow(const ClientWindowId& id) const; |
| |
| // Returns the id to send to the client for a ClientWindowId. Windows that |
| // were created by this client always have the high bits set to 0 (because |
| // the client doesn't know its own id). |
| Id ClientWindowIdToTransportId(const ClientWindowId& client_window_id) const; |
| |
| // Returns the ClientWindowId from a transport id. Uses |client_id_| as the |
| // ClientWindowId::client_id part if invalid. This function does a straight |
| // mapping, there may not be a window with the returned id. |
| ClientWindowId MakeClientWindowId(Id transport_window_id) const; |
| |
| std::vector<mojom::WindowDataPtr> WindowsToWindowDatas( |
| const std::vector<aura::Window*>& windows); |
| mojom::WindowDataPtr WindowToWindowData(aura::Window* window); |
| |
| // Returns the WindowTreeClient previously scheduled for an embed with the |
| // given |token| from ScheduleEmbed(). If this client is the result of an |
| // Embed() and ScheduleEmbed() was not called on this client, then this |
| // recurses to WindowTrees that embedded this tree. |visited_trees| contains |
| // the WindowTrees that have already been visited. Recursing enables an |
| // ancestor to call ScheduleEmbed() and the ancestor to communicate the |
| // token with the client. |
| mojom::WindowTreeClientPtr GetAndRemoveScheduledEmbedWindowTreeClient( |
| const base::UnguessableToken& token, |
| std::set<WindowTree*>* visited_trees); |
| |
| // Methods with the name Impl() mirror those of mojom::WindowTree. The |
| // return value indicates whether they succeeded or not. Generally failure |
| // means the operation was not allowed. |
| bool NewWindowImpl( |
| const ClientWindowId& client_window_id, |
| const std::map<std::string, std::vector<uint8_t>>& properties); |
| bool DeleteWindowImpl(const ClientWindowId& window_id); |
| bool SetCaptureImpl(const ClientWindowId& window_id); |
| bool ReleaseCaptureImpl(const ClientWindowId& window_id); |
| bool AddWindowImpl(const ClientWindowId& parent_id, |
| const ClientWindowId& child_id); |
| bool RemoveWindowFromParentImpl(const ClientWindowId& client_window_id); |
| bool AddTransientWindowImpl(const ClientWindowId& parent_window_id, |
| const ClientWindowId& transient_window_id); |
| bool RemoveTransientWindowFromParentImpl(const ClientWindowId& transient_id); |
| bool SetModalTypeImpl(const ClientWindowId& client_window_id, |
| ui::ModalType type); |
| bool SetWindowVisibilityImpl(const ClientWindowId& window_id, bool visible); |
| bool SetWindowPropertyImpl(const ClientWindowId& window_id, |
| const std::string& name, |
| const base::Optional<std::vector<uint8_t>>& value); |
| bool EmbedImpl(const ClientWindowId& window_id, |
| mojom::WindowTreeClientPtr window_tree_client_ptr, |
| mojom::WindowTreeClient* window_tree_client, |
| uint32_t flags); |
| bool SetWindowOpacityImpl(const ClientWindowId& window_id, float opacity); |
| bool SetWindowBoundsImpl(const ClientWindowId& window_id, |
| const gfx::Rect& bounds, |
| const base::Optional<viz::LocalSurfaceIdAllocation>& |
| local_surface_id_allocation); |
| bool SetWindowTransformImpl(const ClientWindowId& window_id, |
| const gfx::Transform& transform); |
| bool ReorderWindowImpl(const ClientWindowId& window_id, |
| const ClientWindowId& relative_window_id, |
| mojom::OrderDirection direction); |
| std::vector<aura::Window*> GetWindowTreeImpl(const ClientWindowId& window_id); |
| bool SetFocusImpl(const ClientWindowId& window_id); |
| bool SetCursorImpl(const ClientWindowId& window_id, ui::Cursor cursor); |
| bool StackAboveImpl(const ClientWindowId& above_window_id, |
| const ClientWindowId& below_window_id); |
| bool StackAtTopImpl(const ClientWindowId& window_id); |
| |
| void GetWindowTreeRecursive(aura::Window* window, |
| std::vector<aura::Window*>* windows); |
| |
| // Called when the client associated with an Embedding created by this object |
| // disconnects. This deletes |embedding|, which deletes the embedded client. |
| void OnEmbeddedClientConnectionLost(Embedding* embedding); |
| |
| // aura::WindowObserver: |
| void OnWindowHierarchyChanging(const HierarchyChangeParams& params) override; |
| void OnWindowDestroyed(aura::Window* window) override; |
| void OnWindowVisibilityChanging(aura::Window* window, bool visible) override; |
| |
| // aura::client::CaptureClientObserver: |
| void OnCaptureChanged(aura::Window* lost_capture, |
| aura::Window* gained_capture) override; |
| |
| // mojom::WindowTree: |
| void NewWindow( |
| uint32_t change_id, |
| Id transport_window_id, |
| const base::Optional<base::flat_map<std::string, std::vector<uint8_t>>>& |
| transport_properties) override; |
| void NewTopLevelWindow( |
| uint32_t change_id, |
| Id transport_window_id, |
| const base::flat_map<std::string, std::vector<uint8_t>>& properties) |
| override; |
| void DeleteWindow(uint32_t change_id, Id transport_window_id) override; |
| void SetCapture(uint32_t change_id, Id transport_window_id) override; |
| void ReleaseCapture(uint32_t change_id, Id transport_window_id) override; |
| void ObserveEventTypes( |
| const std::vector<ui::mojom::EventType>& types) override; |
| void SetWindowBounds(uint32_t change_id, |
| Id window_id, |
| const gfx::Rect& bounds, |
| const base::Optional<viz::LocalSurfaceIdAllocation>& |
| local_surface_id_allocation) override; |
| void UpdateLocalSurfaceIdFromChild(Id transport_window_id, |
| const viz::LocalSurfaceIdAllocation& |
| local_surface_id_allocation) override; |
| void AllocateLocalSurfaceId(Id transport_window_id) override; |
| void SetWindowTransform(uint32_t change_id, |
| Id transport_window_id, |
| const gfx::Transform& transform) override; |
| void SetClientArea(Id transport_window_id, |
| const gfx::Insets& insets, |
| const base::Optional<std::vector<gfx::Rect>>& |
| additional_client_areas) override; |
| void SetHitTestInsets(Id transport_window_id, |
| const gfx::Insets& mouse, |
| const gfx::Insets& touch) override; |
| void SetShape(Id transport_window_id, |
| const std::vector<gfx::Rect>& shape) override; |
| void AttachFrameSinkId(Id transport_window_id, |
| const viz::FrameSinkId& f) override; |
| void UnattachFrameSinkId(Id transport_window_id) override; |
| void SetCanAcceptDrops(Id window_id, bool accepts_drops) override; |
| void SetWindowVisibility(uint32_t change_id, |
| Id transport_window_id, |
| bool visible) override; |
| void SetWindowProperty( |
| uint32_t change_id, |
| Id window_id, |
| const std::string& name, |
| const base::Optional<std::vector<uint8_t>>& value) override; |
| void SetWindowOpacity(uint32_t change_id, |
| Id transport_window_id, |
| float opacity) override; |
| void AttachCompositorFrameSink( |
| Id transport_window_id, |
| viz::mojom::CompositorFrameSinkRequest compositor_frame_sink, |
| viz::mojom::CompositorFrameSinkClientPtr client) override; |
| void AddWindow(uint32_t change_id, Id parent_id, Id child_id) override; |
| void RemoveWindowFromParent(uint32_t change_id, Id window_id) override; |
| void AddTransientWindow(uint32_t change_id, |
| Id window_id, |
| Id transient_window_id) override; |
| void RemoveTransientWindowFromParent(uint32_t change_id, |
| Id transient_window_id) override; |
| void SetModalType(uint32_t change_id, |
| Id window_id, |
| ui::ModalType type) override; |
| void ReorderWindow(uint32_t change_id, |
| Id transport_window_id, |
| Id transport_relative_window_id, |
| mojom::OrderDirection direction) override; |
| void GetWindowTree(Id window_id, GetWindowTreeCallback callback) override; |
| void Embed(Id transport_window_id, |
| mojom::WindowTreeClientPtr client_ptr, |
| uint32_t embed_flags, |
| EmbedCallback callback) override; |
| void ScheduleEmbed(mojom::WindowTreeClientPtr client, |
| ScheduleEmbedCallback callback) override; |
| void ScheduleEmbedForExistingClient( |
| uint32_t window_id, |
| ScheduleEmbedForExistingClientCallback callback) override; |
| void EmbedUsingToken(Id transport_window_id, |
| const base::UnguessableToken& token, |
| uint32_t embed_flags, |
| EmbedUsingTokenCallback callback) override; |
| void SetFocus(uint32_t change_id, Id transport_window_id) override; |
| void SetCanFocus(Id transport_window_id, bool can_focus) override; |
| void SetCursor(uint32_t change_id, |
| Id transport_window_id, |
| ui::Cursor cursor) override; |
| void SetWindowTextInputState(Id window_id, |
| ui::mojom::TextInputStatePtr state) override; |
| void SetImeVisibility(Id window_id, |
| bool visible, |
| ::ui::mojom::TextInputStatePtr state) override; |
| void SetEventTargetingPolicy(Id transport_window_id, |
| mojom::EventTargetingPolicy policy) override; |
| void OnWindowInputEventAck(uint32_t event_id, |
| mojom::EventResult result) override; |
| void DeactivateWindow(Id transport_window_id) override; |
| void StackAbove(uint32_t change_id, Id above_id, Id below_id) override; |
| void StackAtTop(uint32_t change_id, Id window_id) override; |
| void BindWindowManagerInterface( |
| const std::string& name, |
| mojom::WindowManagerAssociatedRequest window_manager) override; |
| void GetCursorLocationMemory( |
| GetCursorLocationMemoryCallback callback) override; |
| void PerformWindowMove(uint32_t change_id, |
| Id transport_window_id, |
| mojom::MoveLoopSource source, |
| const gfx::Point& cursor, |
| int hit_test) override; |
| void CancelWindowMove(Id transport_window_id) override; |
| void PerformDragDrop( |
| uint32_t change_id, |
| Id source_window_id, |
| const gfx::Point& screen_location, |
| const base::flat_map<std::string, std::vector<uint8_t>>& drag_data, |
| const gfx::ImageSkia& drag_image, |
| const gfx::Vector2d& drag_image_offset, |
| uint32_t drag_operation, |
| ui::mojom::PointerKind source) override; |
| void CancelDragDrop(Id window_id) override; |
| void ObserveTopmostWindow(mojom::MoveLoopSource source, |
| Id window_id) override; |
| void StopObservingTopmostWindow() override; |
| void SetWindowResizeShadow(Id window_id, int hit_test) override; |
| void CancelActiveTouchesExcept(Id not_cancelled_window_id) override; |
| void CancelActiveTouches(Id window_id) override; |
| void TransferGestureEventsTo(Id current_id, |
| Id new_id, |
| bool should_cancel) override; |
| void TrackOcclusionState(Id transport_window_id) override; |
| void PauseWindowOcclusionTracking() override; |
| void UnpauseWindowOcclusionTracking() override; |
| |
| WindowService* window_service_; |
| |
| const ClientSpecificId client_id_; |
| |
| // Identity of the remote client. This is only valid for clients connecting |
| // directly to the WindowService. Clients that were embedded do not connect |
| // directly to the WindowService, in which case |client_name_| is empty. |
| const std::string client_name_; |
| |
| ConnectionType connection_type_ = ConnectionType::kEmbedding; |
| |
| mojom::WindowTreeClient* window_tree_client_; |
| |
| // Controls whether the client can change the visibility of the roots. |
| bool can_change_root_window_visibility_ = true; |
| |
| ClientRoots client_roots_; |
| |
| // These contain mappings for known windows, see KnownWindow for details on |
| // it. This contains all windows created by the client, as well as windows |
| // known to the client. For example,if this client is the result of an |
| // embedding then the window at the embed point (the root window of the |
| // ClientRoot) was not created by this client, but is known and in these |
| // mappings. |
| std::map<aura::Window*, KnownWindow> known_windows_map_; |
| std::unordered_map<ClientWindowId, aura::Window*, ClientWindowIdHash> |
| client_window_id_to_window_map_; |
| |
| // Used to track the active change from the client. |
| std::unique_ptr<ClientChangeTracker> property_change_tracker_; |
| |
| // If non-null, the client requested to observe events the client would not |
| // normally get. |
| std::unique_ptr<EventObserverHelper> event_observer_helper_; |
| |
| FocusHandler focus_handler_{this}; |
| |
| // Holds WindowTreeClients passed to ScheduleEmbed(). Entries are removed |
| // when EmbedUsingToken() is called. |
| using ScheduledEmbeds = |
| base::flat_map<base::UnguessableToken, mojom::WindowTreeClientPtr>; |
| ScheduledEmbeds scheduled_embeds_; |
| |
| // Calls to ScheduleEmbedForExistingClient() add an entry here. The value is |
| // the value supplied to ScheduleEmbedForExistingClient(). When a matching |
| // EmbedUsingToken() is received, the value in the map is used as the id for |
| // the window in this client (specifically |ClientWindowId.sink_id|). |
| using ScheduledEmbedsForExistingClient = |
| base::flat_map<base::UnguessableToken, ClientSpecificId>; |
| ScheduledEmbedsForExistingClient scheduled_embeds_for_existing_client_; |
| |
| // Used to track events sent to the client. Key events are tracked separately, |
| // as their acks may be delayed when the client uses async IME handling. |
| std::queue<std::unique_ptr<InFlightEvent>> in_flight_key_events_; |
| std::queue<std::unique_ptr<InFlightEvent>> in_flight_other_events_; |
| |
| // Set while a window move loop is in progress. |
| aura::Window* window_moving_ = nullptr; |
| |
| // Set while a window move loop is in progress to track the window move |
| // information. |
| std::unique_ptr<TopmostWindowObserver> topmost_window_observer_; |
| |
| // Set while a drag loop is in progress. |
| Id pending_drag_source_window_id_ = kInvalidTransportId; |
| |
| std::vector<std::unique_ptr<WindowManagerInterface>> |
| window_manager_interfaces_; |
| |
| // Keeps track of outstanding occlusion tracking pauses. A ScopedPause object |
| // is added to the list when the client requests to pause and removed from the |
| // list when the client no longer wishes to pause. Using a tracking vector so |
| // that outstanding pauses from the client are properly removed in case the |
| // client goes away. |
| std::vector<std::unique_ptr<aura::WindowOcclusionTracker::ScopedPause>> |
| window_occlusion_tracking_pauses_; |
| |
| base::WeakPtrFactory<WindowTree> weak_factory_{this}; |
| |
| DISALLOW_COPY_AND_ASSIGN(WindowTree); |
| }; |
| |
| } // namespace ws |
| |
| #endif // SERVICES_WS_WINDOW_TREE_H_ |