// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_REMOTE_COCOA_APP_SHIM_NATIVE_WIDGET_NS_WINDOW_FULLSCREEN_CONTROLLER_H_
#define COMPONENTS_REMOTE_COCOA_APP_SHIM_NATIVE_WIDGET_NS_WINDOW_FULLSCREEN_CONTROLLER_H_
#include <optional>
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/time/time.h"
#include "components/remote_cocoa/app_shim/remote_cocoa_app_shim_export.h"
#include "ui/display/types/display_constants.h"
#include "ui/gfx/geometry/rect.h"
namespace remote_cocoa {
class NativeWidgetNSWindowBridge;
class REMOTE_COCOA_APP_SHIM_EXPORT NativeWidgetNSWindowFullscreenController {
public:
class Client {
public:
// Called when a transition between fullscreen and windowed (or vice-versa).
// If `is_target_fullscreen` is true, then the target of the transition is
// fullscreen.
virtual void FullscreenControllerTransitionStart(
bool is_target_fullscreen) = 0;
// Called when a transition between fullscreen and windowed is complete.
// If `is_fullscreen` is true, then the window is now fullscreen.
virtual void FullscreenControllerTransitionComplete(bool is_fullscreen) = 0;
// Set the window's frame to the specified rectangle. If `animate` is true,
// then animate the transition. Runs the `completion_callback` callback once
// the animation is complete, or immediately when `animate` is false.
virtual void FullscreenControllerSetFrame(
const gfx::Rect& frame,
bool animate,
base::OnceCallback<void()> completion_callback) = 0;
// Call -[NSWindow toggleFullscreen:].
virtual void FullscreenControllerToggleFullscreen() = 0;
// Call -[NSWindow close]. Note that this call may result in the caller
// being destroyed.
virtual void FullscreenControllerCloseWindow() = 0;
// Return the display id for the display that the window is currently on.
virtual int64_t FullscreenControllerGetDisplayId() const = 0;
// Return the frame that should be set prior to transitioning to fullscreen
// on the display specified by `display_id`. If `display_id` is invalid,
// then return an empty rectangle.
virtual gfx::Rect FullscreenControllerGetFrameForDisplay(
int64_t display_id) const = 0;
// Get the window's current frame.
virtual gfx::Rect FullscreenControllerGetFrame() const = 0;
};
explicit NativeWidgetNSWindowFullscreenController(Client* client);
NativeWidgetNSWindowFullscreenController(
const NativeWidgetNSWindowFullscreenController&) = delete;
NativeWidgetNSWindowFullscreenController& operator=(
const NativeWidgetNSWindowFullscreenController&) = delete;
~NativeWidgetNSWindowFullscreenController();
// Called by NativeWidget::SetFullscreen.
void EnterFullscreen(int64_t target_display_id);
void ExitFullscreen();
// Called from NativeWidgetNSWindowBridge:CloseWindow, indicating that the
// window has been requested to be closed. If a transition is in progress,
// then the close will be deferred until after the transition completes.
void OnWindowWantsToClose();
// Return true if an active transition has caused closing of the window to be
// deferred.
bool HasDeferredWindowClose() const { return has_deferred_window_close_; }
// Called by NativeWidgetNSWindowBridge::OnWindowWillClose.
void OnWindowWillClose();
// Called by -[NSWindowDelegate windowWill/DidEnter/ExitFullScreen:].
void OnWindowWillEnterFullscreen();
void OnWindowDidEnterFullscreen();
void OnWindowWillExitFullscreen();
void OnWindowDidExitFullscreen();
// Return false unless the state is kWindowed or kFullscreen.
bool IsInFullscreenTransition() const;
// Return true if the window can be resized. The window cannot be resized
// while fullscreen or during a transition.
bool CanResize() const;
// Return the fullscreen state that will be arrived at when all transition
// is done.
bool GetTargetFullscreenState() const;
private:
enum class State {
// In windowed mode.
kWindowed,
// Moving the window to the target display on which it will go fullscreen.
kWindowedMovingToFullscreenTarget,
// In transition to enter fullscreen mode. This encompasses the following
// states:
// - From the kWindowed state, a task for ToggleFullscreen has been
// posted.
// - OnWindowWillEnterFullscreen has been called (either as a result of
// ToggleFullscreen, or as a result of user interaction), but neither
// OnWindowDidEnterFullscreen nor OnWindowDidExitFullscreen have been
// called yet.
kEnterFullscreenTransition,
// In fullscreen mode.
kFullscreen,
// In transition to exit fullscreen mode. This encompasses the following
// states:
// - From the kFullscreen state, a task for ToggleFullscreen has been
// posted.
// - OnWindowWillExitFullscreen has been called (either as a result of
// ToggleFullscreen, or as a result of user interaction), but neither
// OnWindowDidExitFullscreen nor OnWindowDidEnterFullscreen have been
// called yet.
kExitFullscreenTransition,
// Moving the window back to its original position from before it entered
// fullscreen.
kWindowedRestoringOriginalFrame,
// The window has been closed.
kClosed,
};
struct PendingState {
bool is_fullscreen = false;
int64_t display_id = display::kInvalidDisplayId;
};
// Move the window to `target_display_id`, and then post a task to go
// fullscreen.
void MoveToTargetDisplayThenToggleFullscreen(int64_t target_display_id);
// Set the window's frame back to `windowed_frame_`, and then return to
// the kWindowed state.
void RestoreWindowedFrame();
// Notifies the client that the fullscreen exit transition has completed after
// the frame has been restored to its original position.
void OnWindowedFrameRestored();
// Helper function wrapping -[NSWindow toggleFullscreen:].
void ToggleFullscreen();
// If not currently in transition, consume `pending_state_` and start a
// transition to the state it specifies.
void HandlePendingState();
// If there exists a deferred close, then close the window, set the
// current state to kClosed, and return true.
bool HandleDeferredClose();
// Set `state` to `new_state`, and invalidate any posted tasks. Posted tasks
// exist to transition from the current state to a new state, and so if the
// current state changes, then those tasks are no longer applicable.
void SetStateAndCancelPostedTasks(State new_state);
State state_ = State::kWindowed;
// If a call to EnterFullscreen or ExitFullscreen happens during a
// transition, then that final requested state is stored in `pending_state_`.
std::optional<PendingState> pending_state_;
// If we call setFrame while in fullscreen transitions, then we will need to
// restore the original window frame when we return to windowed mode. We save
// that original frame in `windowed_frame_`, and set set
// `restore_windowed_frame_` to true if we call setFrame.
bool restore_windowed_frame_ = false;
std::optional<gfx::Rect> windowed_frame_;
// Trying to close an NSWindow during a fullscreen transition will cause the
// window to lock up. Use this to track if CloseWindow was called during a
// fullscreen transition, to defer the -[NSWindow close] call until the
// transition is complete.
// https://crbug.com/945237
bool has_deferred_window_close_ = false;
// Weak, owns `this`.
const raw_ptr<Client> client_;
base::WeakPtrFactory<NativeWidgetNSWindowFullscreenController> weak_factory_{
this};
};
} // namespace remote_cocoa
#endif // COMPONENTS_REMOTE_COCOA_APP_SHIM_NATIVE_WIDGET_NS_WINDOW_FULLSCREEN_CONTROLLER_H_
Codebase Browser
chromium