// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef ASH_CAPTURE_MODE_VIDEO_RECORDING_WATCHER_H_
#define ASH_CAPTURE_MODE_VIDEO_RECORDING_WATCHER_H_
#include <optional>
#include "ash/ash_export.h"
#include "ash/capture_mode/capture_mode_behavior.h"
#include "ash/capture_mode/capture_mode_types.h"
#include "ash/display/cursor_window_controller.h"
#include "ash/wm/window_dimmer.h"
#include "base/memory/raw_ptr.h"
#include "base/timer/timer.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "services/viz/privileged/mojom/compositing/frame_sink_video_capture.mojom.h"
#include "ui/aura/scoped_window_capture_request.h"
#include "ui/aura/window_observer.h"
#include "ui/base/cursor/cursor.h"
#include "ui/color/color_provider_source_observer.h"
#include "ui/compositor/layer_delegate.h"
#include "ui/compositor/layer_owner.h"
#include "ui/display/display_observer.h"
#include "ui/events/event_handler.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/wm/public/activation_change_observer.h"
namespace display {
enum class TabletState;
} // namespace display
namespace wm {
class CursorManager;
} // namespace wm
namespace ash {
class CaptureModeBehavior;
class CaptureModeController;
class CaptureModeDemoToolsController;
class RecordedWindowRootObserver;
// An instance of this class is created while video recording is in progress to
// watch for events that end video recording, such as a window being recorded
// gets closed or moved between displays, or a display being fullscreen-recorded
// gets disconnected.
// This also paints a dimming shield to distinguish the area being recorded, but
// only when recording a window or a partial region.
// Note that this object doesn't create a new layer, rather the controller makes
// it acquire and reuse the layer of the `CaptureModeSession` prior to the
// session ending.
// It also controls the overlay created on the video capturer to efficiently
// record the mouse cursor on top of the video frames.
class ASH_EXPORT VideoRecordingWatcher
: public aura::WindowObserver,
public ui::LayerOwner,
public ui::LayerDelegate,
public wm::ActivationChangeObserver,
public display::DisplayObserver,
public WindowDimmer::Delegate,
public ui::EventHandler,
public CursorWindowController::Observer,
public ui::ColorProviderSourceObserver {
public:
VideoRecordingWatcher(
CaptureModeController* controller,
CaptureModeBehavior* active_behavior,
aura::Window* window_being_recorded,
mojo::PendingRemote<viz::mojom::FrameSinkVideoCaptureOverlay>
cursor_capture_overlay,
bool is_recording_audio);
~VideoRecordingWatcher() override;
const CaptureModeBehavior* active_behavior() const {
return active_behavior_;
}
aura::Window* window_being_recorded() const { return window_being_recorded_; }
bool is_recording_audio() const { return is_recording_audio_; }
bool should_paint_layer() const { return should_paint_layer_; }
bool is_shutting_down() const { return is_shutting_down_; }
CaptureModeSource recording_source() const { return recording_source_; }
// Clean up prior to deletion.
void ShutDown();
// Returns the current parent window for the on-capture-surface widgets such
// as `CaptureModeCameraController::camera_preview_widget_` and
// `CaptureModeDemoToolsController::key_combo_widget_` when recording is in
// progress.
aura::Window* GetOnCaptureSurfaceWidgetParentWindow() const;
// Returns the bounds within which the on-capture-surface widgets (such as
// capture mode camera preview widget and key combo widget) will be confined
// when recording is in progress.
gfx::Rect GetCaptureSurfaceConfineBounds() const;
// Returns the `partial_region_bounds_` clamped to the bounds of the
// `current_root_`. It should only be called if `recording_source_` is
// `kRegion`.
gfx::Rect GetEffectivePartialRegionBounds() const;
// Returns the `key_combo_widget_` if it is visible.
const views::Widget* GetKeyComboWidgetIfVisible() const;
// aura::WindowObserver:
void OnWindowParentChanged(aura::Window* window,
aura::Window* parent) override;
void OnWindowVisibilityChanged(aura::Window* window, bool visible) override;
void OnWindowBoundsChanged(aura::Window* window,
const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds,
ui::PropertyChangeReason reason) override;
void OnWindowOpacitySet(aura::Window* window,
ui::PropertyChangeReason reason) override;
void OnWindowStackingChanged(aura::Window* window) override;
void OnWindowDestroying(aura::Window* window) override;
void OnWindowDestroyed(aura::Window* window) override;
void OnWindowRemovingFromRootWindow(aura::Window* window,
aura::Window* new_root) override;
// ui::LayerDelegate:
void OnPaintLayer(const ui::PaintContext& context) override;
void OnDeviceScaleFactorChanged(float old_device_scale_factor,
float new_device_scale_factor) override {}
// wm::ActivationChangeObserver:
void OnWindowActivated(ActivationReason reason,
aura::Window* gained_active,
aura::Window* lost_active) override;
// display::DisplayObserver:
void OnDisplayTabletStateChanged(display::TabletState state) override;
void OnDisplayMetricsChanged(const display::Display& display,
uint32_t metrics) override;
// WindowDimmer::Delegate:
void OnDimmedWindowDestroying(aura::Window* window) override;
void OnDimmedWindowParentChanged(aura::Window* dimmed_window) override;
// ui::EventHandler:
void OnKeyEvent(ui::KeyEvent* event) override;
void OnMouseEvent(ui::MouseEvent* event) override;
void OnTouchEvent(ui::TouchEvent* event) override;
// CursorWindowController::Observer:
void OnCursorCompositingStateChanged(bool enabled) override;
// ui::ColorProviderSourceObserver:
void OnColorProviderChanged() override;
bool IsWindowDimmedForTesting(aura::Window* window) const;
void BindCursorOverlayForTesting(
mojo::PendingRemote<viz::mojom::FrameSinkVideoCaptureOverlay> overlay);
void FlushCursorOverlayForTesting();
void SendThrottledWindowSizeChangedNowForTesting();
CaptureModeDemoToolsController* demo_tools_controller_for_testing() const {
return demo_tools_controller_.get();
}
protected:
// ui::LayerOwner:
void SetLayer(std::unique_ptr<ui::Layer> layer) override;
private:
friend class CaptureModeTestApi;
friend class RecordedWindowRootObserver;
// Called by |RecordedWindowRootObserver| to notify us with a hierarchy change
// event received by the |current_root_| window. The |target| window is the
// window that was added to or removed from the hierarchy.
void OnRootHierarchyChanged(aura::Window* target);
bool CalculateShouldPaintLayer() const;
// Uses CalculateShouldPaintLayer() to update whether we should paint the
// recording shield, and stores the value in |should_paint_layer_|. If the
// value of |should_paint_layer_| is changed, it schedules painting on our
// layer.
void UpdateShouldPaintLayer();
// Updates our layer's parent and stacking order within its parent. It also
// determines whether some windows need to be dimmed individually because they
// are above the shield layer in z-order.
void UpdateLayerStackingAndDimmers();
// Returns the current native cursor from |cursor_manager_|.
gfx::NativeCursor GetCurrentCursor() const;
// Updates the cursor overlay using the given |location| in the coordinates of
// the |window_being_recorded_|. This is used for non-pressed/-released mouse
// events which can be too frequent. Recording is performed at a rate of 30
// FPS, so we don't need to send every mouse event to the capturer overlay on
// Viz via mojo. Such events can be throttled using the
// |cursor_events_throttle_timer_|.
void UpdateOrThrottleCursorOverlay(const gfx::PointF& location);
// As opposed to the above UpdateOrThrottleCursorOverlay(), this updates the
// cursor capturer overlay immediately without throttling, if such an update
// is needed (e.g. the cursor bitmap changed, or the location changed, or
// both). This also cancels any pending throttled update, since this immediate
// one is more recent.
void UpdateCursorOverlayNow(const gfx::PointF& location);
// Hides the cursor overlay in the video capturer. Note that this doesn't
// necessarily mean that the video won't contain a cursor, since the software-
// composited cursor might be enabled. See |force_cursor_overlay_hidden_|.
void HideCursorOverlay();
// Invoked when the |cursor_events_throttle_timer_| fires, in order to update
// the cursor overlay with the pending most recently throttled mouse event
// location in |throttled_cursor_location_| if any.
void OnCursorThrottleTimerFiring();
// Invoked when the |window_size_change_throttle_timer_| fires, in order to
// push the current size of the window being recorded to the service.
void OnWindowSizeChangeThrottleTimerFiring();
const raw_ptr<CaptureModeController> controller_;
// The currently active behavior which is passed from capture mode session.
const raw_ptr<CaptureModeBehavior, DanglingUntriaged> active_behavior_;
const raw_ptr<wm::CursorManager> cursor_manager_;
const raw_ptr<aura::Window, DanglingUntriaged> window_being_recorded_;
raw_ptr<aura::Window, DanglingUntriaged> current_root_;
const CaptureModeSource recording_source_;
// The end point of the overlay owned by the video capturer on Viz, which is
// used to blit the mouse cursor onto the recorded video frames.
mojo::Remote<viz::mojom::FrameSinkVideoCaptureOverlay>
cursor_capture_overlay_remote_;
// Observes the hierarchy changes of the root window of the recorded window.
// Only constructed when performing a window recording (i.e.
// |recording_source_| is |kWindow|).
std::unique_ptr<RecordedWindowRootObserver> root_observer_;
// The last cursor we used to update the cursor overlay. This is used to
// determine whether we need to update the cursor bitmap.
gfx::NativeCursor last_cursor_;
// The last bounds we used to update the cursor overlay. This is used to skip
// the update if the bounds didn't change.
// Note that these bounds are relative within the bounds of the recorded frame
// sink, i.e. in the range [0.f, 1.f) for both origin() and size().
// See documentation of FrameSinkVideoCaptureOverlay for more details.
gfx::RectF last_cursor_overlay_bounds_;
// Since recording happens at a rate of 30 FPS, there's no need to send every
// mouse move event (or equivalent events such as enter, exit, dragged, ...
// etc.) to the cursor overlay. This timer is used to throttle such events
// received while this timer is running, and their location will overwrite the
// value of |throttled_cursor_location_|. Once the timer fires,
// OnCursorThrottleTimerFiring() will be called to update the overlay with the
// most recent received throttled event.
base::OneShotTimer cursor_events_throttle_timer_;
// Stores the location of the most recent throttled mouse event (i.e. received
// while the |cursor_events_throttle_timer_| was running). The location is in
// the |window_being_recorded_| coordinates.
std::optional<gfx::PointF> throttled_cursor_location_;
// Resizing a window can generate many intermediate steps, and it would be
// inefficient to push all of them to the recording service, causing a
// repeated reconfiguration of the video encoder. This timer is used to
// throttle such events.
base::OneShotTimer window_size_change_throttle_timer_;
// True if this active recording session started with audio recording turned
// on, and audio recording is being done by the recording service.
const bool is_recording_audio_;
// True if we force hiding the cursor overlay. This happens when we record a
// fullscreen, or a partial screen region, and the software-composited cursor
// gets enabled. The software-composited cursor is already part of the root
// window's frame sink which we record, so we don't need to show the cursor
// overlay. Otherwise, the video will end up with two overlapping cursors.
bool force_cursor_overlay_hidden_ = false;
// Whether or not to paint the layer content in OnPaintLayer(). The value of
// this field is calculated and updated in UpdateShouldPaintLayer().
bool should_paint_layer_ = false;
// The user-selected region for the current ongoing recording. This is only
// valid and non empty when the |recording_source_| is |kRegion|. Note that
// this differs from |CaptureModeController::user_capture_region_| in that the
// latter may change during the recording if the user opens capture mode again
// to take a partial screenshot.
gfx::Rect partial_region_bounds_;
// Maintains window dimmers where each is mapped by the window it dims. These
// are created for the windows that are above the |window_being_recorded_| in
// z-order on the same display so as to clearly show they're not being
// recorded. The ones that are below |window_being_recorded_| in z-order are
// dimmed by the shield layer owned by |this|.
base::flat_map<aura::Window*, std::unique_ptr<WindowDimmer>> dimmers_;
// If |window_being_recorded_| is not a root window, we must make a request to
// make it capturable by the |FrameSinkVideoCapturer|.
aura::ScopedWindowCaptureRequest non_root_window_capture_request_;
std::unique_ptr<CaptureModeDemoToolsController> demo_tools_controller_;
// True if the shutting down process has been triggered. We want to keep
// `is_shutting_down_` as the last member variable in this class.
bool is_shutting_down_ = false;
};
} // namespace ash
#endif // ASH_CAPTURE_MODE_VIDEO_RECORDING_WATCHER_H_
Codebase Browser
chromium