// Copyright 2016 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_WINDOW_H_ #define UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_WINDOW_H_ #include #include #include #include #include #include #include #include "base/containers/circular_deque.h" #include "base/containers/flat_set.h" #include "base/containers/linked_list.h" #include "base/functional/callback.h" #include "base/gtest_prod_util.h" #include "base/memory/raw_ptr.h" #include "base/memory/scoped_refptr.h" #include "base/memory/weak_ptr.h" #include "base/task/single_thread_task_runner.h" #include "ui/base/dragdrop/mojom/drag_drop_types.mojom-forward.h" #include "ui/base/ui_base_types.h" #include "ui/events/event_target.h" #include "ui/events/platform/platform_event_dispatcher.h" #include "ui/gfx/frame_data.h" #include "ui/gfx/geometry/insets.h" #include "ui/gfx/geometry/point_f.h" #include "ui/gfx/geometry/rect.h" #include "ui/gfx/native_ui_types.h" #include "ui/ozone/platform/wayland/common/wayland_object.h" #include "ui/ozone/platform/wayland/host/wayland_output.h" #include "ui/ozone/platform/wayland/host/wayland_surface.h" #include "ui/platform_window/extensions/wayland_extension.h" #include "ui/platform_window/platform_window.h" #include "ui/platform_window/platform_window_delegate.h" #include "ui/platform_window/platform_window_init_properties.h" #include "ui/platform_window/wm/wm_drag_handler.h" namespace wl { struct WaylandOverlayConfig; } // namespace wl namespace ui { class BitmapCursor; class OSExchangeData; class WaylandAsyncCursor; class WaylandBubble; class WaylandConnection; class WaylandSubsurface; class WaylandDataDragController; class WaylandWindowDragController; class WaylandFrameManager; class WaylandPopup; class WaylandToplevelWindow; using WidgetSubsurfaceSet = base::flat_set>; class WaylandWindow : public PlatformWindow, public PlatformEventDispatcher, public WmDragHandler, public WaylandExtension, public EventTarget { public: // An interface to receive window focus change events. class FocusClient { public: virtual void OnKeyboardFocusChanged(bool focused) = 0; virtual void OnTextInputFocusChanged(bool focused) = 0; }; WaylandWindow(const WaylandWindow&) = delete; WaylandWindow& operator=(const WaylandWindow&) = delete; ~WaylandWindow() override; // A factory method that can create any of the derived types of WaylandWindow // (WaylandToplevelWindow, WaylandPopup and WaylandBubble). static std::unique_ptr Create( PlatformWindowDelegate* delegate, WaylandConnection* connection, PlatformWindowInitProperties properties); void OnWindowLostCapture(); // Updates the scale of this window, which may be taken from entered outputs // or from wp-fractional-scale-v1, depending on current setup and feature // flags, eg: WaylandPerSurfaceScale. Children inherit scale from their // parent. Recalculates window bounds appropriately if asked to do so via // |update_bounds|. virtual void UpdateWindowScale(bool update_bounds); // If per-surface scaling is disabled, this updates the window scale as per // the currently entered output(s). void OnEnteredOutputScaleChanged(); // Returns a WeakPtr to the implementation instance. virtual base::WeakPtr AsWeakPtr() = 0; WaylandSurface* root_surface() const { return root_surface_.get(); } WaylandSubsurface* primary_subsurface() const { return primary_subsurface_.get(); } const WidgetSubsurfaceSet& wayland_subsurfaces() const { return wayland_subsurfaces_; } base::LinkedList* subsurface_stack_committed() { return &subsurface_stack_committed_; } void set_parent_window(WaylandWindow* parent_window) { parent_window_ = parent_window; } WaylandWindow* parent_window() const { return parent_window_; } PlatformWindowDelegate* delegate() { return delegate_; } const PlatformWindowDelegate* delegate() const { return delegate_; } gfx::AcceleratedWidget GetWidget() const; // Creates a WaylandSubsurface to put into |wayland_subsurfaces_|. Called if // more subsurfaces are needed when a frame arrives. bool RequestSubsurface(); // Re-arrange the |subsurface_stack_above_| and |subsurface_stack_below_| s.t. // subsurface_stack_above_.size() >= above and // subsurface_stack_below_.size() >= below. bool ArrangeSubsurfaceStack(size_t above, size_t below); bool CommitOverlays(uint32_t frame_id, const gfx::FrameData& data, std::vector& overlays); void set_focus_client(FocusClient* focus_client) { focus_client_ = focus_client; } // Called when the pointer focus changed on this window. void OnPointerFocusChanged(bool focused); // Called when the keyboard focus changed on this window. void OnKeyboardFocusChanged(bool focused); // Called when the text input focus changed on this window. void OnTextInputFocusChanged(bool focused); // Returns the focus status of this window. bool HasPointerFocus() const; bool HasKeyboardFocus() const; // The methods set or return whether this window has touch focus and should // dispatch touch events. void set_touch_focus(bool focus) { has_touch_focus_ = focus; } bool has_touch_focus() const { return has_touch_focus_; } // Set a child of this window. It is very important in case of nested // shell_popups as long as they must be destroyed in the back order. void set_child_popup(WaylandPopup* window) { child_popup_ = window; } WaylandPopup* child_popup() const { return child_popup_; } // Called only by `WaylandBubble`s that are managed in this instance's // `child_bubbles_` list. void AddBubble(WaylandBubble* window); void RemoveBubble(WaylandBubble* window); void ActivateBubble(WaylandBubble* window); WaylandBubble* active_bubble() { return active_bubble_; } // Tentatively determines and returns the scale factor for this window based // on its currently entered wl_outputs, see GetPreferredEnteredOutputId() // description for more details. Returns null when the outputs are not ready. std::optional GetScaleFactorFromEnteredOutputs(); // Returns the preferred entered output id, if any. The preferred output is // the one with the largest scale. This is needed to properly render contents // as it seems like an expectation of Wayland. However, if all the entered // outputs have the same scale factor, the very first entered output is chosen // as there is no way to figure out what output the window occupies the most. std::optional GetPreferredEnteredOutputId(); std::optional GetPreferredScaleFactor() const; // Returns current type of the window. PlatformWindowType type() const { return type_; } bool received_configure_event() const { return received_configure_event_; } // Remove WaylandOutput associated with WaylandSurface of this window. void RemoveEnteredOutput(uint32_t output_id); // WmDragHandler bool StartDrag(const ui::OSExchangeData& data, int operations, mojom::DragEventSource source, gfx::NativeCursor cursor, bool can_grab_pointer, base::OnceClosure drag_started_callback, WmDragHandler::DragFinishedCallback drag_finished_callback, WmDragHandler::LocationDelegate* delegate) override; void CancelDrag() override; void UpdateDragImage(const gfx::ImageSkia& image, const gfx::Vector2d& offset) override; // PlatformWindow void Show(bool inactive) override; void Hide() override; void Close() override; bool IsVisible() const override; void PrepareForShutdown() override; void SetBoundsInPixels(const gfx::Rect& bounds) override; gfx::Rect GetBoundsInPixels() const override; void SetBoundsInDIP(const gfx::Rect& bounds) override; gfx::Rect GetBoundsInDIP() const override; void SetTitle(const std::u16string& title) override; void SetCapture() override; void ReleaseCapture() override; void SetVideoCapture() override; void ReleaseVideoCapture() override; bool HasCapture() const override; void SetFullscreen(bool fullscreen, int64_t target_display_id) override; void Maximize() override; void Minimize() override; void Restore() override; PlatformWindowState GetPlatformWindowState() const override; void Activate() override; void Deactivate() override; void SetUseNativeFrame(bool use_native_frame) override; bool ShouldUseNativeFrame() const override; void SetCursor(scoped_refptr cursor) override; void MoveCursorTo(const gfx::Point& location) override; void ConfineCursorToBounds(const gfx::Rect& bounds) override; void SetRestoredBoundsInDIP(const gfx::Rect& bounds) override; gfx::Rect GetRestoredBoundsInDIP() const override; bool ShouldWindowContentsBeTransparent() const override; void SetAspectRatio(const gfx::SizeF& aspect_ratio) override; void SetWindowIcons(const gfx::ImageSkia& window_icon, const gfx::ImageSkia& app_icon) override; void SizeConstraintsChanged() override; bool ShouldUpdateWindowShape() const override; // PlatformEventDispatcher bool CanDispatchEvent(const PlatformEvent& event) override; uint32_t DispatchEvent(const PlatformEvent& event) override; // WaylandExtension: void RoundTripQueue() override; bool HasInFlightRequestsForState() const override; int64_t GetVizSequenceIdForAppliedState() const override; int64_t GetVizSequenceIdForLatchedState() const override; void SetLatchImmediately(bool latch_immediately) override; // EventTarget: bool CanAcceptEvent(const Event& event) override; EventTarget* GetParentTarget() override; std::unique_ptr GetChildIterator() const override; EventTargeter* GetEventTargeter() override; // Handles the configuration events coming from the shell objects. // The width and height come in DIP of the output that the surface is // currently bound to. virtual void HandleSurfaceConfigure(uint32_t serial); struct WindowStates { public: WindowStates(); ~WindowStates(); bool is_maximized = false; bool is_fullscreen = false; bool is_activated = false; bool is_minimized = false; bool is_suspended = false; WindowTiledEdges tiled_edges; // Dumps the values of the states into a string. std::string ToString() const; }; // Configure related: virtual void HandleToplevelConfigure(int32_t width, int32_t height, const WindowStates& window_states); // TODO(crbug.com/374244479): Linux/Wayland doesn't support configure events // with origin changes as clients are not shared with their onscreen // coordinates. Remove this and fix tests that rely on origin changes. virtual void HandleToplevelConfigureWithOrigin( int32_t x, int32_t y, int32_t width, int32_t height, const WindowStates& window_states); virtual void HandlePopupConfigure(const gfx::Rect& bounds); // Call when we get a new frame produced from viz with |seq| sequence ID. // This is used to determine which requests have been fulfilled, // and sends the appropriate acks back to the wayland server. virtual void OnSequencePoint(int64_t seq) = 0; // Called by shell surfaces to indicate that this window can start submitting // frames. Updating state based on configure is handled separately to this. void OnSurfaceConfigureEvent(); // See comments on the member variable for an explanation of this. const PlatformWindowDelegate::State& applied_state() const { return applied_state_; } // See comments on the member variable for an explanation of this. const PlatformWindowDelegate::State& latched_state() const { return latched_state_; } // Tells if the surface has already been configured. This will be true after // the first set of configure event and ack request, meaning that wl_surface // can attach buffers. virtual bool IsSurfaceConfigured() = 0; // Sends configure acknowledgement to the wayland server. virtual void AckConfigure(uint32_t serial) = 0; // Handles close requests. virtual void OnCloseRequest(); // Notifies about drag/drop session events. |point| is in DIP as wayland // sends coordinates in "surface-local" coordinates. virtual void OnDragEnter(const gfx::PointF& point, int operations); virtual void OnDragDataAvailable(std::unique_ptr data); virtual int OnDragMotion(const gfx::PointF& point, int operations); virtual void OnDragDrop(); virtual void OnDragLeave(); virtual void OnDragSessionClose(ui::mojom::DragOperation operation); // Sets the window geometry. virtual void SetWindowGeometry(const PlatformWindowDelegate::State& state); // Returns the offset of the window geometry within the window surface. gfx::Vector2d GetWindowGeometryOffsetInDIP() const; // Returns a root parent window within the same hierarchy. WaylandWindow* GetRootParentWindow(); // Returns a top most child window within the same hierarchy. WaylandWindow* GetTopMostChildWindow(); // This is the ancestor window that has an xdg_toplevel or xdg_popup role, // because xdg_popup can only be created by another window with an xdg-role. // If `parent_window()` is WaylandBubble, we walk up the window tree to find // the closest ancestor with an xdg-role assigned to create a xdg_popup. WaylandWindow* GetXdgParentWindow(); // Called by the WaylandSurface attached to this window when that surface // becomes partially or fully within the scanout region of an output that it // wasn't before. void OnEnteredOutput(); // Called by the WaylandSurface attached to this window when that surface // becomes fully outside of one of outputs that it previously resided on. void OnLeftOutput(); // Returns true iff this window is opaque. bool IsOpaqueWindow() const; // Says if the current window is set as active by the Wayland server. This // only applies to toplevel surfaces (surfaces such as popups, subsurfaces // do not support that). // TODO(fangzhoug): Revisit `IsActive()` meaning, it has a mixed meaning of // both platform activation in wayland server's perspective as toplevel, and // activation status of delegate()->OnActivationChanged() as bubble. virtual bool IsActive() const; virtual bool IsSuspended() const; // WaylandWindow can be any type of object - WaylandBubble, // WaylandToplevelWindow, WaylandPopup. The following methods cast itself to // WaylandBubble, WaylandPopup or WaylandToplevelWindow, if |this| is // of that type. virtual WaylandBubble* AsWaylandBubble(); virtual WaylandPopup* AsWaylandPopup(); virtual WaylandToplevelWindow* AsWaylandToplevelWindow(); scoped_refptr ui_task_runner() { return ui_task_runner_; } // Clears the state of the |frame_manager_| when the GPU channel is // destroyed. void OnChannelDestroyed(); // Triggers window UI resize and relayout in reaction to system-wide font // scale changes, eg: accessibility's "large text" setting. void OnFontScaleFactorChanged(); void OnDisplayColorSpacesChanged( scoped_refptr display_color_spaces); virtual void DumpState(std::ostream& out) const; #if DCHECK_IS_ON() void disable_null_target_dcheck_for_testing() { disable_null_target_dcheck_for_test_ = true; } #endif protected: WaylandWindow(PlatformWindowDelegate* delegate, WaylandConnection* connection); WaylandConnection* connection() { return connection_; } const WaylandConnection* connection() const { return connection_; } const std::vector>& child_bubbles() { return child_bubbles_; } // Update the bounds of the window in DIP. Unlike SetBoundInDIP, it will not // send a request to the compositor even if the screen coordinate is enabled. void UpdateBoundsInDIP(const gfx::Rect& bounds_dip); // Updates mask for this window. virtual void UpdateWindowMask() = 0; // [Deprecated] // If the given |bounds_px| violates size constraints set for this window, // fixes them so they don't. gfx::Rect AdjustBoundsToConstraintsPx(const gfx::Rect& bounds_px); // If the given |bounds_dip| violates size constraints set for this window, // fixes them so they don't. gfx::Rect AdjustBoundsToConstraintsDIP(const gfx::Rect& bounds_dip); const gfx::Rect& restored_bounds_dip() const { return restored_bounds_dip_; } WaylandFrameManager* frame_manager() { return frame_manager_.get(); } // Configure related: // Processes the currently pending State. This may generate a new in-flight // StateRequest, or apply and ack the request immediately. This should be // called after the server has finished sending a configure request. The // serial number comes from the server and needs to be acked when the changes // from the configure have been applied. void ProcessPendingConfigureState(uint32_t serial); // Requests the given state via RequestState, given that this was a server // initiated change (e.g. configure). void RequestStateFromServer(PlatformWindowDelegate::State state, int64_t serial); // Requests the given state via RequestState, given that this was a client // initiated change. void RequestStateFromClient(PlatformWindowDelegate::State state); // Requests the given state. If this request originates from a configure from // the server, specify |serial|. If |force| is true, the state will always be // applied, even if requests are being throttled. void RequestState(PlatformWindowDelegate::State state, int64_t serial, bool force); // Processes the given sequence point number. It will also latch and ack // the latest fulfilled in-flight request if it exists. void ProcessSequencePoint(int64_t viz_seq); // Applies the latest in-flight StateRequest, if it exists. In-flight // StateRequests need to wait for a frame generated after we inserted a // sequence point for their changes. If |force| is true, the state will always // be applied, even if requests are being throttled. This is used for client // requested changes (server requested changes may be throttled). void MaybeApplyLatestStateRequest(bool force); // Returns the next state that will be applied, or the currently applied state // if there are no later unapplied states. This is used when updating a single // property (e.g. window scale) without wanting to modify the others. PlatformWindowDelegate::State GetLatestRequestedState() const; // Sets the scale used for this window, which is provided by the Wayland // compositor and determines how the pixel size of the surface is treated and // how events can be translated. This must be called when: // // 1. A new preferred scale value is received via fractional-scale-v1 protocol // (when per-surface-scaling enabled); or // 2. Either window is moving to a new display (output), or if the scale // factor of its current display changes. This is not sent via a configure // (legacy per-display scaling mode). void SetWindowScale(float window_scale); // Sets given `window_state` to `applied_state_` so that it reflects the // client side window state change immediately, Not that // `applied_state_.window_state` is the source of truth as a window state. // This should be called only when the client side requests the new window // state and it is expected to become the same when the server side // configures. // DO NOT USE THIS unless it's really needed and okay to use. // TODO(crbug.com/40276379): Remove this. void ForceApplyWindowStateDoNotUse(PlatformWindowState window_state); bool HasInFlightRequestsForStateForTesting() const { return !in_flight_requests_.empty(); } // When surface roles are destroyed with in-flight requests, these serials // become invalid. Clear them so we do not get "wrong configure serial" error. void ClearInFlightRequestsSerial(); // PendingConfigureState describes the content of a configure sent from the // wayland server. struct PendingConfigureState { std::optional window_state; std::optional tiled_edges; std::optional bounds_dip; std::optional size_px; }; // This holds the requested state for the next configure from the server. // The window may get several configuration events that update the pending // bounds or other state. When the configure is fully received, we may // create a StateRequest for this pending State. PendingConfigureState pending_configure_state_; private: friend class WaylandBufferManagerViewportTest; friend class BlockableWaylandToplevelWindow; friend class WaylandWindowManager; FRIEND_TEST_ALL_PREFIXES(WaylandScreenTest, SetWindowScale); FRIEND_TEST_ALL_PREFIXES(WaylandBufferManagerTest, CanSubmitOverlayPriority); FRIEND_TEST_ALL_PREFIXES(WaylandBufferManagerTest, CanSetRoundedCorners); FRIEND_TEST_ALL_PREFIXES(WaylandBufferManagerTest, CommitOverlaysNonsensicalBoundsRect); FRIEND_TEST_ALL_PREFIXES(WaylandWindowTest, ServerInitiatedRestoreFromMinimizedState); // Initializes the WaylandWindow with supplied properties. bool Initialize(PlatformWindowInitProperties properties); uint32_t DispatchEventToDelegate(const PlatformEvent& native_event); // Additional initialization of derived classes. virtual bool OnInitialize(PlatformWindowInitProperties properties, PlatformWindowDelegate::State* state) = 0; // Drag controllers might need to take ownership of the dnd origin surface // when its associated window gets closed in the middle of the session (e.g: // in the process of being snapped into a tab strip) to prevent the drag // session from getting cancelled abruptly by the Wayland compositor. Surface // ownership is allowed to be transferred only when the window is already // under destruction (i.e: |shutting_down_| is set) which can be done, for // example, by implementing |WaylandWindowObserver::OnWindowRemoved|. friend WaylandWindowDragController; friend WaylandDataDragController; std::unique_ptr TakeWaylandSurface(); void UpdateCursorShape(scoped_refptr cursor); void OnCursorLoaded(scoped_refptr cursor, scoped_refptr bitmap_cursor); // StateRequest describes a State that we are applying to the window, and the // metadata about that State, such as what serial number to use for ack (if it // came from a configure), or the viz sequence number. struct StateRequest { // State that has been requested. PlatformWindowDelegate::State state; // Wayland serial number for acking a configure. This is -1 if there is no // serial number (e.g. from client initiated change). int64_t serial = -1; // Viz sequence number at the time of this request. We are looking for a // frame with a number greater than this to latch this request. int64_t viz_seq = -1; // Whether this request has been applied. bool applied = false; }; // Latches the given request. This must be called after the frame // corresponding to the request is received. This acks the request and updates // any window state that should be based on the currently latched state. void LatchStateRequest(const StateRequest& req); raw_ptr delegate_; raw_ptr connection_; raw_ptr parent_window_ = nullptr; raw_ptr child_popup_ = nullptr; // AcceleratedWidget for this window. This will be unique even over time. gfx::AcceleratedWidget accelerated_widget_; // `active_bubble_` represents the WaylandBubble that should take activation // when this WaylandWindow has activation from wayland server. It can be set // on a WaylandWindow regardless of whether or not this WaylandWindow has // activation. If this WaylandWindow has activation the bubble is considered // the active WaylandWindow in the window hierarchy. raw_ptr active_bubble_ = nullptr; std::vector> child_bubbles_; // |root_surface_| is a surface for the opaque background. Its z-order is // INT32_MIN. std::unique_ptr root_surface_; std::unique_ptr frame_manager_; bool received_configure_event_ = false; // |primary_subsurface| is the primary that shows the widget content. std::unique_ptr primary_subsurface_; // Subsurfaces excluding the primary_subsurface WidgetSubsurfaceSet wayland_subsurfaces_; bool wayland_overlay_delegation_enabled_; // The stack of sub-surfaces to take effect when Commit() is called. // |subsurface_stack_above_| refers to subsurfaces that are stacked above the // primary. These include the subsurfaces to be hidden as well. // Subsurface at the front of the list is the closest to the primary. std::list> subsurface_stack_above_; std::list> subsurface_stack_below_; // The stack of sub-surfaces currently committed. This list is altered when // the subsurface arrangement are played back by WaylandFrameManager. base::LinkedList subsurface_stack_committed_; // The current asynchronously loaded cursor (Linux specific). scoped_refptr async_cursor_; bool has_touch_focus_ = false; // Stores current opacity of the window. Set on ::Initialize call. ui::PlatformWindowOpacity opacity_; // The type of the current WaylandWindow object. ui::PlatformWindowType type_ = ui::PlatformWindowType::kWindow; // Set when the window enters in shutdown process. bool shutting_down_ = false; // The bounds of the platform window before it went maximized or fullscreen in // dip. gfx::Rect restored_bounds_dip_; // A focus client that, once set, is expected to live at least as long as this // window. raw_ptr focus_client_ = nullptr; // This holds the currently applied state. When in doubt, use this as the // source of truth for this window's state. Whenever applied_state_ is // changed, that change should be applied and a new in-flight request and // sequence point should be created. Note that changes can be applied via // other means than configures from the Wayland server. For example, // PlatformWindow::SetBoundsInDIP can change the bounds without the server // doing anything. This is separated from pending_configure_state_ to support // these two different sources (server and PlatformWindow/etc) of control of // the state. // // Here is an explanation of the State system: // // After applying some state changes (e.g. setting Chrome's bounds), we ask // PlatformWindowDelegate for a sequence ID, which will be used to identify // the correct buffer that has content corresponding to these changes. It is // not sufficient to use the buffer size to identify this frame, because not // all state changes change the buffer size. Usually these state changes are // caused by configures from the wayland server, but not always. The client // (us) can also set state (e.g. client side bounds change), and this needs to // be managed along with changes via configure. // // Once the sequence ID reaches ozone/wayland GPU from viz, it will pass it // over mojo back to WaylandBufferManagerHost where the whole round trip // started. WaylandWindow will match it up with pending configures, which are // now identified by the sequence ID at the original time of that configure. // // Once we have the sequence ID from viz back, we need to make sure the right // configure is acked. Let's explicitly classify all configure related state // into stages: // // Pending (pending_configure_state_): Accumulates configure data passed by // the server. // // Requested (in_flight_requests_): On configure, we request the configure // state to be applied. Not all configure state will be applied, due to // throttling. Also, any client side changes (e.g. // PlatformWindow::SetBoundsInDIP) should go through requested state to make // sure it takes the same code path. // // Applied (applied_state_): A configure state which we have asked the browser // to apply, e.g. by calling delegate()->OnBoundsChanged. // // Latched (latched_state_): When we receive the frame back from ozone/wayland // GPU, we use the viz sequence ID to match it up with a configure. That state // is now "latched". // // State changes go through this flow: // 1. Pending - if via configure // 2. Requested - in a queue to be applied (unless throttled) // 3. Applied - we asked the browser to apply these state changes, waiting for // the frame to come back // 4. Latched - the frame corresponding to this state came back, we can ack // the configure if there was one PlatformWindowDelegate::State applied_state_; // The current configuration state of the window. This is initially set to // values provided by the client, until we get an actual configure from the // server. See the comments on applied_state_ for further explanation. PlatformWindowDelegate::State latched_state_; // In-flight state requests. Once a frame comes from the GPU // process with the appropriate viz sequence number, ack_configure request // with |serial| will be sent to the Wayland compositor if needed. base::circular_deque in_flight_requests_; // Until all tests work properly with full asynchronicity, we latch // immediately based on the value of `UseTestConfigForPlatformWindows()`. // However, some tests require synchronisation with the wayland server, so // we also provide this flag for turning on asynchronous latching. // Eventually when all tests work asynchronously, we should remove this // and the code to latch immediately based on // `UseTestConfigForPlatformWindows()`. bool latch_immediately_for_testing_ = true; int64_t latest_applied_viz_seq_for_testing_ = -1; int64_t latest_latched_viz_seq_for_testing_ = -1; WmDragHandler::DragFinishedCallback drag_finished_callback_; base::OnceClosure drag_loop_quit_closure_; #if DCHECK_IS_ON() bool disable_null_target_dcheck_for_test_ = false; #endif // Set to true when we are already in the process of applying a state. // This is used to detect re-entrancy which is hard to reason about and // also will cause memory corruption with the current implementation. bool applying_state_ = false; // This has an invariant that it is empty unless `applying_state_` is true. // That is, if we are not in the re-entrant section, then we should never have // a re-entrant request. Note that by deferring re-entrant requests, it means // that PlatformWindow calls that normally would take effect immediately (in // the same stack) will no longer do so. They won't be entirely asynchronous, // but they will apply later once the re-entrant requests are processed. // TODO(crbug.com/40058672): Remove this once we have no // client initiated state requests. std::vector> reentrant_requests_; scoped_refptr ui_task_runner_; }; } // namespace ui #endif // UI_OZONE_PLATFORM_WAYLAND_HOST_WAYLAND_WINDOW_H_