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