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 #include "ash/shell.h" 6 7 #include <algorithm> 8 #include <string> 9 10 #include "ash/accelerators/focus_manager_factory.h" 11 #include "ash/ash_switches.h" 12 #include "ash/caps_lock_delegate.h" 13 #include "ash/desktop_background/desktop_background_controller.h" 14 #include "ash/desktop_background/desktop_background_view.h" 15 #include "ash/desktop_background/user_wallpaper_delegate.h" 16 #include "ash/display/display_controller.h" 17 #include "ash/display/display_manager.h" 18 #include "ash/display/event_transformation_handler.h" 19 #include "ash/display/mouse_cursor_event_filter.h" 20 #include "ash/display/resolution_notification_controller.h" 21 #include "ash/display/screen_position_controller.h" 22 #include "ash/drag_drop/drag_drop_controller.h" 23 #include "ash/focus_cycler.h" 24 #include "ash/high_contrast/high_contrast_controller.h" 25 #include "ash/host/root_window_host_factory.h" 26 #include "ash/launcher/launcher_delegate.h" 27 #include "ash/launcher/launcher_model.h" 28 #include "ash/magnifier/magnification_controller.h" 29 #include "ash/magnifier/partial_magnification_controller.h" 30 #include "ash/root_window_controller.h" 31 #include "ash/screen_ash.h" 32 #include "ash/session_state_delegate.h" 33 #include "ash/shelf/shelf_layout_manager.h" 34 #include "ash/shelf/shelf_widget.h" 35 #include "ash/shell_delegate.h" 36 #include "ash/shell_factory.h" 37 #include "ash/shell_window_ids.h" 38 #include "ash/system/locale/locale_notification_controller.h" 39 #include "ash/system/status_area_widget.h" 40 #include "ash/system/tray/system_tray_delegate.h" 41 #include "ash/system/tray/system_tray_notifier.h" 42 #include "ash/wm/activation_controller.h" 43 #include "ash/wm/app_list_controller.h" 44 #include "ash/wm/ash_activation_controller.h" 45 #include "ash/wm/ash_focus_rules.h" 46 #include "ash/wm/ash_native_cursor_manager.h" 47 #include "ash/wm/base_layout_manager.h" 48 #include "ash/wm/capture_controller.h" 49 #include "ash/wm/coordinate_conversion.h" 50 #include "ash/wm/custom_frame_view_ash.h" 51 #include "ash/wm/event_client_impl.h" 52 #include "ash/wm/event_rewriter_event_filter.h" 53 #include "ash/wm/lock_state_controller.h" 54 #include "ash/wm/lock_state_controller_impl2.h" 55 #include "ash/wm/mru_window_tracker.h" 56 #include "ash/wm/overlay_event_filter.h" 57 #include "ash/wm/power_button_controller.h" 58 #include "ash/wm/property_util.h" 59 #include "ash/wm/resize_shadow_controller.h" 60 #include "ash/wm/root_window_layout_manager.h" 61 #include "ash/wm/screen_dimmer.h" 62 #include "ash/wm/session_state_controller_impl.h" 63 #include "ash/wm/system_gesture_event_filter.h" 64 #include "ash/wm/system_modal_container_event_filter.h" 65 #include "ash/wm/system_modal_container_layout_manager.h" 66 #include "ash/wm/user_activity_detector.h" 67 #include "ash/wm/video_detector.h" 68 #include "ash/wm/window_animations.h" 69 #include "ash/wm/window_cycle_controller.h" 70 #include "ash/wm/window_properties.h" 71 #include "ash/wm/window_selector_controller.h" 72 #include "ash/wm/window_util.h" 73 #include "ash/wm/workspace_controller.h" 74 #include "base/bind.h" 75 #include "base/command_line.h" 76 #include "base/debug/leak_annotations.h" 77 #include "ui/aura/client/aura_constants.h" 78 #include "ui/aura/client/user_action_client.h" 79 #include "ui/aura/env.h" 80 #include "ui/aura/focus_manager.h" 81 #include "ui/aura/layout_manager.h" 82 #include "ui/aura/root_window.h" 83 #include "ui/aura/window.h" 84 #include "ui/base/ui_base_switches.h" 85 #include "ui/compositor/layer.h" 86 #include "ui/compositor/layer_animator.h" 87 #include "ui/gfx/display.h" 88 #include "ui/gfx/image/image_skia.h" 89 #include "ui/gfx/screen.h" 90 #include "ui/gfx/size.h" 91 #include "ui/keyboard/keyboard.h" 92 #include "ui/keyboard/keyboard_util.h" 93 #include "ui/message_center/message_center.h" 94 #include "ui/views/corewm/compound_event_filter.h" 95 #include "ui/views/corewm/corewm_switches.h" 96 #include "ui/views/corewm/focus_controller.h" 97 #include "ui/views/corewm/input_method_event_filter.h" 98 #include "ui/views/corewm/shadow_controller.h" 99 #include "ui/views/corewm/tooltip_controller.h" 100 #include "ui/views/corewm/visibility_controller.h" 101 #include "ui/views/corewm/window_modality_controller.h" 102 #include "ui/views/focus/focus_manager_factory.h" 103 #include "ui/views/widget/native_widget_aura.h" 104 #include "ui/views/widget/widget.h" 105 106 #if !defined(OS_MACOSX) 107 #include "ash/accelerators/accelerator_controller.h" 108 #include "ash/accelerators/accelerator_filter.h" 109 #include "ash/accelerators/nested_dispatcher_controller.h" 110 #endif 111 112 #if defined(OS_CHROMEOS) 113 #if defined(USE_X11) 114 #include "ash/ash_constants.h" 115 #include "ash/display/display_change_observer_x11.h" 116 #include "ash/display/display_error_observer.h" 117 #include "ash/display/output_configurator_animation.h" 118 #include "base/chromeos/chromeos_version.h" 119 #include "base/message_loop/message_pump_aurax11.h" 120 #include "chromeos/display/output_configurator.h" 121 #include "content/public/browser/gpu_data_manager.h" 122 #include "content/public/common/content_switches.h" 123 #include "gpu/config/gpu_feature_type.h" 124 #endif // defined(USE_X11) 125 #include "ash/system/chromeos/power/power_status.h" 126 #endif // defined(OS_CHROMEOS) 127 128 namespace ash { 129 130 namespace { 131 132 using aura::Window; 133 using views::Widget; 134 135 // This dummy class is used for shell unit tests. We dont have chrome delegate 136 // in these tests. 137 class DummyUserWallpaperDelegate : public UserWallpaperDelegate { 138 public: 139 DummyUserWallpaperDelegate() {} 140 141 virtual ~DummyUserWallpaperDelegate() {} 142 143 virtual int GetAnimationType() OVERRIDE { 144 return views::corewm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE; 145 } 146 147 virtual bool ShouldShowInitialAnimation() OVERRIDE { 148 return false; 149 } 150 151 virtual void UpdateWallpaper() OVERRIDE { 152 } 153 154 virtual void InitializeWallpaper() OVERRIDE { 155 ash::Shell::GetInstance()->desktop_background_controller()-> 156 CreateEmptyWallpaper(); 157 } 158 159 virtual void OpenSetWallpaperPage() OVERRIDE { 160 } 161 162 virtual bool CanOpenSetWallpaperPage() OVERRIDE { 163 return false; 164 } 165 166 virtual void OnWallpaperAnimationFinished() OVERRIDE { 167 } 168 169 virtual void OnWallpaperBootAnimationFinished() OVERRIDE { 170 } 171 172 private: 173 DISALLOW_COPY_AND_ASSIGN(DummyUserWallpaperDelegate); 174 }; 175 176 // A Corewm VisibilityController subclass that calls the Ash animation routine 177 // so we can pick up our extended animations. See ash/wm/window_animations.h. 178 class AshVisibilityController : public views::corewm::VisibilityController { 179 public: 180 AshVisibilityController() {} 181 virtual ~AshVisibilityController() {} 182 183 private: 184 // Overridden from views::corewm::VisibilityController: 185 virtual bool CallAnimateOnChildWindowVisibilityChanged( 186 aura::Window* window, 187 bool visible) OVERRIDE { 188 return AnimateOnChildWindowVisibilityChanged(window, visible); 189 } 190 191 DISALLOW_COPY_AND_ASSIGN(AshVisibilityController); 192 }; 193 194 } // namespace 195 196 // static 197 Shell* Shell::instance_ = NULL; 198 // static 199 bool Shell::initially_hide_cursor_ = false; 200 201 //////////////////////////////////////////////////////////////////////////////// 202 // Shell, public: 203 204 Shell::Shell(ShellDelegate* delegate) 205 : screen_(new ScreenAsh), 206 target_root_window_(NULL), 207 scoped_target_root_window_(NULL), 208 delegate_(delegate), 209 activation_client_(NULL), 210 #if defined(OS_CHROMEOS) && defined(USE_X11) 211 output_configurator_(new chromeos::OutputConfigurator()), 212 #endif // defined(OS_CHROMEOS) 213 native_cursor_manager_(new AshNativeCursorManager), 214 cursor_manager_(scoped_ptr<views::corewm::NativeCursorManager>( 215 native_cursor_manager_)), 216 browser_context_(NULL), 217 simulate_modal_window_open_for_testing_(false), 218 is_touch_hud_projection_enabled_(false) { 219 DCHECK(delegate_.get()); 220 display_manager_.reset(new internal::DisplayManager); 221 222 ANNOTATE_LEAKING_OBJECT_PTR(screen_); // see crbug.com/156466 223 gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_ALTERNATE, screen_); 224 if (!gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE)) 225 gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, screen_); 226 display_controller_.reset(new DisplayController); 227 #if defined(OS_CHROMEOS) && defined(USE_X11) 228 bool is_panel_fitting_disabled = 229 content::GpuDataManager::GetInstance()->IsFeatureBlacklisted( 230 gpu::GPU_FEATURE_TYPE_PANEL_FITTING) || 231 CommandLine::ForCurrentProcess()->HasSwitch( 232 ::switches::kDisablePanelFitting); 233 234 output_configurator_->Init(!is_panel_fitting_disabled); 235 236 base::MessagePumpAuraX11::Current()->AddDispatcherForRootWindow( 237 output_configurator()); 238 // We can't do this with a root window listener because XI_HierarchyChanged 239 // messages don't have a target window. 240 base::MessagePumpAuraX11::Current()->AddObserver(output_configurator()); 241 #endif // defined(OS_CHROMEOS) 242 AddPreTargetHandler(this); 243 244 #if defined(OS_CHROMEOS) 245 internal::PowerStatus::Initialize(); 246 #endif 247 } 248 249 Shell::~Shell() { 250 views::FocusManagerFactory::Install(NULL); 251 252 // Remove the focus from any window. This will prevent overhead and side 253 // effects (e.g. crashes) from changing focus during shutdown. 254 // See bug crbug.com/134502. 255 aura::client::GetFocusClient(GetPrimaryRootWindow())->FocusWindow(NULL); 256 257 // Please keep in same order as in Init() because it's easy to miss one. 258 RemovePreTargetHandler(event_rewriter_filter_.get()); 259 RemovePreTargetHandler(user_activity_detector_.get()); 260 RemovePreTargetHandler(overlay_filter_.get()); 261 RemovePreTargetHandler(input_method_filter_.get()); 262 RemovePreTargetHandler(window_modality_controller_.get()); 263 if (mouse_cursor_filter_) 264 RemovePreTargetHandler(mouse_cursor_filter_.get()); 265 RemovePreTargetHandler(system_gesture_filter_.get()); 266 RemovePreTargetHandler(event_transformation_handler_.get()); 267 #if !defined(OS_MACOSX) 268 RemovePreTargetHandler(accelerator_filter_.get()); 269 #endif 270 271 // TooltipController is deleted with the Shell so removing its references. 272 RemovePreTargetHandler(tooltip_controller_.get()); 273 274 // AppList needs to be released before shelf layout manager, which is 275 // destroyed with launcher container in the loop below. However, app list 276 // container is now on top of launcher container and released after it. 277 // TODO(xiyuan): Move it back when app list container is no longer needed. 278 app_list_controller_.reset(); 279 280 // Destroy SystemTrayDelegate before destroying the status area(s). 281 system_tray_delegate_->Shutdown(); 282 system_tray_delegate_.reset(); 283 284 locale_notification_controller_.reset(); 285 286 // Drag-and-drop must be canceled prior to close all windows. 287 drag_drop_controller_.reset(); 288 289 // Destroy all child windows including widgets. 290 display_controller_->CloseChildWindows(); 291 292 // Destroy SystemTrayNotifier after destroying SystemTray as TrayItems 293 // needs to remove observers from it. 294 system_tray_notifier_.reset(); 295 296 // These need a valid Shell instance to clean up properly, so explicitly 297 // delete them before invalidating the instance. 298 // Alphabetical. TODO(oshima): sort. 299 magnification_controller_.reset(); 300 partial_magnification_controller_.reset(); 301 resize_shadow_controller_.reset(); 302 shadow_controller_.reset(); 303 tooltip_controller_.reset(); 304 event_client_.reset(); 305 window_cycle_controller_.reset(); 306 capture_controller_.reset(); 307 nested_dispatcher_controller_.reset(); 308 user_action_client_.reset(); 309 visibility_controller_.reset(); 310 launcher_delegate_.reset(); 311 launcher_model_.reset(); 312 video_detector_.reset(); 313 314 power_button_controller_.reset(); 315 lock_state_controller_.reset(); 316 mru_window_tracker_.reset(); 317 318 resolution_notification_controller_.reset(); 319 320 // This also deletes all RootWindows. Note that we invoke Shutdown() on 321 // DisplayController before resetting |display_controller_|, since destruction 322 // of its owned RootWindowControllers relies on the value. 323 display_controller_->Shutdown(); 324 display_controller_.reset(); 325 screen_position_controller_.reset(); 326 327 // Delete the activation controller after other controllers and launcher 328 // because they might have registered ActivationChangeObserver. 329 activation_controller_.reset(); 330 331 #if defined(OS_CHROMEOS) && defined(USE_X11) 332 if (display_change_observer_) 333 output_configurator_->RemoveObserver(display_change_observer_.get()); 334 if (output_configurator_animation_) 335 output_configurator_->RemoveObserver(output_configurator_animation_.get()); 336 if (display_error_observer_) 337 output_configurator_->RemoveObserver(display_error_observer_.get()); 338 base::MessagePumpAuraX11::Current()->RemoveDispatcherForRootWindow( 339 output_configurator()); 340 base::MessagePumpAuraX11::Current()->RemoveObserver(output_configurator()); 341 display_change_observer_.reset(); 342 #endif // defined(OS_CHROMEOS) 343 344 #if defined(OS_CHROMEOS) 345 internal::PowerStatus::Shutdown(); 346 #endif 347 348 DCHECK(instance_ == this); 349 instance_ = NULL; 350 } 351 352 // static 353 Shell* Shell::CreateInstance(ShellDelegate* delegate) { 354 CHECK(!instance_); 355 instance_ = new Shell(delegate); 356 instance_->Init(); 357 return instance_; 358 } 359 360 // static 361 Shell* Shell::GetInstance() { 362 DCHECK(instance_); 363 return instance_; 364 } 365 366 // static 367 bool Shell::HasInstance() { 368 return !!instance_; 369 } 370 371 // static 372 void Shell::DeleteInstance() { 373 delete instance_; 374 instance_ = NULL; 375 } 376 377 // static 378 internal::RootWindowController* Shell::GetPrimaryRootWindowController() { 379 return GetRootWindowController(GetPrimaryRootWindow()); 380 } 381 382 // static 383 Shell::RootWindowControllerList Shell::GetAllRootWindowControllers() { 384 return Shell::GetInstance()->display_controller()-> 385 GetAllRootWindowControllers(); 386 } 387 388 // static 389 aura::RootWindow* Shell::GetPrimaryRootWindow() { 390 return GetInstance()->display_controller()->GetPrimaryRootWindow(); 391 } 392 393 // static 394 aura::RootWindow* Shell::GetActiveRootWindow() { 395 Shell* shell = GetInstance(); 396 if (shell->scoped_target_root_window_) 397 return shell->scoped_target_root_window_; 398 return shell->target_root_window_; 399 } 400 401 // static 402 gfx::Screen* Shell::GetScreen() { 403 return gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE); 404 } 405 406 // static 407 Shell::RootWindowList Shell::GetAllRootWindows() { 408 return Shell::GetInstance()->display_controller()-> 409 GetAllRootWindows(); 410 } 411 412 // static 413 aura::Window* Shell::GetContainer(aura::RootWindow* root_window, 414 int container_id) { 415 return root_window->GetChildById(container_id); 416 } 417 418 // static 419 const aura::Window* Shell::GetContainer(const aura::RootWindow* root_window, 420 int container_id) { 421 return root_window->GetChildById(container_id); 422 } 423 424 // static 425 std::vector<aura::Window*> Shell::GetContainersFromAllRootWindows( 426 int container_id, 427 aura::RootWindow* priority_root) { 428 std::vector<aura::Window*> containers; 429 RootWindowList root_windows = GetAllRootWindows(); 430 for (RootWindowList::const_iterator it = root_windows.begin(); 431 it != root_windows.end(); ++it) { 432 aura::Window* container = (*it)->GetChildById(container_id); 433 if (container) { 434 if (priority_root && priority_root->Contains(container)) 435 containers.insert(containers.begin(), container); 436 else 437 containers.push_back(container); 438 } 439 } 440 return containers; 441 } 442 443 // static 444 bool Shell::IsForcedMaximizeMode() { 445 CommandLine* command_line = CommandLine::ForCurrentProcess(); 446 return command_line->HasSwitch(switches::kForcedMaximizeMode); 447 } 448 449 void Shell::Init() { 450 CommandLine* command_line = CommandLine::ForCurrentProcess(); 451 452 delegate_->PreInit(); 453 bool display_initialized = false; 454 #if defined(OS_CHROMEOS) && defined(USE_X11) 455 output_configurator_animation_.reset( 456 new internal::OutputConfiguratorAnimation()); 457 output_configurator_->AddObserver(output_configurator_animation_.get()); 458 if (base::chromeos::IsRunningOnChromeOS()) { 459 display_change_observer_.reset(new internal::DisplayChangeObserverX11); 460 // Register |display_change_observer_| first so that the rest of 461 // observer gets invoked after the root windows are configured. 462 output_configurator_->AddObserver(display_change_observer_.get()); 463 display_error_observer_.reset(new internal::DisplayErrorObserver()); 464 output_configurator_->AddObserver(display_error_observer_.get()); 465 output_configurator_->set_state_controller(display_change_observer_.get()); 466 if (!command_line->HasSwitch(ash::switches::kAshDisableSoftwareMirroring)) 467 output_configurator_->set_mirroring_controller(display_manager_.get()); 468 output_configurator_->Start( 469 delegate_->IsFirstRunAfterBoot() ? kChromeOsBootColor : 0); 470 display_initialized = true; 471 } 472 #endif 473 if (!display_initialized) 474 display_manager_->InitFromCommandLine(); 475 476 // Install the custom factory first so that views::FocusManagers for Tray, 477 // Launcher, and WallPaper could be created by the factory. 478 views::FocusManagerFactory::Install(new AshFocusManagerFactory); 479 480 env_filter_.reset(new views::corewm::CompoundEventFilter); 481 AddPreTargetHandler(env_filter_.get()); 482 483 // Env creates the compositor. Historically it seems to have been implicitly 484 // initialized first by the ActivationController, but now that FocusController 485 // no longer does this we need to do it explicitly. 486 aura::Env::GetInstance(); 487 if (views::corewm::UseFocusController()) { 488 views::corewm::FocusController* focus_controller = 489 new views::corewm::FocusController(new wm::AshFocusRules); 490 focus_client_.reset(focus_controller); 491 activation_client_ = focus_controller; 492 activation_client_->AddObserver(this); 493 } else { 494 focus_client_.reset(new aura::FocusManager); 495 activation_controller_.reset( 496 new internal::ActivationController( 497 focus_client_.get(), 498 new internal::AshActivationController)); 499 activation_client_ = activation_controller_.get(); 500 AddPreTargetHandler(activation_controller_.get()); 501 } 502 503 focus_cycler_.reset(new internal::FocusCycler()); 504 505 screen_position_controller_.reset(new internal::ScreenPositionController); 506 root_window_host_factory_.reset(delegate_->CreateRootWindowHostFactory()); 507 508 display_controller_->Start(); 509 display_controller_->InitPrimaryDisplay(); 510 aura::RootWindow* root_window = display_controller_->GetPrimaryRootWindow(); 511 target_root_window_ = root_window; 512 513 resolution_notification_controller_.reset( 514 new internal::ResolutionNotificationController); 515 516 cursor_manager_.SetDisplay(DisplayController::GetPrimaryDisplay()); 517 518 #if !defined(OS_MACOSX) 519 nested_dispatcher_controller_.reset(new NestedDispatcherController); 520 accelerator_controller_.reset(new AcceleratorController); 521 #endif 522 523 // The order in which event filters are added is significant. 524 event_rewriter_filter_.reset(new internal::EventRewriterEventFilter); 525 AddPreTargetHandler(event_rewriter_filter_.get()); 526 527 // UserActivityDetector passes events to observers, so let them get 528 // rewritten first. 529 user_activity_detector_.reset(new UserActivityDetector); 530 AddPreTargetHandler(user_activity_detector_.get()); 531 532 overlay_filter_.reset(new internal::OverlayEventFilter); 533 AddPreTargetHandler(overlay_filter_.get()); 534 AddShellObserver(overlay_filter_.get()); 535 536 input_method_filter_.reset(new views::corewm::InputMethodEventFilter( 537 root_window->GetAcceleratedWidget())); 538 AddPreTargetHandler(input_method_filter_.get()); 539 540 #if !defined(OS_MACOSX) 541 accelerator_filter_.reset(new internal::AcceleratorFilter); 542 AddPreTargetHandler(accelerator_filter_.get()); 543 #endif 544 545 event_transformation_handler_.reset(new internal::EventTransformationHandler); 546 AddPreTargetHandler(event_transformation_handler_.get()); 547 548 system_gesture_filter_.reset(new internal::SystemGestureEventFilter); 549 AddPreTargetHandler(system_gesture_filter_.get()); 550 551 capture_controller_.reset(new internal::CaptureController); 552 553 // The keyboard system must be initialized before the RootWindowController is 554 // created. 555 if (keyboard::IsKeyboardEnabled()) 556 keyboard::InitializeKeyboard(); 557 558 if (command_line->HasSwitch(ash::switches::kAshDisableNewLockAnimations)) 559 lock_state_controller_.reset(new SessionStateControllerImpl); 560 else 561 lock_state_controller_.reset(new LockStateControllerImpl2); 562 power_button_controller_.reset(new PowerButtonController( 563 lock_state_controller_.get())); 564 AddShellObserver(lock_state_controller_.get()); 565 566 drag_drop_controller_.reset(new internal::DragDropController); 567 mouse_cursor_filter_.reset(new internal::MouseCursorEventFilter()); 568 PrependPreTargetHandler(mouse_cursor_filter_.get()); 569 570 // Create Controllers that may need root window. 571 // TODO(oshima): Move as many controllers before creating 572 // RootWindowController as possible. 573 visibility_controller_.reset(new AshVisibilityController); 574 user_action_client_.reset(delegate_->CreateUserActionClient()); 575 window_modality_controller_.reset( 576 new views::corewm::WindowModalityController); 577 AddPreTargetHandler(window_modality_controller_.get()); 578 579 magnification_controller_.reset( 580 MagnificationController::CreateInstance()); 581 mru_window_tracker_.reset(new MruWindowTracker(activation_client_)); 582 583 partial_magnification_controller_.reset( 584 new PartialMagnificationController()); 585 586 high_contrast_controller_.reset(new HighContrastController); 587 video_detector_.reset(new VideoDetector); 588 window_cycle_controller_.reset(new WindowCycleController()); 589 window_selector_controller_.reset(new WindowSelectorController()); 590 591 tooltip_controller_.reset(new views::corewm::TooltipController( 592 gfx::SCREEN_TYPE_ALTERNATE)); 593 AddPreTargetHandler(tooltip_controller_.get()); 594 595 event_client_.reset(new internal::EventClientImpl); 596 597 // This controller needs to be set before SetupManagedWindowMode. 598 desktop_background_controller_.reset(new DesktopBackgroundController()); 599 user_wallpaper_delegate_.reset(delegate_->CreateUserWallpaperDelegate()); 600 if (!user_wallpaper_delegate_) 601 user_wallpaper_delegate_.reset(new DummyUserWallpaperDelegate()); 602 603 // StatusAreaWidget uses Shell's CapsLockDelegate. 604 caps_lock_delegate_.reset(delegate_->CreateCapsLockDelegate()); 605 606 session_state_delegate_.reset(delegate_->CreateSessionStateDelegate()); 607 608 if (!command_line->HasSwitch(views::corewm::switches::kNoDropShadows)) { 609 resize_shadow_controller_.reset(new internal::ResizeShadowController()); 610 shadow_controller_.reset( 611 new views::corewm::ShadowController(activation_client_)); 612 } 613 614 // Create system_tray_notifier_ before the delegate. 615 system_tray_notifier_.reset(new ash::SystemTrayNotifier()); 616 617 // Initialize system_tray_delegate_ before initializing StatusAreaWidget. 618 system_tray_delegate_.reset(delegate()->CreateSystemTrayDelegate()); 619 if (!system_tray_delegate_) 620 system_tray_delegate_.reset(SystemTrayDelegate::CreateDummyDelegate()); 621 622 internal::RootWindowController* root_window_controller = 623 new internal::RootWindowController(root_window); 624 InitRootWindowController(root_window_controller, 625 delegate_->IsFirstRunAfterBoot()); 626 627 locale_notification_controller_.reset( 628 new internal::LocaleNotificationController); 629 630 // Initialize system_tray_delegate_ after StatusAreaWidget is created. 631 system_tray_delegate_->Initialize(); 632 633 display_controller_->InitSecondaryDisplays(); 634 635 // Force Layout 636 root_window_controller->root_window_layout()->OnWindowResized(); 637 638 // It needs to be created after OnWindowResized has been called, otherwise the 639 // widget will not paint when restoring after a browser crash. Also it needs 640 // to be created after InitSecondaryDisplays() to initialize the wallpapers in 641 // the correct size. 642 user_wallpaper_delegate_->InitializeWallpaper(); 643 644 if (initially_hide_cursor_) 645 cursor_manager_.HideCursor(); 646 cursor_manager_.SetCursor(ui::kCursorPointer); 647 648 if (!cursor_manager_.IsCursorVisible()) { 649 // Cursor might have been hidden by something other than chrome. 650 // Let the first mouse event show the cursor. 651 env_filter_->set_cursor_hidden_by_filter(true); 652 } 653 } 654 655 void Shell::ShowContextMenu(const gfx::Point& location_in_screen, 656 ui::MenuSourceType source_type) { 657 // No context menus if there is no session with an active user. 658 if (!session_state_delegate_->NumberOfLoggedInUsers()) 659 return; 660 // No context menus when screen is locked. 661 if (session_state_delegate_->IsScreenLocked()) 662 return; 663 664 aura::RootWindow* root = 665 wm::GetRootWindowMatching(gfx::Rect(location_in_screen, gfx::Size())); 666 // TODO(oshima): The root and root window controller shouldn't be 667 // NULL even for the out-of-bounds |location_in_screen| (It should 668 // return the primary root). Investigate why/how this is 669 // happening. crbug.com/165214. 670 internal::RootWindowController* rwc = GetRootWindowController(root); 671 CHECK(rwc) << "root=" << root 672 << ", location:" << location_in_screen.ToString(); 673 if (rwc) 674 rwc->ShowContextMenu(location_in_screen, source_type); 675 } 676 677 void Shell::ToggleAppList(aura::Window* window) { 678 // If the context window is not given, show it on the active root window. 679 if (!window) 680 window = GetActiveRootWindow(); 681 if (!app_list_controller_) 682 app_list_controller_.reset(new internal::AppListController); 683 app_list_controller_->SetVisible(!app_list_controller_->IsVisible(), window); 684 } 685 686 bool Shell::GetAppListTargetVisibility() const { 687 return app_list_controller_.get() && 688 app_list_controller_->GetTargetVisibility(); 689 } 690 691 aura::Window* Shell::GetAppListWindow() { 692 return app_list_controller_.get() ? app_list_controller_->GetWindow() : NULL; 693 } 694 695 bool Shell::IsSystemModalWindowOpen() const { 696 if (simulate_modal_window_open_for_testing_) 697 return true; 698 const std::vector<aura::Window*> containers = GetContainersFromAllRootWindows( 699 internal::kShellWindowId_SystemModalContainer, NULL); 700 for (std::vector<aura::Window*>::const_iterator cit = containers.begin(); 701 cit != containers.end(); ++cit) { 702 for (aura::Window::Windows::const_iterator wit = (*cit)->children().begin(); 703 wit != (*cit)->children().end(); ++wit) { 704 if ((*wit)->GetProperty(aura::client::kModalKey) == 705 ui::MODAL_TYPE_SYSTEM && (*wit)->TargetVisibility()) { 706 return true; 707 } 708 } 709 } 710 return false; 711 } 712 713 views::NonClientFrameView* Shell::CreateDefaultNonClientFrameView( 714 views::Widget* widget) { 715 // Use translucent-style window frames for dialogs. 716 CustomFrameViewAsh* frame_view = new CustomFrameViewAsh; 717 frame_view->Init(widget); 718 return frame_view; 719 } 720 721 void Shell::RotateFocus(Direction direction) { 722 focus_cycler_->RotateFocus( 723 direction == FORWARD ? internal::FocusCycler::FORWARD : 724 internal::FocusCycler::BACKWARD); 725 } 726 727 void Shell::SetDisplayWorkAreaInsets(Window* contains, 728 const gfx::Insets& insets) { 729 if (!display_controller_->UpdateWorkAreaOfDisplayNearestWindow( 730 contains, insets)) { 731 return; 732 } 733 FOR_EACH_OBSERVER(ShellObserver, observers_, 734 OnDisplayWorkAreaInsetsChanged()); 735 } 736 737 void Shell::OnLoginStateChanged(user::LoginStatus status) { 738 FOR_EACH_OBSERVER(ShellObserver, observers_, OnLoginStateChanged(status)); 739 } 740 741 void Shell::UpdateAfterLoginStatusChange(user::LoginStatus status) { 742 RootWindowControllerList controllers = GetAllRootWindowControllers(); 743 for (RootWindowControllerList::iterator iter = controllers.begin(); 744 iter != controllers.end(); ++iter) 745 (*iter)->UpdateAfterLoginStatusChange(status); 746 } 747 748 void Shell::OnAppTerminating() { 749 FOR_EACH_OBSERVER(ShellObserver, observers_, OnAppTerminating()); 750 } 751 752 void Shell::OnLockStateChanged(bool locked) { 753 FOR_EACH_OBSERVER(ShellObserver, observers_, OnLockStateChanged(locked)); 754 #ifndef NDEBUG 755 // Make sure that there is no system modal in Lock layer when unlocked. 756 if (!locked) { 757 std::vector<aura::Window*> containers = GetContainersFromAllRootWindows( 758 internal::kShellWindowId_LockSystemModalContainer, 759 GetPrimaryRootWindow()); 760 for (std::vector<aura::Window*>::const_iterator iter = containers.begin(); 761 iter != containers.end(); ++iter) { 762 DCHECK_EQ(0u, (*iter)->children().size()); 763 } 764 } 765 #endif 766 } 767 768 void Shell::CreateLauncher() { 769 RootWindowControllerList controllers = GetAllRootWindowControllers(); 770 for (RootWindowControllerList::iterator iter = controllers.begin(); 771 iter != controllers.end(); ++iter) 772 (*iter)->shelf()->CreateLauncher(); 773 } 774 775 void Shell::ShowLauncher() { 776 RootWindowControllerList controllers = GetAllRootWindowControllers(); 777 for (RootWindowControllerList::iterator iter = controllers.begin(); 778 iter != controllers.end(); ++iter) 779 (*iter)->ShowLauncher(); 780 } 781 782 void Shell::AddShellObserver(ShellObserver* observer) { 783 observers_.AddObserver(observer); 784 } 785 786 void Shell::RemoveShellObserver(ShellObserver* observer) { 787 observers_.RemoveObserver(observer); 788 } 789 790 void Shell::UpdateShelfVisibility() { 791 RootWindowControllerList controllers = GetAllRootWindowControllers(); 792 for (RootWindowControllerList::iterator iter = controllers.begin(); 793 iter != controllers.end(); ++iter) 794 if ((*iter)->shelf()) 795 (*iter)->UpdateShelfVisibility(); 796 } 797 798 void Shell::SetShelfAutoHideBehavior(ShelfAutoHideBehavior behavior, 799 aura::RootWindow* root_window) { 800 ash::internal::ShelfLayoutManager::ForLauncher(root_window)-> 801 SetAutoHideBehavior(behavior); 802 } 803 804 ShelfAutoHideBehavior Shell::GetShelfAutoHideBehavior( 805 aura::RootWindow* root_window) const { 806 return ash::internal::ShelfLayoutManager::ForLauncher(root_window)-> 807 auto_hide_behavior(); 808 } 809 810 void Shell::SetShelfAlignment(ShelfAlignment alignment, 811 aura::RootWindow* root_window) { 812 if (ash::internal::ShelfLayoutManager::ForLauncher(root_window)-> 813 SetAlignment(alignment)) { 814 FOR_EACH_OBSERVER( 815 ShellObserver, observers_, OnShelfAlignmentChanged(root_window)); 816 } 817 } 818 819 ShelfAlignment Shell::GetShelfAlignment(aura::RootWindow* root_window) { 820 return GetRootWindowController(root_window)-> 821 GetShelfLayoutManager()->GetAlignment(); 822 } 823 824 void Shell::SetDimming(bool should_dim) { 825 RootWindowControllerList controllers = GetAllRootWindowControllers(); 826 for (RootWindowControllerList::iterator iter = controllers.begin(); 827 iter != controllers.end(); ++iter) 828 (*iter)->screen_dimmer()->SetDimming(should_dim); 829 } 830 831 void Shell::CreateModalBackground(aura::Window* window) { 832 if (!modality_filter_) { 833 modality_filter_.reset(new internal::SystemModalContainerEventFilter(this)); 834 AddPreTargetHandler(modality_filter_.get()); 835 } 836 RootWindowControllerList controllers = GetAllRootWindowControllers(); 837 for (RootWindowControllerList::iterator iter = controllers.begin(); 838 iter != controllers.end(); ++iter) 839 (*iter)->GetSystemModalLayoutManager(window)->CreateModalBackground(); 840 } 841 842 void Shell::OnModalWindowRemoved(aura::Window* removed) { 843 RootWindowControllerList controllers = GetAllRootWindowControllers(); 844 bool activated = false; 845 for (RootWindowControllerList::iterator iter = controllers.begin(); 846 iter != controllers.end() && !activated; ++iter) { 847 activated = (*iter)->GetSystemModalLayoutManager(removed)-> 848 ActivateNextModalWindow(); 849 } 850 if (!activated) { 851 RemovePreTargetHandler(modality_filter_.get()); 852 modality_filter_.reset(); 853 for (RootWindowControllerList::iterator iter = controllers.begin(); 854 iter != controllers.end(); ++iter) 855 (*iter)->GetSystemModalLayoutManager(removed)->DestroyModalBackground(); 856 } 857 } 858 859 WebNotificationTray* Shell::GetWebNotificationTray() { 860 return GetPrimaryRootWindowController()->shelf()-> 861 status_area_widget()->web_notification_tray(); 862 } 863 864 bool Shell::HasPrimaryStatusArea() { 865 ShelfWidget* shelf = GetPrimaryRootWindowController()->shelf(); 866 return shelf && shelf->status_area_widget(); 867 } 868 869 SystemTray* Shell::GetPrimarySystemTray() { 870 return GetPrimaryRootWindowController()->GetSystemTray(); 871 } 872 873 LauncherDelegate* Shell::GetLauncherDelegate() { 874 if (!launcher_delegate_) { 875 launcher_model_.reset(new LauncherModel); 876 launcher_delegate_.reset( 877 delegate_->CreateLauncherDelegate(launcher_model_.get())); 878 } 879 return launcher_delegate_.get(); 880 } 881 882 void Shell::SetTouchHudProjectionEnabled(bool enabled) { 883 if (is_touch_hud_projection_enabled_ == enabled) 884 return; 885 886 is_touch_hud_projection_enabled_ = enabled; 887 FOR_EACH_OBSERVER(ShellObserver, observers_, 888 OnTouchHudProjectionToggled(enabled)); 889 } 890 891 void Shell::InitRootWindowForSecondaryDisplay(aura::RootWindow* root) { 892 internal::RootWindowController* controller = 893 new internal::RootWindowController(root); 894 // Pass false for the |is_first_run_after_boot| parameter so we'll show a 895 // black background on this display instead of trying to mimic the boot splash 896 // screen. 897 InitRootWindowController(controller, false); 898 899 controller->root_window_layout()->OnWindowResized(); 900 desktop_background_controller_->OnRootWindowAdded(root); 901 high_contrast_controller_->OnRootWindowAdded(root); 902 root->ShowRootWindow(); 903 // Activate new root for testing. 904 // TODO(oshima): remove this. 905 target_root_window_ = root; 906 907 // Create a launcher if a user is already logged. 908 if (Shell::GetInstance()->session_state_delegate()->NumberOfLoggedInUsers()) 909 controller->shelf()->CreateLauncher(); 910 } 911 912 void Shell::DoInitialWorkspaceAnimation() { 913 return GetPrimaryRootWindowController()->workspace_controller()-> 914 DoInitialAnimation(); 915 } 916 917 void Shell::InitRootWindowController( 918 internal::RootWindowController* controller, 919 bool first_run_after_boot) { 920 921 aura::RootWindow* root_window = controller->root_window(); 922 DCHECK(activation_client_); 923 DCHECK(visibility_controller_.get()); 924 DCHECK(drag_drop_controller_.get()); 925 DCHECK(capture_controller_.get()); 926 DCHECK(window_cycle_controller_.get()); 927 928 aura::client::SetFocusClient(root_window, focus_client_.get()); 929 input_method_filter_->SetInputMethodPropertyInRootWindow(root_window); 930 aura::client::SetActivationClient(root_window, activation_client_); 931 if (views::corewm::UseFocusController()) { 932 views::corewm::FocusController* controller = 933 static_cast<views::corewm::FocusController*>(activation_client_); 934 root_window->AddPreTargetHandler(controller); 935 } 936 aura::client::SetVisibilityClient(root_window, visibility_controller_.get()); 937 aura::client::SetDragDropClient(root_window, drag_drop_controller_.get()); 938 aura::client::SetCaptureClient(root_window, capture_controller_.get()); 939 aura::client::SetScreenPositionClient(root_window, 940 screen_position_controller_.get()); 941 aura::client::SetCursorClient(root_window, &cursor_manager_); 942 aura::client::SetTooltipClient(root_window, tooltip_controller_.get()); 943 aura::client::SetEventClient(root_window, event_client_.get()); 944 945 if (nested_dispatcher_controller_) { 946 aura::client::SetDispatcherClient(root_window, 947 nested_dispatcher_controller_.get()); 948 } 949 if (user_action_client_) 950 aura::client::SetUserActionClient(root_window, user_action_client_.get()); 951 952 controller->Init(first_run_after_boot); 953 954 mru_window_tracker_->OnRootWindowAdded(root_window); 955 } 956 957 //////////////////////////////////////////////////////////////////////////////// 958 // Shell, private: 959 960 bool Shell::CanWindowReceiveEvents(aura::Window* window) { 961 RootWindowControllerList controllers = GetAllRootWindowControllers(); 962 for (RootWindowControllerList::iterator iter = controllers.begin(); 963 iter != controllers.end(); ++iter) { 964 internal::SystemModalContainerLayoutManager* layout_manager = 965 (*iter)->GetSystemModalLayoutManager(window); 966 if (layout_manager && layout_manager->CanWindowReceiveEvents(window)) 967 return true; 968 } 969 return false; 970 } 971 972 //////////////////////////////////////////////////////////////////////////////// 973 // Shell, ui::EventTarget overrides: 974 975 bool Shell::CanAcceptEvent(const ui::Event& event) { 976 return true; 977 } 978 979 ui::EventTarget* Shell::GetParentTarget() { 980 return NULL; 981 } 982 983 void Shell::OnEvent(ui::Event* event) { 984 } 985 986 //////////////////////////////////////////////////////////////////////////////// 987 // Shell, aura::client::ActivationChangeObserver implementation: 988 989 void Shell::OnWindowActivated(aura::Window* gained_active, 990 aura::Window* lost_active) { 991 if (gained_active) 992 target_root_window_ = gained_active->GetRootWindow(); 993 } 994 995 } // namespace ash 996