// Copyright (c) 2012 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 ASH_SHELL_H_ #define ASH_SHELL_H_ #include #include #include #include "ash/ash_export.h" #include "ash/constants/ash_features.h" #include "ash/in_session_auth/in_session_auth_dialog_controller_impl.h" #include "ash/public/cpp/session/session_observer.h" #include "ash/public/cpp/shelf_types.h" #include "ash/wm/system_modal_container_event_filter_delegate.h" #include "base/gtest_prod_util.h" #include "base/memory/weak_ptr.h" #include "base/observer_list.h" #include "ui/aura/window.h" #include "ui/base/ui_base_types.h" #include "ui/display/screen.h" #include "ui/events/event_target.h" #include "ui/wm/core/cursor_manager.h" #include "ui/wm/public/activation_change_observer.h" class PrefService; namespace aura { class RootWindow; class Window; } // namespace aura namespace chromeos { class ImmersiveContext; class SnapController; } // namespace chromeos namespace dbus { class Bus; } namespace display { class DisplayChangeObserver; class DisplayConfigurator; class DisplayManager; } // namespace display namespace gfx { class Point; } // namespace gfx namespace keyboard { class KeyboardUIFactory; } namespace ui { class ContextFactory; class UserActivityDetector; class UserActivityPowerManagerNotifier; } // namespace ui namespace views { class NonClientFrameView; class Widget; namespace corewm { class TooltipController; } } // namespace views namespace wm { class AcceleratorFilter; class ActivationClient; class CompoundEventFilter; class FocusController; class ShadowController; class VisibilityController; class WindowModalityController; } // namespace wm namespace ash { class AcceleratorControllerImpl; class AccessibilityControllerImpl; class AccessibilityDelegate; class AccessibilityFocusRingControllerImpl; class AdaptiveChargingController; class AmbientController; class AppListControllerImpl; class AppListFeatureUsageMetrics; class AshColorProvider; class AshDBusServices; class AshFocusRules; class AshTouchTransformController; class AssistantControllerImpl; class AutoclickController; class AutozoomControllerImpl; class BackGestureEventHandler; class BacklightsForcedOffSetter; class BluetoothDeviceStatusUiHandler; class BluetoothNotificationController; class BluetoothPowerController; class BrightnessControlDelegate; class CalendarController; class CaptureModeController; class ControlVHistogramRecorder; class CrosDisplayConfig; class DarkLightModeControllerImpl; class DesksController; class DetachableBaseHandler; class DetachableBaseNotificationController; class DisplayAlignmentController; class DisplayColorManager; class NativeCursorManagerAsh; class DisplayConfigurationController; class DisplayConfigurationObserver; class DisplayErrorObserver; class DisplayHighlightController; class DisplayPrefs; class DisplayShutdownObserver; class DisplaySpeakerController; class DockedMagnifierController; class DragDropController; class EventClientImpl; class EventRewriterControllerImpl; class EventTransformationHandler; class WindowRestoreController; class FirmwareUpdateNotificationController; class FloatController; class FocusCycler; class FrameThrottlingController; class FullscreenMagnifierController; class GeolocationController; class GlanceablesController; class HighContrastController; class HighlighterController; class HoldingSpaceController; class HumanPresenceOrientationController; class ImeControllerImpl; class WebAuthNDialogControllerImpl; class KeyAccessibilityEnabler; class KeyboardBacklightColorController; class KeyboardBrightnessControlDelegate; class KeyboardControllerImpl; class LaserPointerController; class LocaleUpdateControllerImpl; class LockStateController; class LogoutConfirmationController; class LoginScreenController; class LoginUnlockThroughputRecorder; class MediaNotificationProviderImpl; class TabClusterUIController; class TabletModeController; class MediaControllerImpl; class MessageCenterAshImpl; class MessageCenterController; class MouseCursorEventFilter; class MruWindowTracker; class MultiDeviceNotificationPresenter; class MultitaskMenuNudgeController; class NearbyShareControllerImpl; class DesksTemplatesDelegate; class NearbyShareDelegate; class NightLightControllerImpl; class OcclusionTrackerPauser; class OverlayEventFilter; class OverviewController; class ParentAccessController; class PartialMagnifierController; class PciePeripheralNotificationController; class UsbPeripheralNotificationController; class PeripheralBatteryListener; class PeripheralBatteryNotifier; class PersistentDesksBarController; class PersistentWindowController; class PolicyRecommendationRestorer; class PowerButtonController; class PowerEventObserver; class PowerPrefs; class PrivacyHubController; class PrivacyScreenController; class ProjectingObserver; class ProjectorControllerImpl; class RgbKeyboardManager; class RefreshRateThrottleController; class ResizeShadowController; class ResolutionNotificationController; class RootWindowController; class ScreenLayoutObserver; class ScreenOrientationController; class ScreenPinningController; class ScreenPositionController; class ScreenSwitchCheckController; class SessionControllerImpl; class FeatureDiscoveryDurationReporterImpl; class ShelfConfig; class ShelfController; class ShelfWindowWatcher; class ShellDelegate; struct ShellInitParams; class ShellObserver; class ShutdownControllerImpl; class SmsObserver; class SnoopingProtectionController; class StickyKeysController; class SystemGestureEventFilter; class SystemModalContainerEventFilter; class SystemNotificationController; class SystemTrayModel; class SystemTrayNotifier; class ToastManagerImpl; class ToplevelWindowEventHandler; class ClipboardHistoryControllerImpl; class TouchDevicesController; class TrayAction; class TrayBluetoothHelper; class UserMetricsRecorder; class VideoActivityNotifier; class VideoDetector; class WallpaperControllerImpl; class WindowCycleController; class WindowPositioner; class WindowTreeHostManager; class ArcInputMethodBoundsTracker; class MultiCaptureServiceClient; enum class LoginStatus; namespace diagnostics { class DiagnosticsLogController; } // namespace diagnostics namespace quick_pair { class Mediator; } // namespace quick_pair // Shell is a singleton object that presents the Shell API and implements the // RootWindow's delegate interface. // // Upon creation, the Shell sets itself as the RootWindow's delegate, which // takes ownership of the Shell. class ASH_EXPORT Shell : public SessionObserver, public SystemModalContainerEventFilterDelegate, public ui::EventTarget, public ::wm::ActivationChangeObserver { public: typedef std::vector RootWindowControllerList; Shell(const Shell&) = delete; Shell& operator=(const Shell&) = delete; // Creates the single Shell instance. static Shell* CreateInstance(ShellInitParams init_params); // Should never be called before |CreateInstance()|. static Shell* Get(); // Returns true if the ash shell has been instantiated. static bool HasInstance(); static void DeleteInstance(); // Returns the root window controller for the primary root window. // TODO(oshima): move this to |RootWindowController| static RootWindowController* GetPrimaryRootWindowController(); // Returns the RootWindowController for the given display id. If there // is no display for |display_id|, null is returned. static RootWindowController* GetRootWindowControllerWithDisplayId( int64_t display_id); // Returns the root Window for the given display id. If there is no display // for |display_id| null is returned. static aura::Window* GetRootWindowForDisplayId(int64_t display_id); // Returns all root window controllers. // TODO(oshima): move this to |RootWindowController| static RootWindowControllerList GetAllRootWindowControllers(); // Returns the primary root Window. The primary root Window is the one that // has a launcher. static aura::Window* GetPrimaryRootWindow(); // Sets the root window that newly created windows should be added to. static void SetRootWindowForNewWindows(aura::Window* root); // Returns the root window that newly created windows should be added to. // Value can be temporarily overridden using // display::ScopedDisplayForNewWindows. NOTE: this returns the root, newly // created window should be added to the appropriate container in the returned // window. static aura::Window* GetRootWindowForNewWindows(); // Returns all root windows. static aura::Window::Windows GetAllRootWindows(); static aura::Window* GetContainer(aura::Window* root_window, int container_id); static const aura::Window* GetContainer(const aura::Window* root_window, int container_id); // If a system-modal dialog window is currently open, returns the ID of the // system modal window container that contains the window. // If no system-modal dialogs are open it returns -1. static int GetOpenSystemModalWindowContainerId(); // Returns true if a system-modal dialog window is currently open. static bool IsSystemModalWindowOpen(); // Track/Untrack InputMethod bounds. void TrackInputMethodBounds(ArcInputMethodBoundsTracker* tracker); void UntrackTrackInputMethodBounds(ArcInputMethodBoundsTracker* tracker); // Creates a default views::NonClientFrameView for use by windows in the // Ash environment. std::unique_ptr CreateDefaultNonClientFrameView( views::Widget* widget); // Called when a casting session is started or stopped. void OnCastingSessionStartedOrStopped(bool started); // Called when a root window is created. void OnRootWindowAdded(aura::Window* root_window); // Called when a root window is about to shutdown. void OnRootWindowWillShutdown(aura::Window* root_window); // Called when dictation is activated. void OnDictationStarted(); // Called when dictation is ended. void OnDictationEnded(); // Returns whether the device is currently in tablet mode. If the tablet // mode controller isn't available, we assume the device is not in // tablet mode. bool IsInTabletMode() const; // Tests if TabletModeWindowManager is not enabled, and if // TabletModeController is not currently setting a display rotation. Or if // the |resolution_notification_controller_| is not showing its confirmation // dialog. If true then changes to display settings can be saved. bool ShouldSaveDisplaySettings(); AcceleratorControllerImpl* accelerator_controller() { return accelerator_controller_.get(); } AccessibilityControllerImpl* accessibility_controller() { return accessibility_controller_.get(); } AccessibilityDelegate* accessibility_delegate() { return accessibility_delegate_.get(); } AccessibilityFocusRingControllerImpl* accessibility_focus_ring_controller() { return accessibility_focus_ring_controller_.get(); } ::wm::ActivationClient* activation_client(); AppListControllerImpl* app_list_controller() { return app_list_controller_.get(); } AdaptiveChargingController* adaptive_charging_controller() { return adaptive_charging_controller_.get(); } AmbientController* ambient_controller() { return ambient_controller_.get(); } AssistantControllerImpl* assistant_controller() { return assistant_controller_.get(); } AutoclickController* autoclick_controller() { return autoclick_controller_.get(); } AutozoomControllerImpl* autozoom_controller() { return autozoom_controller_.get(); } BacklightsForcedOffSetter* backlights_forced_off_setter() { return backlights_forced_off_setter_.get(); } BluetoothPowerController* bluetooth_power_controller() { DCHECK(!ash::features::IsBluetoothRevampEnabled()); return bluetooth_power_controller_.get(); } BrightnessControlDelegate* brightness_control_delegate() { return brightness_control_delegate_.get(); } CalendarController* calendar_controller() { return calendar_controller_.get(); } CrosDisplayConfig* cros_display_config() { return cros_display_config_.get(); } ::wm::CursorManager* cursor_manager() { return cursor_manager_.get(); } DarkLightModeControllerImpl* dark_light_mode_controller() { return dark_light_mode_controller_.get(); } DesksController* desks_controller() { return desks_controller_.get(); } PersistentDesksBarController* persistent_desks_bar_controller() { return persistent_desks_bar_controller_.get(); } DesksTemplatesDelegate* desks_templates_delegate() { return desks_templates_delegate_.get(); } DetachableBaseHandler* detachable_base_handler() { return detachable_base_handler_.get(); } display::DisplayManager* display_manager() { return display_manager_.get(); } DisplayPrefs* display_prefs() { return display_prefs_.get(); } DisplayConfigurationController* display_configuration_controller() { return display_configuration_controller_.get(); } RefreshRateThrottleController* refresh_rate_throttle_controller() { return refresh_rate_throttle_controller_.get(); } DisplayAlignmentController* display_alignment_controller() { return display_alignment_controller_.get(); } display::DisplayConfigurator* display_configurator(); DisplayColorManager* display_color_manager() { return display_color_manager_.get(); } DisplayErrorObserver* display_error_observer() { return display_error_observer_.get(); } ProjectingObserver* projecting_observer() { return projecting_observer_.get(); } DisplayHighlightController* display_highlight_controller() { return display_highlight_controller_.get(); } DockedMagnifierController* docked_magnifier_controller() { return docked_magnifier_controller_.get(); } ::wm::CompoundEventFilter* env_filter() { return env_filter_.get(); } EventRewriterControllerImpl* event_rewriter_controller() { return event_rewriter_controller_.get(); } EventClientImpl* event_client() { return event_client_.get(); } EventTransformationHandler* event_transformation_handler() { return event_transformation_handler_.get(); } FirmwareUpdateNotificationController* firmware_update_notification_controller() { return firmware_update_notification_controller_.get(); } FloatController* float_controller() { return float_controller_.get(); } ::wm::FocusController* focus_controller() { return focus_controller_.get(); } AshFocusRules* focus_rules() { return focus_rules_; } FocusCycler* focus_cycler() { return focus_cycler_.get(); } FullscreenMagnifierController* fullscreen_magnifier_controller() { return fullscreen_magnifier_controller_.get(); } GeolocationController* geolocation_controller() { return geolocation_controller_.get(); } GlanceablesController* glanceables_controller() { return glanceables_controller_.get(); } HighlighterController* highlighter_controller() { return highlighter_controller_.get(); } HighContrastController* high_contrast_controller() { return high_contrast_controller_.get(); } HumanPresenceOrientationController* human_presence_orientation_controller() { return human_presence_orientation_controller_.get(); } ImeControllerImpl* ime_controller() { return ime_controller_.get(); } WebAuthNDialogControllerImpl* webauthn_dialog_controller() { return webauthn_dialog_controller_.get(); } InSessionAuthDialogControllerImpl* in_session_auth_dialog_controller() { return in_session_auth_dialog_controller_.get(); } KeyAccessibilityEnabler* key_accessibility_enabler() { return key_accessibility_enabler_.get(); } KeyboardBacklightColorController* keyboard_backlight_color_controller() { return keyboard_backlight_color_controller_.get(); } KeyboardBrightnessControlDelegate* keyboard_brightness_control_delegate() { return keyboard_brightness_control_delegate_.get(); } KeyboardControllerImpl* keyboard_controller() { return keyboard_controller_.get(); } LaserPointerController* laser_pointer_controller() { return laser_pointer_controller_.get(); } LocaleUpdateControllerImpl* locale_update_controller() { return locale_update_controller_.get(); } LoginScreenController* login_screen_controller() { return login_screen_controller_.get(); } LockStateController* lock_state_controller() { return lock_state_controller_.get(); } LogoutConfirmationController* logout_confirmation_controller() { return logout_confirmation_controller_.get(); } MediaControllerImpl* media_controller() { return media_controller_.get(); } MediaNotificationProviderImpl* media_notification_provider() { return media_notification_provider_.get(); } MessageCenterAshImpl* message_center_ash_impl() { return message_center_ash_impl_.get(); } MessageCenterController* message_center_controller() { return message_center_controller_.get(); } MouseCursorEventFilter* mouse_cursor_filter() { return mouse_cursor_filter_.get(); } MruWindowTracker* mru_window_tracker() { return mru_window_tracker_.get(); } MultitaskMenuNudgeController* multitask_menu_nudge_controller() { return multitask_menu_nudge_controller_.get(); } NearbyShareControllerImpl* nearby_share_controller() { return nearby_share_controller_.get(); } NearbyShareDelegate* nearby_share_delegate() { return nearby_share_delegate_.get(); } NightLightControllerImpl* night_light_controller() { return night_light_controller_.get(); } OverlayEventFilter* overlay_filter() { return overlay_filter_.get(); } ParentAccessController* parent_access_controller() { return parent_access_controller_.get(); } PartialMagnifierController* partial_magnifier_controller() { return partial_magnifier_controller_.get(); } PeripheralBatteryListener* peripheral_battery_listener() { return peripheral_battery_listener_.get(); } PolicyRecommendationRestorer* policy_recommendation_restorer() { return policy_recommendation_restorer_.get(); } PowerButtonController* power_button_controller() { return power_button_controller_.get(); } PowerEventObserver* power_event_observer() { return power_event_observer_.get(); } PrivacyHubController* privacy_hub_controller() { return privacy_hub_controller_.get(); } PrivacyScreenController* privacy_screen_controller() { return privacy_screen_controller_.get(); } quick_pair::Mediator* quick_pair_mediator() { return quick_pair_mediator_.get(); } MultiCaptureServiceClient* multi_capture_service_client() { return multi_capture_service_client_.get(); } ResizeShadowController* resize_shadow_controller() { return resize_shadow_controller_.get(); } ResolutionNotificationController* resolution_notification_controller() { return resolution_notification_controller_.get(); } RgbKeyboardManager* rgb_keyboard_manager() { return rgb_keyboard_manager_.get(); } ScreenLayoutObserver* screen_layout_observer() { return screen_layout_observer_.get(); } ScreenOrientationController* screen_orientation_controller() { return screen_orientation_controller_.get(); } ScreenPinningController* screen_pinning_controller() { return screen_pinning_controller_.get(); } ScreenSwitchCheckController* screen_switch_check_controller() { return screen_switch_check_controller_.get(); } SessionControllerImpl* session_controller() { return session_controller_.get(); } FeatureDiscoveryDurationReporterImpl* feature_discover_reporter() { return feature_discover_reporter_.get(); } ::wm::ShadowController* shadow_controller() { return shadow_controller_.get(); } ShelfConfig* shelf_config() { return shelf_config_.get(); } ShelfController* shelf_controller() { return shelf_controller_.get(); } ShellDelegate* shell_delegate() { return shell_delegate_.get(); } ShutdownControllerImpl* shutdown_controller() { return shutdown_controller_.get(); } SnoopingProtectionController* snooping_protection_controller() { return snooping_protection_controller_.get(); } StickyKeysController* sticky_keys_controller() { return sticky_keys_controller_.get(); } SystemNotificationController* system_notification_controller() { return system_notification_controller_.get(); } SystemTrayModel* system_tray_model() { return system_tray_model_.get(); } SystemTrayNotifier* system_tray_notifier() { return system_tray_notifier_.get(); } TabClusterUIController* tab_cluster_ui_controller() const { return tab_cluster_ui_controller_.get(); } TabletModeController* tablet_mode_controller() const { return tablet_mode_controller_.get(); } ToastManagerImpl* toast_manager() { return toast_manager_.get(); } views::corewm::TooltipController* tooltip_controller() { return tooltip_controller_.get(); } ClipboardHistoryControllerImpl* clipboard_history_controller() { return clipboard_history_controller_.get(); } TouchDevicesController* touch_devices_controller() { return touch_devices_controller_.get(); } AshTouchTransformController* touch_transformer_controller() { return touch_transformer_controller_.get(); } TrayAction* tray_action() { return tray_action_.get(); } // Will return |nullptr| when the |kBluetoothRevamp| feature flag is enabled. TrayBluetoothHelper* tray_bluetooth_helper() { return tray_bluetooth_helper_.get(); } UserMetricsRecorder* metrics() { return user_metrics_recorder_.get(); } VideoDetector* video_detector() { return video_detector_.get(); } WallpaperControllerImpl* wallpaper_controller() { return wallpaper_controller_.get(); } WindowCycleController* window_cycle_controller() { return window_cycle_controller_.get(); } WindowPositioner* window_positioner() { return window_positioner_.get(); } OverviewController* overview_controller() { return overview_controller_.get(); } WindowTreeHostManager* window_tree_host_manager() { return window_tree_host_manager_.get(); } BackGestureEventHandler* back_gesture_event_handler() { return back_gesture_event_handler_.get(); } ui::EventHandler* shell_tab_handler() { return shell_tab_handler_.get(); } ToplevelWindowEventHandler* toplevel_window_event_handler() { return toplevel_window_event_handler_.get(); } AshColorProvider* ash_color_provider() { return ash_color_provider_.get(); } PrefService* local_state() { return local_state_; } FrameThrottlingController* frame_throttling_controller() { return frame_throttling_controller_.get(); } ProjectorControllerImpl* projector_controller() { return projector_controller_.get(); } PciePeripheralNotificationController* pcie_peripheral_notification_controller() { return pcie_peripheral_notification_controller_.get(); } UsbPeripheralNotificationController* usb_peripheral_notification_controller() { return usb_peripheral_notification_controller_.get(); } OcclusionTrackerPauser* occlusion_tracker_pauser() { return occlusion_tracker_pauser_.get(); } // Does the primary display have status area? bool HasPrimaryStatusArea(); // Starts the animation that occurs on first login. void DoInitialWorkspaceAnimation(); void SetLargeCursorSizeInDip(int large_cursor_size_in_dip); // Sets a custom color for the cursor. void SetCursorColor(SkColor cursor_color); // Updates cursor compositing on/off. Native cursor is disabled when cursor // compositing is enabled, and vice versa. void UpdateCursorCompositingEnabled(); // Force setting compositing on/off without checking dependency. void SetCursorCompositingEnabled(bool enabled); // Shows the context menu for the wallpaper or shelf at |location_in_screen|. void ShowContextMenu(const gfx::Point& location_in_screen, ui::MenuSourceType source_type); void AddShellObserver(ShellObserver* observer); void RemoveShellObserver(ShellObserver* observer); // Disables event dispatch during shutdown so that Window events no longer // propagate as they are being closed/destroyed. void ShutdownEventDispatch(); // Called when the login status changes. // TODO(oshima): Investigate if we can merge this and |OnLoginStateChanged|. void UpdateAfterLoginStatusChange(LoginStatus status); // Notifies observers that fullscreen mode has changed for |container|. // |container| is always the active desk container. void NotifyFullscreenStateChanged(bool is_fullscreen, aura::Window* container); // Notifies observers that |pinned_window| changed its pinned window state. void NotifyPinnedStateChanged(aura::Window* pinned_window); // Notifies observers that |root_window|'s user work area insets have changed. // This notification is not fired when shelf bounds changed. void NotifyUserWorkAreaInsetsChanged(aura::Window* root_window); // Notifies observers that |root_window|'s shelf changed alignment. // TODO(jamescook): Move to Shelf. void NotifyShelfAlignmentChanged(aura::Window* root_window, ShelfAlignment old_alignment); private: FRIEND_TEST_ALL_PREFIXES(ExtendedDesktopTest, TestCursor); FRIEND_TEST_ALL_PREFIXES(WindowManagerTest, MouseEventCursors); FRIEND_TEST_ALL_PREFIXES(WindowManagerTest, TransformActivate); friend class AcceleratorControllerTest; friend class AshTestHelper; friend class RootWindowController; friend class ShellTestApi; friend class SmsObserverTest; explicit Shell(std::unique_ptr shell_delegate); ~Shell() override; void Init(ui::ContextFactory* context_factory, PrefService* local_state, std::unique_ptr keyboard_ui_factory, scoped_refptr dbus_bus); // Initializes the display manager and related components. void InitializeDisplayManager(); // Initializes the root window so that it can host browser windows. void InitRootWindow(aura::Window* root_window); // Destroys all child windows including widgets across all roots. void CloseAllRootWindowChildWindows(); // SystemModalContainerEventFilterDelegate: bool CanWindowReceiveEvents(aura::Window* window) override; // Overridden from ui::EventTarget: bool CanAcceptEvent(const ui::Event& event) override; EventTarget* GetParentTarget() override; std::unique_ptr GetChildIterator() const override; ui::EventTargeter* GetEventTargeter() override; // wm::ActivationChangeObserver: void OnWindowActivated(ActivationReason reason, aura::Window* gained_active, aura::Window* lost_active) override; // SessionObserver: void OnFirstSessionStarted() override; void OnSessionStateChanged(session_manager::SessionState state) override; void OnLoginStatusChanged(LoginStatus login_status) override; void OnLockStateChanged(bool locked) override; static Shell* instance_; // The CompoundEventFilter owned by aura::Env object. std::unique_ptr<::wm::CompoundEventFilter> env_filter_; std::unique_ptr event_rewriter_controller_; std::unique_ptr user_metrics_recorder_; std::unique_ptr window_positioner_; std::unique_ptr accelerator_controller_; std::unique_ptr accessibility_controller_; std::unique_ptr accessibility_delegate_; std::unique_ptr accessibility_focus_ring_controller_; std::unique_ptr adaptive_charging_controller_; std::unique_ptr ambient_controller_; std::unique_ptr app_list_controller_; std::unique_ptr app_list_feature_usage_metrics_; // May be null in tests or when running on linux-chromeos. scoped_refptr dbus_bus_; std::unique_ptr ash_dbus_services_; std::unique_ptr assistant_controller_; std::unique_ptr autozoom_controller_; std::unique_ptr backlights_forced_off_setter_; std::unique_ptr brightness_control_delegate_; std::unique_ptr calendar_controller_; std::unique_ptr cros_display_config_; std::unique_ptr dark_light_mode_controller_; std::unique_ptr desks_controller_; std::unique_ptr desks_templates_delegate_; std::unique_ptr detachable_base_handler_; std::unique_ptr detachable_base_notification_controller_; std::unique_ptr diagnostics_log_controller_; std::unique_ptr display_highlight_controller_; std::unique_ptr display_speaker_controller_; std::unique_ptr drag_drop_controller_; std::unique_ptr firmware_update_notification_controller_; std::unique_ptr focus_cycler_; std::unique_ptr float_controller_; std::unique_ptr geolocation_controller_; std::unique_ptr glanceables_controller_; std::unique_ptr holding_space_controller_; std::unique_ptr power_prefs_; std::unique_ptr snooping_protection_controller_; std::unique_ptr human_presence_orientation_controller_; std::unique_ptr ime_controller_; std::unique_ptr immersive_context_; std::unique_ptr webauthn_dialog_controller_; std::unique_ptr keyboard_backlight_color_controller_; std::unique_ptr in_session_auth_dialog_controller_; std::unique_ptr keyboard_brightness_control_delegate_; std::unique_ptr locale_update_controller_; std::unique_ptr login_screen_controller_; std::unique_ptr logout_confirmation_controller_; std::unique_ptr tab_cluster_ui_controller_; std::unique_ptr tablet_mode_controller_; std::unique_ptr message_center_ash_impl_; std::unique_ptr media_controller_; std::unique_ptr media_notification_provider_; std::unique_ptr mru_window_tracker_; std::unique_ptr multidevice_notification_presenter_; std::unique_ptr multitask_menu_nudge_controller_; std::unique_ptr nearby_share_controller_; std::unique_ptr nearby_share_delegate_; std::unique_ptr parent_access_controller_; std::unique_ptr pcie_peripheral_notification_controller_; std::unique_ptr privacy_hub_controller_; std::unique_ptr usb_peripheral_notification_controller_; std::unique_ptr persistent_desks_bar_controller_; std::unique_ptr rgb_keyboard_manager_; std::unique_ptr resize_shadow_controller_; std::unique_ptr session_controller_; std::unique_ptr feature_discover_reporter_; std::unique_ptr ash_color_provider_; std::unique_ptr night_light_controller_; std::unique_ptr privacy_screen_controller_; std::unique_ptr policy_recommendation_restorer_; std::unique_ptr screen_switch_check_controller_; std::unique_ptr shelf_config_; std::unique_ptr shelf_controller_; std::unique_ptr shelf_window_watcher_; std::unique_ptr shell_delegate_; std::unique_ptr capture_mode_controller_; std::unique_ptr control_v_histogram_recorder_; std::unique_ptr shutdown_controller_; std::unique_ptr system_notification_controller_; std::unique_ptr system_tray_model_; std::unique_ptr system_tray_notifier_; std::unique_ptr toast_manager_; std::unique_ptr clipboard_history_controller_; std::unique_ptr touch_devices_controller_; std::unique_ptr tray_action_; std::unique_ptr wallpaper_controller_; std::unique_ptr window_cycle_controller_; std::unique_ptr window_restore_controller_; std::unique_ptr overview_controller_; // Owned by |focus_controller_|. AshFocusRules* focus_rules_ = nullptr; std::unique_ptr<::wm::ShadowController> shadow_controller_; std::unique_ptr<::wm::VisibilityController> visibility_controller_; std::unique_ptr<::wm::WindowModalityController> window_modality_controller_; PrefService* local_state_ = nullptr; std::unique_ptr tooltip_controller_; std::unique_ptr power_button_controller_; std::unique_ptr lock_state_controller_; std::unique_ptr user_activity_detector_; std::unique_ptr video_detector_; std::unique_ptr window_tree_host_manager_; std::unique_ptr persistent_window_controller_; std::unique_ptr high_contrast_controller_; std::unique_ptr fullscreen_magnifier_controller_; std::unique_ptr autoclick_controller_; std::unique_ptr<::wm::FocusController> focus_controller_; std::unique_ptr mouse_cursor_filter_; std::unique_ptr screen_position_controller_; std::unique_ptr modality_filter_; std::unique_ptr event_client_; std::unique_ptr event_transformation_handler_; // An event filter that pre-handles key events while the partial // screenshot UI or the keyboard overlay is active. std::unique_ptr overlay_filter_; // An event filter which handles swiping back from left side of the window. std::unique_ptr back_gesture_event_handler_; // An event filter which redirects focus when tab is pressed on a RootWindow // with no active windows. std::unique_ptr shell_tab_handler_; // An event filter which handles moving and resizing windows. std::unique_ptr toplevel_window_event_handler_; // An event filter which handles system level gestures std::unique_ptr system_gesture_filter_; // An event filter that pre-handles global accelerators. std::unique_ptr<::wm::AcceleratorFilter> accelerator_filter_; std::unique_ptr display_manager_; std::unique_ptr display_prefs_; std::unique_ptr display_configuration_controller_; std::unique_ptr display_configuration_observer_; std::unique_ptr refresh_rate_throttle_controller_; std::unique_ptr screen_pinning_controller_; std::unique_ptr peripheral_battery_listener_; std::unique_ptr peripheral_battery_notifier_; std::unique_ptr power_event_observer_; std::unique_ptr user_activity_notifier_; std::unique_ptr video_activity_notifier_; std::unique_ptr sticky_keys_controller_; std::unique_ptr resolution_notification_controller_; std::unique_ptr bluetooth_notification_controller_; std::unique_ptr bluetooth_device_status_ui_handler_; std::unique_ptr bluetooth_power_controller_; // Will be |nullptr| when the |kBluetoothRevamp| feature flag is enabled. std::unique_ptr tray_bluetooth_helper_; std::unique_ptr keyboard_controller_; std::unique_ptr display_alignment_controller_; std::unique_ptr display_color_manager_; std::unique_ptr display_error_observer_; std::unique_ptr projecting_observer_; // Listens for output changes and updates the display manager. std::unique_ptr display_change_observer_; // Listens for shutdown and updates DisplayConfigurator. std::unique_ptr display_shutdown_observer_; // Listens for new sms messages and shows notifications. std::unique_ptr sms_observer_; // Implements content::ScreenOrientationController for Chrome OS. std::unique_ptr screen_orientation_controller_; std::unique_ptr screen_layout_observer_; std::unique_ptr touch_transformer_controller_; std::unique_ptr magnifier_key_scroll_handler_; std::unique_ptr speech_feedback_handler_; std::unique_ptr laser_pointer_controller_; std::unique_ptr partial_magnifier_controller_; std::unique_ptr highlighter_controller_; std::unique_ptr docked_magnifier_controller_; std::unique_ptr snap_controller_; // |native_cursor_manager_| is owned by |cursor_manager_|, but we keep a // pointer to vend to test code. NativeCursorManagerAsh* native_cursor_manager_; // Cursor may be hidden on certain key events in Chrome OS, whereas we never // hide the cursor on Windows. std::unique_ptr<::wm::CursorManager> cursor_manager_; // Enables spoken feedback accessibility based on a press and hold of both // volume keys. std::unique_ptr key_accessibility_enabler_; std::unique_ptr frame_throttling_controller_; std::unique_ptr projector_controller_; // For testing only: simulate that a modal window is open bool simulate_modal_window_open_for_test_ = false; std::unique_ptr message_center_controller_; std::unique_ptr login_unlock_throughput_recorder_; std::unique_ptr occlusion_tracker_pauser_; std::unique_ptr multi_capture_service_client_; std::unique_ptr quick_pair_mediator_; base::ObserverList::Unchecked shell_observers_; base::WeakPtrFactory weak_factory_{this}; }; } // namespace ash #endif // ASH_SHELL_H_