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