text: // 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 <utility>
  #include <vector>
  
  #include "ash/ash_export.h"
  #include "ash/metrics/user_metrics_recorder.h"
  #include "ash/shelf/shelf_types.h"
  #include "ash/system/user/login_status.h"
  #include "ash/wm/cursor_manager_chromeos.h"
  #include "ash/wm/system_modal_container_event_filter_delegate.h"
  #include "base/basictypes.h"
  #include "base/compiler_specific.h"
  #include "base/gtest_prod_util.h"
  #include "base/memory/scoped_ptr.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/events/event_target.h"
  #include "ui/gfx/insets.h"
  #include "ui/gfx/screen.h"
  #include "ui/gfx/size.h"
  #include "ui/wm/core/cursor_manager.h"
  #include "ui/wm/public/activation_change_observer.h"
  
  namespace app_list {
  class AppListView;
  }
  namespace aura {
  class EventFilter;
  class RootWindow;
  class Window;
  namespace client {
  class ActivationClient;
  class FocusClient;
  }
  }
  
  namespace gfx {
  class ImageSkia;
  class Point;
  class Rect;
  }
  
  namespace ui {
  class DisplayConfigurator;
  class Layer;
  class UserActivityPowerManagerNotifier;
  }
  namespace views {
  class NonClientFrameView;
  class Widget;
  namespace corewm {
  class TooltipController;
  }
  }
  
  namespace wm {
  class AcceleratorFilter;
  class CompoundEventFilter;
  class InputMethodEventFilter;
  class NestedAcceleratorController;
  class ShadowController;
  class VisibilityController;
  class UserActivityDetector;
  class WindowModalityController;
  }
  
  namespace ash {
  
  class AcceleratorController;
  class AccelerometerController;
  class AccessibilityDelegate;
  class AppListController;
  class AshNativeCursorManager;
  class AutoclickController;
  class BluetoothNotificationController;
  class CaptureController;
  class DesktopBackgroundController;
  class DisplayChangeObserver;
  class DisplayConfiguratorAnimation;
  class DisplayController;
  class DisplayErrorObserver;
  class DisplayManager;
  class DragDropController;
  class EventClientImpl;
  class EventRewriterEventFilter;
  class EventTransformationHandler;
  class FirstRunHelper;
  class FocusCycler;
  class GPUSupport;
  class HighContrastController;
  class KeyboardUMAEventFilter;
  class LastWindowClosedLogoutReminder;
  class LocaleNotificationController;
  class LockStateController;
  class LogoutConfirmationController;
  class MagnificationController;
  class MaximizeModeController;
  class MaximizeModeWindowManager;
  class MediaDelegate;
  class MouseCursorEventFilter;
  class MruWindowTracker;
  class NewWindowDelegate;
  class OverlayEventFilter;
  class PartialMagnificationController;
  class PowerButtonController;
  class PowerEventObserver;
  class ProjectingObserver;
  class ResizeShadowController;
  class ResolutionNotificationController;
  class RootWindowController;
  class ScopedTargetRootWindow;
  class ScreenAsh;
  class ScreenPositionController;
  class SessionStateDelegate;
  class Shelf;
  class ShelfDelegate;
  class ShelfItemDelegateManager;
  class ShelfModel;
  class ShelfWindowWatcher;
  class ShellDelegate;
  struct ShellInitParams;
  class ShellObserver;
  class SlowAnimationEventFilter;
  class StatusAreaWidget;
  class StickyKeysController;
  class SystemGestureEventFilter;
  class SystemModalContainerEventFilter;
  class SystemTray;
  class SystemTrayDelegate;
  class SystemTrayNotifier;
  class ToplevelWindowEventHandler;
  class TouchTransformerController;
  class TouchObserverHUD;
  class UserActivityDetector;
  class UserWallpaperDelegate;
  class VirtualKeyboardController;
  class VideoActivityNotifier;
  class VideoDetector;
  class WebNotificationTray;
  class WindowCycleController;
  class WindowPositioner;
  class WindowSelectorController;
  
  namespace shell {
  class WindowWatcher;
  }
  
  namespace test {
  class ShellTestApi;
  }
  
  // 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 SystemModalContainerEventFilterDelegate,
                           public ui::EventTarget,
                           public aura::client::ActivationChangeObserver {
   public:
    typedef std::vector<RootWindowController*> RootWindowControllerList;
  
    enum Direction {
      FORWARD,
      BACKWARD
    };
  
    // A shell must be explicitly created so that it can call |Init()| with the
    // delegate set. |delegate| can be NULL (if not required for initialization).
    // Takes ownership of |delegate|.
    static Shell* CreateInstance(const ShellInitParams& init_params);
  
    // Should never be called before |CreateInstance()|.
    static Shell* GetInstance();
  
    // 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 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();
  
    // Returns a root Window when used as a target when creating a new window.
    // The root window of the active window is used in most cases, but can
    // be overridden by using ScopedTargetRootWindow().
    // If you want to get the root Window of the active window, just use
    // |wm::GetActiveWindow()->GetRootWindow()|.
    static aura::Window* GetTargetRootWindow();
  
    // Returns the global Screen object that's always active in ash.
    static gfx::Screen* GetScreen();
  
    // 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);
  
    // Returns the list of containers that match |container_id| in
    // all root windows. If |priority_root| is given, the container
    // in the |priority_root| will be inserted at the top of the list.
    static std::vector<aura::Window*> GetContainersFromAllRootWindows(
        int container_id,
        aura::Window* priority_root);
  
    void set_target_root_window(aura::Window* target_root_window) {
      target_root_window_ = target_root_window;
    }
  
    // Shows the context menu for the background and launcher at
    // |location_in_screen| (in screen coordinates).
    void ShowContextMenu(const gfx::Point& location_in_screen,
                         ui::MenuSourceType source_type);
  
    // Shows the app list. |window| specifies in which display the app
    // list should be shown. If this is NULL, the active root window
    // will be used.
    void ShowAppList(aura::Window* anchor);
  
    // Dismisses the app list.
    void DismissAppList();
  
    // Shows the app list if it's not visible. Dismisses it otherwise.
    void ToggleAppList(aura::Window* anchor);
  
    // Returns app list target visibility.
    bool GetAppListTargetVisibility() const;
  
    // Returns app list window or NULL if it is not visible.
    aura::Window* GetAppListWindow();
  
    // Returns app list view or NULL if it is not visible.
    app_list::AppListView* GetAppListView();
  
    // Returns true if a system-modal dialog window is currently open.
    bool IsSystemModalWindowOpen() const;
  
    // For testing only: set simulation that a modal window is open
    void SimulateModalWindowOpenForTesting(bool modal_window_open) {
      simulate_modal_window_open_for_testing_ = modal_window_open;
    }
  
    // Creates a default views::NonClientFrameView for use by windows in the
    // Ash environment.
    views::NonClientFrameView* CreateDefaultNonClientFrameView(
        views::Widget* widget);
  
    // Rotates focus through containers that can receive focus.
    void RotateFocus(Direction direction);
  
    // Sets the work area insets of the display that contains |window|,
    // this notifies observers too.
    // TODO(sky): this no longer really replicates what happens and is unreliable.
    // Remove this.
    void SetDisplayWorkAreaInsets(aura::Window* window,
                                  const gfx::Insets& insets);
  
    // Called when the user logs in.
    void OnLoginStateChanged(user::LoginStatus status);
  
    // Called after the logged-in user's profile is ready.
    void OnLoginUserProfilePrepared();
  
    // Called when the login status changes.
    // TODO(oshima): Investigate if we can merge this and |OnLoginStateChanged|.
    void UpdateAfterLoginStatusChange(user::LoginStatus status);
  
    // Called when the application is exiting.
    void OnAppTerminating();
  
    // Called when the screen is locked (after the lock window is visible) or
    // unlocked.
    void OnLockStateChanged(bool locked);
  
    // Called when a casting session is started or stopped.
    void OnCastingSessionStartedOrStopped(bool started);
  
    // Called when the overview mode is about to be started (before the windows
    // get re-arranged).
    void OnOverviewModeStarting();
  
    // Called before the overview mode is ending (before the windows get arranged
    // to their final position).
    void OnOverviewModeEnding();
  
    // Called after maximize mode has started, windows might still animate though.
    void OnMaximizeModeStarted();
  
    // Called after maximize mode has ended, windows might still be returning to
    // their original position.
    void OnMaximizeModeEnded();
  
    // Called when a root window is created.
    void OnRootWindowAdded(aura::Window* root_window);
  
    // Initializes |shelf_|.  Does nothing if it's already initialized.
    void CreateShelf();
  
    // Called when the shelf is created for |root_window|.
    void OnShelfCreatedForRootWindow(aura::Window* root_window);
  
    // Creates a virtual keyboard. Deletes the old virtual keyboard if it already
    // exists.
    void CreateKeyboard();
  
    // Deactivates the virtual keyboard.
    void DeactivateKeyboard();
  
    // Show shelf view if it was created hidden (before session has started).
    void ShowShelf();
  
    // Adds/removes observer.
    void AddShellObserver(ShellObserver* observer);
    void RemoveShellObserver(ShellObserver* observer);
  
  #if defined(OS_CHROMEOS)
    // Test if MaximizeModeWindowManager is not enabled, and if
    // MaximizeModeController 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();
  #endif
  
    AcceleratorController* accelerator_controller() {
      return accelerator_controller_.get();
    }
  
    DisplayManager* display_manager() { return display_manager_.get(); }
    ::wm::InputMethodEventFilter* input_method_filter() {
      return input_method_filter_.get();
    }
    ::wm::CompoundEventFilter* env_filter() {
      return env_filter_.get();
    }
    views::corewm::TooltipController* tooltip_controller() {
      return tooltip_controller_.get();
    }
    OverlayEventFilter* overlay_filter() { return overlay_filter_.get(); }
    DesktopBackgroundController* desktop_background_controller() {
      return desktop_background_controller_.get();
    }
    PowerButtonController* power_button_controller() {
      return power_button_controller_.get();
    }
    LockStateController* lock_state_controller() {
      return lock_state_controller_.get();
    }
    MruWindowTracker* mru_window_tracker() {
      return mru_window_tracker_.get();
    }
    ::wm::UserActivityDetector* user_activity_detector() {
      return user_activity_detector_.get();
    }
    VideoDetector* video_detector() {
      return video_detector_.get();
    }
    WindowCycleController* window_cycle_controller() {
      return window_cycle_controller_.get();
    }
    WindowSelectorController* window_selector_controller() {
      return window_selector_controller_.get();
    }
    FocusCycler* focus_cycler() { return focus_cycler_.get(); }
    DisplayController* display_controller() {
      return display_controller_.get();
    }
  #if defined(OS_CHROMEOS) && defined(USE_X11)
    TouchTransformerController* touch_transformer_controller() {
      return touch_transformer_controller_.get();
    }
  #endif  // defined(OS_CHROMEOS) && defined(USE_X11)
    MouseCursorEventFilter* mouse_cursor_filter() {
      return mouse_cursor_filter_.get();
    }
    EventTransformationHandler* event_transformation_handler() {
      return event_transformation_handler_.get();
    }
    ::wm::CursorManager* cursor_manager() { return &cursor_manager_; }
  
    ShellDelegate* delegate() { return delegate_.get(); }
  
    UserWallpaperDelegate* user_wallpaper_delegate() {
      return user_wallpaper_delegate_.get();
    }
  
    SessionStateDelegate* session_state_delegate() {
      return session_state_delegate_.get();
    }
  
    AccessibilityDelegate* accessibility_delegate() {
      return accessibility_delegate_.get();
    }
  
    NewWindowDelegate* new_window_delegate() {
      return new_window_delegate_.get();
    }
  
    MediaDelegate* media_delegate() {
      return media_delegate_.get();
    }
  
    HighContrastController* high_contrast_controller() {
      return high_contrast_controller_.get();
    }
  
    MagnificationController* magnification_controller() {
      return magnification_controller_.get();
    }
  
    PartialMagnificationController* partial_magnification_controller() {
      return partial_magnification_controller_.get();
    }
  
    AutoclickController* autoclick_controller() {
      return autoclick_controller_.get();
    }
  
    aura::client::ActivationClient* activation_client() {
      return activation_client_;
    }
  
    ShelfItemDelegateManager* shelf_item_delegate_manager() {
      return shelf_item_delegate_manager_.get();
    }
  
    // Force the shelf to query for it's current visibility state.
    void UpdateShelfVisibility();
  
    // TODO(oshima): Define an interface to access shelf/launcher
    // state, or just use Launcher.
  
    // Sets/gets the shelf auto-hide behavior on |root_window|.
    void SetShelfAutoHideBehavior(ShelfAutoHideBehavior behavior,
                                  aura::Window* root_window);
    ShelfAutoHideBehavior GetShelfAutoHideBehavior(
        aura::Window* root_window) const;
  
    // Sets/gets shelf's alignment on |root_window|.
    void SetShelfAlignment(ShelfAlignment alignment,
                           aura::Window* root_window);
    ShelfAlignment GetShelfAlignment(const aura::Window* root_window);
  
    // Dims or undims the screen.
    void SetDimming(bool should_dim);
  
    // Notifies |observers_| when entering or exiting fullscreen mode in
    // |root_window|.
    void NotifyFullscreenStateChange(bool is_fullscreen,
                                     aura::Window* root_window);
  
    // Creates a modal background (a partially-opaque fullscreen window)
    // on all displays for |window|.
    void CreateModalBackground(aura::Window* window);
  
    // Called when a modal window is removed. It will activate
    // another modal window if any, or remove modal screens
    // on all displays.
    void OnModalWindowRemoved(aura::Window* removed);
  
    // Returns WebNotificationTray on the primary root window.
    WebNotificationTray* GetWebNotificationTray();
  
    // Does the primary display have status area?
    bool HasPrimaryStatusArea();
  
    // Returns the system tray on primary display.
    SystemTray* GetPrimarySystemTray();
  
    SystemTrayDelegate* system_tray_delegate() {
      return system_tray_delegate_.get();
    }
  
    SystemTrayNotifier* system_tray_notifier() {
      return system_tray_notifier_.get();
    }
  
    static void set_initially_hide_cursor(bool hide) {
      initially_hide_cursor_ = hide;
    }
  
    ResizeShadowController* resize_shadow_controller() {
      return resize_shadow_controller_.get();
    }
  
    // Made available for tests.
    ::wm::ShadowController* shadow_controller() {
      return shadow_controller_.get();
    }
  
    // Starts the animation that occurs on first login.
    void DoInitialWorkspaceAnimation();
  
    AccelerometerController* accelerometer_controller() {
      return accelerometer_controller_.get();
    }
  
    MaximizeModeController* maximize_mode_controller() {
      return maximize_mode_controller_.get();
    }
  
  #if defined(OS_CHROMEOS)
    // TODO(oshima): Move these objects to DisplayController.
    ui::DisplayConfigurator* display_configurator() {
      return display_configurator_.get();
    }
    DisplayConfiguratorAnimation* display_configurator_animation() {
      return display_configurator_animation_.get();
    }
    DisplayErrorObserver* display_error_observer() {
      return display_error_observer_.get();
    }
  
    ResolutionNotificationController* resolution_notification_controller() {
      return resolution_notification_controller_.get();
    }
  
    LogoutConfirmationController* logout_confirmation_controller() {
      return logout_confirmation_controller_.get();
    }
  #endif  // defined(OS_CHROMEOS)
  
    ShelfModel* shelf_model() {
      return shelf_model_.get();
    }
  
    WindowPositioner* window_positioner() {
      return window_positioner_.get();
    }
  
    // Returns the launcher delegate, creating if necesary.
    ShelfDelegate* GetShelfDelegate();
  
    UserMetricsRecorder* metrics() {
      return user_metrics_recorder_.get();
    }
  
    void SetTouchHudProjectionEnabled(bool enabled);
  
    bool is_touch_hud_projection_enabled() const {
      return is_touch_hud_projection_enabled_;
    }
  
  #if defined(OS_CHROMEOS)
    // Creates instance of FirstRunHelper. Caller is responsible for deleting
    // returned object.
    ash::FirstRunHelper* CreateFirstRunHelper();
  
    // Toggles cursor compositing on/off. Native cursor is disabled when cursor
    // compositing is enabled, and vice versa.
    void SetCursorCompositingEnabled(bool enabled);
  
    StickyKeysController* sticky_keys_controller() {
      return sticky_keys_controller_.get();
    }
  #endif  // defined(OS_CHROMEOS)
  
    GPUSupport* gpu_support() { return gpu_support_.get(); }
  
   private:
    FRIEND_TEST_ALL_PREFIXES(ExtendedDesktopTest, TestCursor);
    FRIEND_TEST_ALL_PREFIXES(WindowManagerTest, MouseEventCursors);
    FRIEND_TEST_ALL_PREFIXES(WindowManagerTest, TransformActivate);
    friend class RootWindowController;
    friend class ScopedTargetRootWindow;
    friend class test::ShellTestApi;
    friend class shell::WindowWatcher;
  
    typedef std::pair<aura::Window*, gfx::Rect> WindowAndBoundsPair;
  
    // Takes ownership of |delegate|.
    explicit Shell(ShellDelegate* delegate);
    virtual ~Shell();
  
    void Init(const ShellInitParams& init_params);
  
    // Initializes virtual keyboard controller.
    void InitKeyboard();
  
    // Initializes the root window so that it can host browser windows.
    void InitRootWindow(aura::Window* root_window);
  
    // ash::SystemModalContainerEventFilterDelegate overrides:
    virtual bool CanWindowReceiveEvents(aura::Window* window) OVERRIDE;
  
    // Overridden from ui::EventTarget:
    virtual bool CanAcceptEvent(const ui::Event& event) OVERRIDE;
    virtual EventTarget* GetParentTarget() OVERRIDE;
    virtual scoped_ptr<ui::EventTargetIterator> GetChildIterator() const OVERRIDE;
    virtual ui::EventTargeter* GetEventTargeter() OVERRIDE;
    virtual void OnEvent(ui::Event* event) OVERRIDE;
  
    // Overridden from aura::client::ActivationChangeObserver:
    virtual void OnWindowActivated(aura::Window* gained_active,
                                   aura::Window* lost_active) OVERRIDE;
  
    static Shell* instance_;
  
    // If set before the Shell is initialized, the mouse cursor will be hidden
    // when the screen is initially created.
    static bool initially_hide_cursor_;
  
    // When no explicit target display/RootWindow is given, new windows are
    // created on |scoped_target_root_window_| , unless NULL in
    // which case they are created on |target_root_window_|.
    // |target_root_window_| never becomes NULL during the session.
    aura::Window* target_root_window_;
    aura::Window* scoped_target_root_window_;
  
    // The CompoundEventFilter owned by aura::Env object.
    scoped_ptr< ::wm::CompoundEventFilter> env_filter_;
  
    std::vector<WindowAndBoundsPair> to_restore_;
  
    scoped_ptr<UserMetricsRecorder> user_metrics_recorder_;
    scoped_ptr< ::wm::NestedAcceleratorController> nested_accelerator_controller_;
    scoped_ptr<AcceleratorController> accelerator_controller_;
    scoped_ptr<ShellDelegate> delegate_;
    scoped_ptr<SystemTrayDelegate> system_tray_delegate_;
    scoped_ptr<SystemTrayNotifier> system_tray_notifier_;
    scoped_ptr<UserWallpaperDelegate> user_wallpaper_delegate_;
    scoped_ptr<SessionStateDelegate> session_state_delegate_;
    scoped_ptr<AccessibilityDelegate> accessibility_delegate_;
    scoped_ptr<NewWindowDelegate> new_window_delegate_;
    scoped_ptr<MediaDelegate> media_delegate_;
    scoped_ptr<ShelfDelegate> shelf_delegate_;
    scoped_ptr<ShelfItemDelegateManager> shelf_item_delegate_manager_;
    scoped_ptr<ShelfWindowWatcher> shelf_window_watcher_;
  
    scoped_ptr<ShelfModel> shelf_model_;
    scoped_ptr<WindowPositioner> window_positioner_;
  
    scoped_ptr<AppListController> app_list_controller_;
  
    scoped_ptr<DragDropController> drag_drop_controller_;
    scoped_ptr<ResizeShadowController> resize_shadow_controller_;
    scoped_ptr< ::wm::ShadowController> shadow_controller_;
    scoped_ptr< ::wm::VisibilityController> visibility_controller_;
    scoped_ptr< ::wm::WindowModalityController> window_modality_controller_;
    scoped_ptr<views::corewm::TooltipController> tooltip_controller_;
    scoped_ptr<DesktopBackgroundController> desktop_background_controller_;
    scoped_ptr<PowerButtonController> power_button_controller_;
    scoped_ptr<LockStateController> lock_state_controller_;
    scoped_ptr<MruWindowTracker> mru_window_tracker_;
    scoped_ptr< ::wm::UserActivityDetector> user_activity_detector_;
    scoped_ptr<VideoDetector> video_detector_;
    scoped_ptr<WindowCycleController> window_cycle_controller_;
    scoped_ptr<WindowSelectorController> window_selector_controller_;
    scoped_ptr<FocusCycler> focus_cycler_;
    scoped_ptr<DisplayController> display_controller_;
    scoped_ptr<VirtualKeyboardController> virtual_keyboard_controller_;
    scoped_ptr<HighContrastController> high_contrast_controller_;
    scoped_ptr<MagnificationController> magnification_controller_;
    scoped_ptr<PartialMagnificationController> partial_magnification_controller_;
    scoped_ptr<AutoclickController> autoclick_controller_;
    scoped_ptr<aura::client::FocusClient> focus_client_;
    aura::client::ActivationClient* activation_client_;
  
    scoped_ptr<MouseCursorEventFilter> mouse_cursor_filter_;
    scoped_ptr<ScreenPositionController> screen_position_controller_;
    scoped_ptr<SystemModalContainerEventFilter> modality_filter_;
    scoped_ptr<EventClientImpl> event_client_;
    scoped_ptr<EventTransformationHandler> event_transformation_handler_;
  
    // An event filter that pre-handles key events while the partial
    // screenshot UI or the keyboard overlay is active.
    scoped_ptr<OverlayEventFilter> overlay_filter_;
  
    // An event filter for logging keyboard-related metrics.
    scoped_ptr<KeyboardUMAEventFilter> keyboard_metrics_filter_;
  
    // An event filter which handles moving and resizing windows.
    scoped_ptr<ToplevelWindowEventHandler> toplevel_window_event_handler_;
  
    // An event filter which handles system level gestures
    scoped_ptr<SystemGestureEventFilter> system_gesture_filter_;
  
    // An event filter that pre-handles global accelerators.
    scoped_ptr< ::wm::AcceleratorFilter> accelerator_filter_;
  
    // An event filter that pre-handles all key events to send them to an IME.
    scoped_ptr< ::wm::InputMethodEventFilter> input_method_filter_;
  
    scoped_ptr<DisplayManager> display_manager_;
    scoped_ptr<base::WeakPtrFactory<DisplayManager> >
        weak_display_manager_factory_;
  
    scoped_ptr<LocaleNotificationController> locale_notification_controller_;
  
    scoped_ptr<AccelerometerController> accelerometer_controller_;
  
  #if defined(OS_CHROMEOS)
    scoped_ptr<PowerEventObserver> power_event_observer_;
    scoped_ptr<ui::UserActivityPowerManagerNotifier> user_activity_notifier_;
    scoped_ptr<VideoActivityNotifier> video_activity_notifier_;
    scoped_ptr<StickyKeysController> sticky_keys_controller_;
    scoped_ptr<ResolutionNotificationController>
        resolution_notification_controller_;
    scoped_ptr<BluetoothNotificationController>
        bluetooth_notification_controller_;
    scoped_ptr<LogoutConfirmationController> logout_confirmation_controller_;
    scoped_ptr<LastWindowClosedLogoutReminder>
        last_window_closed_logout_reminder_;
    // Controls video output device state.
    scoped_ptr<ui::DisplayConfigurator> display_configurator_;
    scoped_ptr<DisplayConfiguratorAnimation> display_configurator_animation_;
    scoped_ptr<DisplayErrorObserver> display_error_observer_;
    scoped_ptr<ProjectingObserver> projecting_observer_;
  
    // Listens for output changes and updates the display manager.
    scoped_ptr<DisplayChangeObserver> display_change_observer_;
  
  #if defined(USE_X11)
    scoped_ptr<ui::EventHandler> magnifier_key_scroll_handler_;
    scoped_ptr<ui::EventHandler> speech_feedback_handler_;
    scoped_ptr<TouchTransformerController> touch_transformer_controller_;
  #endif  // defined(USE_X11)
  #endif  // defined(OS_CHROMEOS)
  
    scoped_ptr<MaximizeModeController> maximize_mode_controller_;
  
    // |native_cursor_manager_| is owned by |cursor_manager_|, but we keep a
    // pointer to vend to test code.
    AshNativeCursorManager* native_cursor_manager_;
  
  // Cursor may be hidden on certain key events in ChromeOS, whereas we never hide
  // the cursor on Windows.
  #if defined(OS_CHROMEOS)
    CursorManager cursor_manager_;
  #else  // !defined(OS_CHROMEOS)
    ::wm::CursorManager cursor_manager_;
  #endif  // defined(OS_CHROMEOS)
  
    ObserverList<ShellObserver> observers_;
  
    // For testing only: simulate that a modal window is open
    bool simulate_modal_window_open_for_testing_;
  
    bool is_touch_hud_projection_enabled_;
  
    // Injected content::GPUDataManager support.
    scoped_ptr<GPUSupport> gpu_support_;
  
    DISALLOW_COPY_AND_ASSIGN(Shell);
  };
  
  }  // namespace ash
  
  #endif  // ASH_SHELL_H_
  