ash/shell.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef ASH_SHELL_H_
   6 #define ASH_SHELL_H_
   7
   8 #include <utility>
   9 #include <vector>
  10
  11 #include "ash/ash_export.h"
  12 #include "ash/metrics/user_metrics_recorder.h"
  13 #include "ash/shelf/shelf_types.h"
  14 #include "ash/system/user/login_status.h"
  15 #include "ash/wm/cursor_manager_chromeos.h"
  16 #include "ash/wm/system_modal_container_event_filter_delegate.h"
  17 #include "base/basictypes.h"
  18 #include "base/compiler_specific.h"
  19 #include "base/gtest_prod_util.h"
  20 #include "base/memory/scoped_ptr.h"
  21 #include "base/memory/weak_ptr.h"
  22 #include "base/observer_list.h"
  23 #include "ui/aura/window.h"
  24 #include "ui/base/ui_base_types.h"
  25 #include "ui/events/event_target.h"
  26 #include "ui/gfx/insets.h"
  27 #include "ui/gfx/screen.h"
  28 #include "ui/gfx/size.h"
  29 #include "ui/wm/core/cursor_manager.h"
  30 #include "ui/wm/public/activation_change_observer.h"
  31
  32 namespace app_list {
  33 class AppListView;
  34 }
  35 namespace aura {
  36 class EventFilter;
  37 class RootWindow;
  38 class Window;
  39 namespace client {
  40 class ActivationClient;
  41 class FocusClient;
  42 }
  43 }
  44
  45 namespace gfx {
  46 class ImageSkia;
  47 class Point;
  48 class Rect;
  49 }
  50
  51 namespace ui {
  52 class DisplayConfigurator;
  53 class Layer;
  54 class UserActivityPowerManagerNotifier;
  55 }
  56 namespace views {
  57 class NonClientFrameView;
  58 class Widget;
  59 namespace corewm {
  60 class TooltipController;
  61 }
  62 }
  63
  64 namespace wm {
  65 class CompoundEventFilter;
  66 class InputMethodEventFilter;
  67 class ShadowController;
  68 class VisibilityController;
  69 class UserActivityDetector;
  70 class WindowModalityController;
  71 }
  72
  73 namespace ash {
  74
  75 class AcceleratorController;
  76 class AccelerometerController;
  77 class AcceleratorFilter;
  78 class AccessibilityDelegate;
  79 class AppListController;
  80 class AshNativeCursorManager;
  81 class AutoclickController;
  82 class BluetoothNotificationController;
  83 class CaptureController;
  84 class DesktopBackgroundController;
  85 class DisplayChangeObserver;
  86 class DisplayController;
  87 class DisplayErrorObserver;
  88 class DisplayManager;
  89 class DragDropController;
  90 class EventClientImpl;
  91 class EventRewriterEventFilter;
  92 class EventTransformationHandler;
  93 class FirstRunHelper;
  94 class FocusCycler;
  95 class GPUSupport;
  96 class HighContrastController;
  97 class KeyboardUMAEventFilter;
  98 class LastWindowClosedLogoutReminder;
  99 class LocaleNotificationController;
 100 class LockStateController;
 101 class LogoutConfirmationController;
 102 class MagnificationController;
 103 class MaximizeModeController;
 104 class MaximizeModeWindowManager;
 105 class MediaDelegate;
 106 class MouseCursorEventFilter;
 107 class MruWindowTracker;
 108 class NestedDispatcherController;
 109 class NewWindowDelegate;
 110 class OutputConfiguratorAnimation;
 111 class OverlayEventFilter;
 112 class PartialMagnificationController;
 113 class PowerButtonController;
 114 class PowerEventObserver;
 115 class ProjectingObserver;
 116 class ResizeShadowController;
 117 class ResolutionNotificationController;
 118 class RootWindowController;
 119 class ScopedTargetRootWindow;
 120 class ScreenAsh;
 121 class ScreenPositionController;
 122 class SessionStateDelegate;
 123 class Shelf;
 124 class ShelfDelegate;
 125 class ShelfItemDelegateManager;
 126 class ShelfModel;
 127 class ShelfWindowWatcher;
 128 class ShellDelegate;
 129 class ShellObserver;
 130 class SlowAnimationEventFilter;
 131 class StatusAreaWidget;
 132 class StickyKeysController;
 133 class SystemGestureEventFilter;
 134 class SystemModalContainerEventFilter;
 135 class SystemTray;
 136 class SystemTrayDelegate;
 137 class SystemTrayNotifier;
 138 class ToplevelWindowEventHandler;
 139 class TouchObserverHUD;
 140 class UserActivityDetector;
 141 class UserWallpaperDelegate;
 142 class VideoActivityNotifier;
 143 class VideoDetector;
 144 class WebNotificationTray;
 145 class WindowCycleController;
 146 class WindowPositioner;
 147 class WindowSelectorController;
 148
 149 namespace shell {
 150 class WindowWatcher;
 151 }
 152
 153 namespace test {
 154 class ShellTestApi;
 155 }
 156
 157 // Shell is a singleton object that presents the Shell API and implements the
 158 // RootWindow's delegate interface.
 159 //
 160 // Upon creation, the Shell sets itself as the RootWindow's delegate, which
 161 // takes ownership of the Shell.
 162 class ASH_EXPORT Shell : public SystemModalContainerEventFilterDelegate,
 163                          public ui::EventTarget,
 164                          public aura::client::ActivationChangeObserver {
 165  public:
 166   typedef std::vector<RootWindowController*> RootWindowControllerList;
 167
 168   enum Direction {
 169     FORWARD,
 170     BACKWARD
 171   };
 172
 173   // A shell must be explicitly created so that it can call |Init()| with the
 174   // delegate set. |delegate| can be NULL (if not required for initialization).
 175   // Takes ownership of |delegate|.
 176   static Shell* CreateInstance(ShellDelegate* delegate);
 177
 178   // Should never be called before |CreateInstance()|.
 179   static Shell* GetInstance();
 180
 181   // Returns true if the ash shell has been instantiated.
 182   static bool HasInstance();
 183
 184   static void DeleteInstance();
 185
 186   // Returns the root window controller for the primary root window.
 187   // TODO(oshima): move this to |RootWindowController|
 188   static RootWindowController* GetPrimaryRootWindowController();
 189
 190   // Returns all root window controllers.
 191   // TODO(oshima): move this to |RootWindowController|
 192   static RootWindowControllerList GetAllRootWindowControllers();
 193
 194   // Returns the primary root Window. The primary root Window is the one that
 195   // has a launcher.
 196   static aura::Window* GetPrimaryRootWindow();
 197
 198   // Returns a root Window when used as a target when creating a new window.
 199   // The root window of the active window is used in most cases, but can
 200   // be overridden by using ScopedTargetRootWindow().
 201   // If you want to get the root Window of the active window, just use
 202   // |wm::GetActiveWindow()->GetRootWindow()|.
 203   static aura::Window* GetTargetRootWindow();
 204
 205   // Returns the global Screen object that's always active in ash.
 206   static gfx::Screen* GetScreen();
 207
 208   // Returns all root windows.
 209   static aura::Window::Windows GetAllRootWindows();
 210
 211   static aura::Window* GetContainer(aura::Window* root_window,
 212                                     int container_id);
 213   static const aura::Window* GetContainer(const aura::Window* root_window,
 214                                           int container_id);
 215
 216   // Returns the list of containers that match |container_id| in
 217   // all root windows. If |priority_root| is given, the container
 218   // in the |priority_root| will be inserted at the top of the list.
 219   static std::vector<aura::Window*> GetContainersFromAllRootWindows(
 220       int container_id,
 221       aura::Window* priority_root);
 222
 223   void set_target_root_window(aura::Window* target_root_window) {
 224     target_root_window_ = target_root_window;
 225   }
 226
 227   // Shows the context menu for the background and launcher at
 228   // |location_in_screen| (in screen coordinates).
 229   void ShowContextMenu(const gfx::Point& location_in_screen,
 230                        ui::MenuSourceType source_type);
 231
 232   // Toggles the app list. |window| specifies in which display the app
 233   // list should be shown. If this is NULL, the active root window
 234   // will be used.
 235   void ToggleAppList(aura::Window* anchor);
 236
 237   // Returns app list target visibility.
 238   bool GetAppListTargetVisibility() const;
 239
 240   // Returns app list window or NULL if it is not visible.
 241   aura::Window* GetAppListWindow();
 242
 243   // Returns app list view or NULL if it is not visible.
 244   app_list::AppListView* GetAppListView();
 245
 246   // Returns true if a system-modal dialog window is currently open.
 247   bool IsSystemModalWindowOpen() const;
 248
 249   // For testing only: set simulation that a modal window is open
 250   void SimulateModalWindowOpenForTesting(bool modal_window_open) {
 251     simulate_modal_window_open_for_testing_ = modal_window_open;
 252   }
 253
 254   // Creates a default views::NonClientFrameView for use by windows in the
 255   // Ash environment.
 256   views::NonClientFrameView* CreateDefaultNonClientFrameView(
 257       views::Widget* widget);
 258
 259   // Rotates focus through containers that can receive focus.
 260   void RotateFocus(Direction direction);
 261
 262   // Sets the work area insets of the display that contains |window|,
 263   // this notifies observers too.
 264   // TODO(sky): this no longer really replicates what happens and is unreliable.
 265   // Remove this.
 266   void SetDisplayWorkAreaInsets(aura::Window* window,
 267                                 const gfx::Insets& insets);
 268
 269   // Called when the user logs in.
 270   void OnLoginStateChanged(user::LoginStatus status);
 271
 272   // Called after the logged-in user's profile is ready.
 273   void OnLoginUserProfilePrepared();
 274
 275   // Called when the login status changes.
 276   // TODO(oshima): Investigate if we can merge this and |OnLoginStateChanged|.
 277   void UpdateAfterLoginStatusChange(user::LoginStatus status);
 278
 279   // Called when the application is exiting.
 280   void OnAppTerminating();
 281
 282   // Called when the screen is locked (after the lock window is visible) or
 283   // unlocked.
 284   void OnLockStateChanged(bool locked);
 285
 286   // Called when a casting session is started or stopped.
 287   void OnCastingSessionStartedOrStopped(bool started);
 288
 289   // Called when the overview mode is about to be started (before the windows
 290   // get re-arranged).
 291   void OnOverviewModeStarting();
 292
 293   // Called before the overview mode is ending (before the windows get arranged
 294   // to their final position).
 295   void OnOverviewModeEnding();
 296
 297   // Called after maximize mode has started, windows might still animate though.
 298   void OnMaximizeModeStarted();
 299
 300   // Called after maximize mode has ended, windows might still be returning to
 301   // their original position.
 302   void OnMaximizeModeEnded();
 303
 304   // Called when a root window is created.
 305   void OnRootWindowAdded(aura::Window* root_window);
 306
 307   // Initializes |shelf_|.  Does nothing if it's already initialized.
 308   void CreateShelf();
 309
 310   // Called when the shelf is created for |root_window|.
 311   void OnShelfCreatedForRootWindow(aura::Window* root_window);
 312
 313   // Creates a virtual keyboard. Deletes the old virtual keyboard if it already
 314   // exists.
 315   void CreateKeyboard();
 316
 317   // Deactivates the virtual keyboard.
 318   void DeactivateKeyboard();
 319
 320   // Show shelf view if it was created hidden (before session has started).
 321   void ShowShelf();
 322
 323   // Adds/removes observer.
 324   void AddShellObserver(ShellObserver* observer);
 325   void RemoveShellObserver(ShellObserver* observer);
 326
 327   // Turn the always maximize mode window manager on or off.
 328   void EnableMaximizeModeWindowManager(bool enable);
 329
 330   // Test if the MaximizeModeWindowManager is enabled or not.
 331   bool IsMaximizeModeWindowManagerEnabled();
 332
 333   AcceleratorController* accelerator_controller() {
 334     return accelerator_controller_.get();
 335   }
 336
 337   DisplayManager* display_manager() { return display_manager_.get(); }
 338   ::wm::InputMethodEventFilter* input_method_filter() {
 339     return input_method_filter_.get();
 340   }
 341   ::wm::CompoundEventFilter* env_filter() {
 342     return env_filter_.get();
 343   }
 344   views::corewm::TooltipController* tooltip_controller() {
 345     return tooltip_controller_.get();
 346   }
 347   OverlayEventFilter* overlay_filter() { return overlay_filter_.get(); }
 348   DesktopBackgroundController* desktop_background_controller() {
 349     return desktop_background_controller_.get();
 350   }
 351   PowerButtonController* power_button_controller() {
 352     return power_button_controller_.get();
 353   }
 354   LockStateController* lock_state_controller() {
 355     return lock_state_controller_.get();
 356   }
 357   MruWindowTracker* mru_window_tracker() {
 358     return mru_window_tracker_.get();
 359   }
 360   ::wm::UserActivityDetector* user_activity_detector() {
 361     return user_activity_detector_.get();
 362   }
 363   VideoDetector* video_detector() {
 364     return video_detector_.get();
 365   }
 366   WindowSelectorController* window_selector_controller() {
 367     return window_selector_controller_.get();
 368   }
 369   FocusCycler* focus_cycler() { return focus_cycler_.get(); }
 370   DisplayController* display_controller() {
 371     return display_controller_.get();
 372   }
 373   MouseCursorEventFilter* mouse_cursor_filter() {
 374     return mouse_cursor_filter_.get();
 375   }
 376   EventTransformationHandler* event_transformation_handler() {
 377     return event_transformation_handler_.get();
 378   }
 379   ::wm::CursorManager* cursor_manager() { return &cursor_manager_; }
 380
 381   ShellDelegate* delegate() { return delegate_.get(); }
 382
 383   UserWallpaperDelegate* user_wallpaper_delegate() {
 384     return user_wallpaper_delegate_.get();
 385   }
 386
 387   SessionStateDelegate* session_state_delegate() {
 388     return session_state_delegate_.get();
 389   }
 390
 391   AccessibilityDelegate* accessibility_delegate() {
 392     return accessibility_delegate_.get();
 393   }
 394
 395   NewWindowDelegate* new_window_delegate() {
 396     return new_window_delegate_.get();
 397   }
 398
 399   MediaDelegate* media_delegate() {
 400     return media_delegate_.get();
 401   }
 402
 403   HighContrastController* high_contrast_controller() {
 404     return high_contrast_controller_.get();
 405   }
 406
 407   MagnificationController* magnification_controller() {
 408     return magnification_controller_.get();
 409   }
 410
 411   PartialMagnificationController* partial_magnification_controller() {
 412     return partial_magnification_controller_.get();
 413   }
 414
 415   AutoclickController* autoclick_controller() {
 416     return autoclick_controller_.get();
 417   }
 418
 419   aura::client::ActivationClient* activation_client() {
 420     return activation_client_;
 421   }
 422
 423   ShelfItemDelegateManager* shelf_item_delegate_manager() {
 424     return shelf_item_delegate_manager_.get();
 425   }
 426
 427   // Force the shelf to query for it's current visibility state.
 428   void UpdateShelfVisibility();
 429
 430   // TODO(oshima): Define an interface to access shelf/launcher
 431   // state, or just use Launcher.
 432
 433   // Sets/gets the shelf auto-hide behavior on |root_window|.
 434   void SetShelfAutoHideBehavior(ShelfAutoHideBehavior behavior,
 435                                 aura::Window* root_window);
 436   ShelfAutoHideBehavior GetShelfAutoHideBehavior(
 437       aura::Window* root_window) const;
 438
 439   // Sets/gets shelf's alignment on |root_window|.
 440   void SetShelfAlignment(ShelfAlignment alignment,
 441                          aura::Window* root_window);
 442   ShelfAlignment GetShelfAlignment(aura::Window* root_window);
 443
 444   // Dims or undims the screen.
 445   void SetDimming(bool should_dim);
 446
 447   // Notifies |observers_| when entering or exiting fullscreen mode in
 448   // |root_window|.
 449   void NotifyFullscreenStateChange(bool is_fullscreen,
 450                                    aura::Window* root_window);
 451
 452   // Creates a modal background (a partially-opaque fullscreen window)
 453   // on all displays for |window|.
 454   void CreateModalBackground(aura::Window* window);
 455
 456   // Called when a modal window is removed. It will activate
 457   // another modal window if any, or remove modal screens
 458   // on all displays.
 459   void OnModalWindowRemoved(aura::Window* removed);
 460
 461   // Returns WebNotificationTray on the primary root window.
 462   WebNotificationTray* GetWebNotificationTray();
 463
 464   // Does the primary display have status area?
 465   bool HasPrimaryStatusArea();
 466
 467   // Returns the system tray on primary display.
 468   SystemTray* GetPrimarySystemTray();
 469
 470   SystemTrayDelegate* system_tray_delegate() {
 471     return system_tray_delegate_.get();
 472   }
 473
 474   SystemTrayNotifier* system_tray_notifier() {
 475     return system_tray_notifier_.get();
 476   }
 477
 478   static void set_initially_hide_cursor(bool hide) {
 479     initially_hide_cursor_ = hide;
 480   }
 481
 482   ResizeShadowController* resize_shadow_controller() {
 483     return resize_shadow_controller_.get();
 484   }
 485
 486   // Made available for tests.
 487   ::wm::ShadowController* shadow_controller() {
 488     return shadow_controller_.get();
 489   }
 490
 491   // Starts the animation that occurs on first login.
 492   void DoInitialWorkspaceAnimation();
 493
 494   AccelerometerController* accelerometer_controller() {
 495     return accelerometer_controller_.get();
 496   }
 497
 498   MaximizeModeController* maximize_mode_controller() {
 499     return maximize_mode_controller_.get();
 500   }
 501
 502 #if defined(OS_CHROMEOS)
 503   // TODO(oshima): Move these objects to DisplayController.
 504   ui::DisplayConfigurator* display_configurator() {
 505     return display_configurator_.get();
 506   }
 507   OutputConfiguratorAnimation* output_configurator_animation() {
 508     return output_configurator_animation_.get();
 509   }
 510   DisplayErrorObserver* display_error_observer() {
 511     return display_error_observer_.get();
 512   }
 513
 514   ResolutionNotificationController* resolution_notification_controller() {
 515     return resolution_notification_controller_.get();
 516   }
 517
 518   LogoutConfirmationController* logout_confirmation_controller() {
 519     return logout_confirmation_controller_.get();
 520   }
 521 #endif  // defined(OS_CHROMEOS)
 522
 523   ShelfModel* shelf_model() {
 524     return shelf_model_.get();
 525   }
 526
 527   WindowPositioner* window_positioner() {
 528     return window_positioner_.get();
 529   }
 530
 531   // Returns the launcher delegate, creating if necesary.
 532   ShelfDelegate* GetShelfDelegate();
 533
 534   UserMetricsRecorder* metrics() {
 535     return user_metrics_recorder_.get();
 536   }
 537
 538   void SetTouchHudProjectionEnabled(bool enabled);
 539
 540   bool is_touch_hud_projection_enabled() const {
 541     return is_touch_hud_projection_enabled_;
 542   }
 543
 544 #if defined(OS_CHROMEOS)
 545   // Creates instance of FirstRunHelper. Caller is responsible for deleting
 546   // returned object.
 547   ash::FirstRunHelper* CreateFirstRunHelper();
 548
 549   // Toggles cursor compositing on/off. Native cursor is disabled when cursor
 550   // compositing is enabled, and vice versa.
 551   void SetCursorCompositingEnabled(bool enabled);
 552
 553   StickyKeysController* sticky_keys_controller() {
 554     return sticky_keys_controller_.get();
 555   }
 556 #endif  // defined(OS_CHROMEOS)
 557
 558   GPUSupport* gpu_support() { return gpu_support_.get(); }
 559
 560  private:
 561   FRIEND_TEST_ALL_PREFIXES(ExtendedDesktopTest, TestCursor);
 562   FRIEND_TEST_ALL_PREFIXES(WindowManagerTest, MouseEventCursors);
 563   FRIEND_TEST_ALL_PREFIXES(WindowManagerTest, TransformActivate);
 564   friend class RootWindowController;
 565   friend class ScopedTargetRootWindow;
 566   friend class test::ShellTestApi;
 567   friend class shell::WindowWatcher;
 568
 569   typedef std::pair<aura::Window*, gfx::Rect> WindowAndBoundsPair;
 570
 571   // Takes ownership of |delegate|.
 572   explicit Shell(ShellDelegate* delegate);
 573   virtual ~Shell();
 574
 575   void Init();
 576
 577   // Initializes virtual keyboard controller.
 578   void InitKeyboard();
 579
 580   // Initializes the root window so that it can host browser windows.
 581   void InitRootWindow(aura::Window* root_window);
 582
 583   // ash::SystemModalContainerEventFilterDelegate overrides:
 584   virtual bool CanWindowReceiveEvents(aura::Window* window) OVERRIDE;
 585
 586   // Overridden from ui::EventTarget:
 587   virtual bool CanAcceptEvent(const ui::Event& event) OVERRIDE;
 588   virtual EventTarget* GetParentTarget() OVERRIDE;
 589   virtual scoped_ptr<ui::EventTargetIterator> GetChildIterator() const OVERRIDE;
 590   virtual ui::EventTargeter* GetEventTargeter() OVERRIDE;
 591   virtual void OnEvent(ui::Event* event) OVERRIDE;
 592
 593   // Overridden from aura::client::ActivationChangeObserver:
 594   virtual void OnWindowActivated(aura::Window* gained_active,
 595                                  aura::Window* lost_active) OVERRIDE;
 596
 597   static Shell* instance_;
 598
 599   // If set before the Shell is initialized, the mouse cursor will be hidden
 600   // when the screen is initially created.
 601   static bool initially_hide_cursor_;
 602
 603   // When no explicit target display/RootWindow is given, new windows are
 604   // created on |scoped_target_root_window_| , unless NULL in
 605   // which case they are created on |target_root_window_|.
 606   // |target_root_window_| never becomes NULL during the session.
 607   aura::Window* target_root_window_;
 608   aura::Window* scoped_target_root_window_;
 609
 610   // The CompoundEventFilter owned by aura::Env object.
 611   scoped_ptr< ::wm::CompoundEventFilter> env_filter_;
 612
 613   std::vector<WindowAndBoundsPair> to_restore_;
 614
 615   scoped_ptr<UserMetricsRecorder> user_metrics_recorder_;
 616   scoped_ptr<NestedDispatcherController> nested_dispatcher_controller_;
 617   scoped_ptr<AcceleratorController> accelerator_controller_;
 618   scoped_ptr<ShellDelegate> delegate_;
 619   scoped_ptr<SystemTrayDelegate> system_tray_delegate_;
 620   scoped_ptr<SystemTrayNotifier> system_tray_notifier_;
 621   scoped_ptr<UserWallpaperDelegate> user_wallpaper_delegate_;
 622   scoped_ptr<SessionStateDelegate> session_state_delegate_;
 623   scoped_ptr<AccessibilityDelegate> accessibility_delegate_;
 624   scoped_ptr<NewWindowDelegate> new_window_delegate_;
 625   scoped_ptr<MediaDelegate> media_delegate_;
 626   scoped_ptr<ShelfDelegate> shelf_delegate_;
 627   scoped_ptr<ShelfItemDelegateManager> shelf_item_delegate_manager_;
 628   scoped_ptr<ShelfWindowWatcher> shelf_window_watcher_;
 629
 630   scoped_ptr<ShelfModel> shelf_model_;
 631   scoped_ptr<WindowPositioner> window_positioner_;
 632
 633   scoped_ptr<AppListController> app_list_controller_;
 634
 635   scoped_ptr<DragDropController> drag_drop_controller_;
 636   scoped_ptr<ResizeShadowController> resize_shadow_controller_;
 637   scoped_ptr< ::wm::ShadowController> shadow_controller_;
 638   scoped_ptr< ::wm::VisibilityController> visibility_controller_;
 639   scoped_ptr< ::wm::WindowModalityController> window_modality_controller_;
 640   scoped_ptr<views::corewm::TooltipController> tooltip_controller_;
 641   scoped_ptr<DesktopBackgroundController> desktop_background_controller_;
 642   scoped_ptr<PowerButtonController> power_button_controller_;
 643   scoped_ptr<LockStateController> lock_state_controller_;
 644   scoped_ptr<MruWindowTracker> mru_window_tracker_;
 645   scoped_ptr< ::wm::UserActivityDetector> user_activity_detector_;
 646   scoped_ptr<VideoDetector> video_detector_;
 647   scoped_ptr<WindowSelectorController> window_selector_controller_;
 648   scoped_ptr<FocusCycler> focus_cycler_;
 649   scoped_ptr<DisplayController> display_controller_;
 650   scoped_ptr<HighContrastController> high_contrast_controller_;
 651   scoped_ptr<MagnificationController> magnification_controller_;
 652   scoped_ptr<PartialMagnificationController> partial_magnification_controller_;
 653   scoped_ptr<AutoclickController> autoclick_controller_;
 654   scoped_ptr<aura::client::FocusClient> focus_client_;
 655   aura::client::ActivationClient* activation_client_;
 656
 657   scoped_ptr<MouseCursorEventFilter> mouse_cursor_filter_;
 658   scoped_ptr<ScreenPositionController> screen_position_controller_;
 659   scoped_ptr<SystemModalContainerEventFilter> modality_filter_;
 660   scoped_ptr<EventClientImpl> event_client_;
 661   scoped_ptr<EventTransformationHandler> event_transformation_handler_;
 662
 663   // An event filter that pre-handles key events while the partial
 664   // screenshot UI or the keyboard overlay is active.
 665   scoped_ptr<OverlayEventFilter> overlay_filter_;
 666
 667   // An event filter for logging keyboard-related metrics.
 668   scoped_ptr<KeyboardUMAEventFilter> keyboard_metrics_filter_;
 669
 670   // An event filter which handles moving and resizing windows.
 671   scoped_ptr<ToplevelWindowEventHandler> toplevel_window_event_handler_;
 672
 673   // An event filter which handles system level gestures
 674   scoped_ptr<SystemGestureEventFilter> system_gesture_filter_;
 675
 676   // An event filter that pre-handles global accelerators.
 677   scoped_ptr<AcceleratorFilter> accelerator_filter_;
 678
 679   // An event filter that pre-handles all key events to send them to an IME.
 680   scoped_ptr< ::wm::InputMethodEventFilter> input_method_filter_;
 681
 682   scoped_ptr<DisplayManager> display_manager_;
 683   scoped_ptr<base::WeakPtrFactory<DisplayManager> >
 684       weak_display_manager_factory_;
 685
 686   scoped_ptr<LocaleNotificationController> locale_notification_controller_;
 687
 688   // The maximized window manager (if enabled).
 689   scoped_ptr<MaximizeModeWindowManager> maximize_mode_window_manager_;
 690
 691   scoped_ptr<AccelerometerController> accelerometer_controller_;
 692
 693 #if defined(OS_CHROMEOS)
 694   scoped_ptr<PowerEventObserver> power_event_observer_;
 695   scoped_ptr<ui::UserActivityPowerManagerNotifier> user_activity_notifier_;
 696   scoped_ptr<VideoActivityNotifier> video_activity_notifier_;
 697   scoped_ptr<StickyKeysController> sticky_keys_controller_;
 698   scoped_ptr<ResolutionNotificationController>
 699       resolution_notification_controller_;
 700   scoped_ptr<BluetoothNotificationController>
 701       bluetooth_notification_controller_;
 702   scoped_ptr<LogoutConfirmationController> logout_confirmation_controller_;
 703   scoped_ptr<LastWindowClosedLogoutReminder>
 704       last_window_closed_logout_reminder_;
 705   // Controls video output device state.
 706   scoped_ptr<ui::DisplayConfigurator> display_configurator_;
 707   scoped_ptr<OutputConfiguratorAnimation> output_configurator_animation_;
 708   scoped_ptr<DisplayErrorObserver> display_error_observer_;
 709   scoped_ptr<ProjectingObserver> projecting_observer_;
 710
 711   // Listens for output changes and updates the display manager.
 712   scoped_ptr<DisplayChangeObserver> display_change_observer_;
 713
 714 #if defined(USE_X11)
 715   scoped_ptr<ui::EventHandler> magnifier_key_scroll_handler_;
 716   scoped_ptr<ui::EventHandler> speech_feedback_handler_;
 717 #endif  // defined(USE_X11)
 718 #endif  // defined(OS_CHROMEOS)
 719
 720   scoped_ptr<MaximizeModeController> maximize_mode_controller_;
 721
 722   // |native_cursor_manager_| is owned by |cursor_manager_|, but we keep a
 723   // pointer to vend to test code.
 724   AshNativeCursorManager* native_cursor_manager_;
 725
 726 // Cursor may be hidden on certain key events in ChromeOS, whereas we never hide
 727 // the cursor on Windows.
 728 #if defined(OS_CHROMEOS)
 729   CursorManager cursor_manager_;
 730 #else  // !defined(OS_CHROMEOS)
 731   ::wm::CursorManager cursor_manager_;
 732 #endif  // defined(OS_CHROMEOS)
 733
 734   ObserverList<ShellObserver> observers_;
 735
 736   // For testing only: simulate that a modal window is open
 737   bool simulate_modal_window_open_for_testing_;
 738
 739   bool is_touch_hud_projection_enabled_;
 740
 741   // Injected content::GPUDataManager support.
 742   scoped_ptr<GPUSupport> gpu_support_;
 743
 744   DISALLOW_COPY_AND_ASSIGN(Shell);
 745 };
 746
 747 }  // namespace ash
 748
 749 #endif  // ASH_SHELL_H_