Home | History | Annotate | Download | only in ash 
      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/accelerator_controller.h"
     11 #include "ash/accelerators/accelerator_delegate.h"
     12 #include "ash/accelerators/focus_manager_factory.h"
     13 #include "ash/accelerators/nested_accelerator_delegate.h"
     14 #include "ash/accelerometer/accelerometer_controller.h"
     15 #include "ash/ash_switches.h"
     16 #include "ash/autoclick/autoclick_controller.h"
     17 #include "ash/desktop_background/desktop_background_controller.h"
     18 #include "ash/desktop_background/desktop_background_view.h"
     19 #include "ash/desktop_background/user_wallpaper_delegate.h"
     20 #include "ash/display/cursor_window_controller.h"
     21 #include "ash/display/display_controller.h"
     22 #include "ash/display/display_manager.h"
     23 #include "ash/display/event_transformation_handler.h"
     24 #include "ash/display/mouse_cursor_event_filter.h"
     25 #include "ash/display/screen_position_controller.h"
     26 #include "ash/drag_drop/drag_drop_controller.h"
     27 #include "ash/first_run/first_run_helper_impl.h"
     28 #include "ash/focus_cycler.h"
     29 #include "ash/frame/custom_frame_view_ash.h"
     30 #include "ash/gpu_support.h"
     31 #include "ash/high_contrast/high_contrast_controller.h"
     32 #include "ash/host/ash_window_tree_host_init_params.h"
     33 #include "ash/keyboard_uma_event_filter.h"
     34 #include "ash/magnifier/magnification_controller.h"
     35 #include "ash/magnifier/partial_magnification_controller.h"
     36 #include "ash/media_delegate.h"
     37 #include "ash/new_window_delegate.h"
     38 #include "ash/root_window_controller.h"
     39 #include "ash/session/session_state_delegate.h"
     40 #include "ash/shelf/app_list_shelf_item_delegate.h"
     41 #include "ash/shelf/shelf_delegate.h"
     42 #include "ash/shelf/shelf_item_delegate.h"
     43 #include "ash/shelf/shelf_item_delegate_manager.h"
     44 #include "ash/shelf/shelf_layout_manager.h"
     45 #include "ash/shelf/shelf_model.h"
     46 #include "ash/shelf/shelf_widget.h"
     47 #include "ash/shelf/shelf_window_watcher.h"
     48 #include "ash/shell_delegate.h"
     49 #include "ash/shell_factory.h"
     50 #include "ash/shell_init_params.h"
     51 #include "ash/shell_window_ids.h"
     52 #include "ash/system/locale/locale_notification_controller.h"
     53 #include "ash/system/status_area_widget.h"
     54 #include "ash/system/tray/system_tray_delegate.h"
     55 #include "ash/system/tray/system_tray_notifier.h"
     56 #include "ash/virtual_keyboard_controller.h"
     57 #include "ash/wm/app_list_controller.h"
     58 #include "ash/wm/ash_focus_rules.h"
     59 #include "ash/wm/ash_native_cursor_manager.h"
     60 #include "ash/wm/coordinate_conversion.h"
     61 #include "ash/wm/event_client_impl.h"
     62 #include "ash/wm/lock_state_controller.h"
     63 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
     64 #include "ash/wm/maximize_mode/maximize_mode_window_manager.h"
     65 #include "ash/wm/mru_window_tracker.h"
     66 #include "ash/wm/overlay_event_filter.h"
     67 #include "ash/wm/overview/window_selector_controller.h"
     68 #include "ash/wm/power_button_controller.h"
     69 #include "ash/wm/resize_shadow_controller.h"
     70 #include "ash/wm/root_window_layout_manager.h"
     71 #include "ash/wm/screen_dimmer.h"
     72 #include "ash/wm/system_gesture_event_filter.h"
     73 #include "ash/wm/system_modal_container_event_filter.h"
     74 #include "ash/wm/system_modal_container_layout_manager.h"
     75 #include "ash/wm/toplevel_window_event_handler.h"
     76 #include "ash/wm/video_detector.h"
     77 #include "ash/wm/window_animations.h"
     78 #include "ash/wm/window_cycle_controller.h"
     79 #include "ash/wm/window_positioner.h"
     80 #include "ash/wm/window_properties.h"
     81 #include "ash/wm/window_util.h"
     82 #include "ash/wm/workspace_controller.h"
     83 #include "base/bind.h"
     84 #include "base/debug/trace_event.h"
     85 #include "ui/aura/client/aura_constants.h"
     86 #include "ui/aura/env.h"
     87 #include "ui/aura/layout_manager.h"
     88 #include "ui/aura/window.h"
     89 #include "ui/aura/window_event_dispatcher.h"
     90 #include "ui/base/ui_base_switches.h"
     91 #include "ui/compositor/layer.h"
     92 #include "ui/compositor/layer_animator.h"
     93 #include "ui/events/event_target_iterator.h"
     94 #include "ui/gfx/display.h"
     95 #include "ui/gfx/image/image_skia.h"
     96 #include "ui/gfx/screen.h"
     97 #include "ui/gfx/size.h"
     98 #include "ui/keyboard/keyboard.h"
     99 #include "ui/keyboard/keyboard_controller.h"
    100 #include "ui/keyboard/keyboard_switches.h"
    101 #include "ui/keyboard/keyboard_util.h"
    102 #include "ui/message_center/message_center.h"
    103 #include "ui/views/corewm/tooltip_aura.h"
    104 #include "ui/views/corewm/tooltip_controller.h"
    105 #include "ui/views/focus/focus_manager_factory.h"
    106 #include "ui/views/widget/native_widget_aura.h"
    107 #include "ui/views/widget/widget.h"
    108 #include "ui/wm/core/accelerator_filter.h"
    109 #include "ui/wm/core/compound_event_filter.h"
    110 #include "ui/wm/core/focus_controller.h"
    111 #include "ui/wm/core/input_method_event_filter.h"
    112 #include "ui/wm/core/nested_accelerator_controller.h"
    113 #include "ui/wm/core/shadow_controller.h"
    114 #include "ui/wm/core/user_activity_detector.h"
    115 #include "ui/wm/core/visibility_controller.h"
    116 #include "ui/wm/core/window_modality_controller.h"
    117 
    118 #if defined(OS_CHROMEOS)
    119 #if defined(USE_X11)
    120 #include "ash/accelerators/magnifier_key_scroller.h"
    121 #include "ash/accelerators/spoken_feedback_toggler.h"
    122 #include "ash/touch/touch_transformer_controller.h"
    123 #include "ui/gfx/x/x11_types.h"
    124 #endif  // defined(USE_X11)
    125 #include "ash/ash_constants.h"
    126 #include "ash/display/display_change_observer_chromeos.h"
    127 #include "ash/display/display_configurator_animation.h"
    128 #include "ash/display/display_error_observer_chromeos.h"
    129 #include "ash/display/projecting_observer_chromeos.h"
    130 #include "ash/display/resolution_notification_controller.h"
    131 #include "ash/sticky_keys/sticky_keys_controller.h"
    132 #include "ash/system/chromeos/bluetooth/bluetooth_notification_controller.h"
    133 #include "ash/system/chromeos/brightness/brightness_controller_chromeos.h"
    134 #include "ash/system/chromeos/power/power_event_observer.h"
    135 #include "ash/system/chromeos/power/power_status.h"
    136 #include "ash/system/chromeos/power/video_activity_notifier.h"
    137 #include "ash/system/chromeos/session/last_window_closed_logout_reminder.h"
    138 #include "ash/system/chromeos/session/logout_confirmation_controller.h"
    139 #include "base/bind_helpers.h"
    140 #include "base/sys_info.h"
    141 #include "ui/chromeos/user_activity_power_manager_notifier.h"
    142 #include "ui/display/chromeos/display_configurator.h"
    143 #endif  // defined(OS_CHROMEOS)
    144 
    145 namespace ash {
    146 
    147 namespace {
    148 
    149 using aura::Window;
    150 using views::Widget;
    151 
    152 // A Corewm VisibilityController subclass that calls the Ash animation routine
    153 // so we can pick up our extended animations. See ash/wm/window_animations.h.
    154 class AshVisibilityController : public ::wm::VisibilityController {
    155  public:
    156   AshVisibilityController() {}
    157   virtual ~AshVisibilityController() {}
    158 
    159  private:
    160   // Overridden from ::wm::VisibilityController:
    161   virtual bool CallAnimateOnChildWindowVisibilityChanged(
    162       aura::Window* window,
    163       bool visible) OVERRIDE {
    164     return AnimateOnChildWindowVisibilityChanged(window, visible);
    165   }
    166 
    167   DISALLOW_COPY_AND_ASSIGN(AshVisibilityController);
    168 };
    169 
    170 AshWindowTreeHostInitParams ShellInitParamsToAshWindowTreeHostInitParams(
    171     const ShellInitParams& shell_init_params) {
    172   AshWindowTreeHostInitParams ash_init_params;
    173 #if defined(OS_WIN)
    174   ash_init_params.remote_hwnd = shell_init_params.remote_hwnd;
    175 #endif
    176   return ash_init_params;
    177 }
    178 
    179 }  // namespace
    180 
    181 // static
    182 Shell* Shell::instance_ = NULL;
    183 // static
    184 bool Shell::initially_hide_cursor_ = false;
    185 
    186 ////////////////////////////////////////////////////////////////////////////////
    187 // Shell, public:
    188 
    189 // static
    190 Shell* Shell::CreateInstance(const ShellInitParams& init_params) {
    191   CHECK(!instance_);
    192   instance_ = new Shell(init_params.delegate);
    193   instance_->Init(init_params);
    194   return instance_;
    195 }
    196 
    197 // static
    198 Shell* Shell::GetInstance() {
    199   CHECK(instance_);
    200   return instance_;
    201 }
    202 
    203 // static
    204 bool Shell::HasInstance() {
    205   return !!instance_;
    206 }
    207 
    208 // static
    209 void Shell::DeleteInstance() {
    210   delete instance_;
    211   instance_ = NULL;
    212 }
    213 
    214 // static
    215 RootWindowController* Shell::GetPrimaryRootWindowController() {
    216   CHECK(HasInstance());
    217   return GetRootWindowController(GetPrimaryRootWindow());
    218 }
    219 
    220 // static
    221 Shell::RootWindowControllerList Shell::GetAllRootWindowControllers() {
    222   CHECK(HasInstance());
    223   return Shell::GetInstance()->display_controller()->
    224       GetAllRootWindowControllers();
    225 }
    226 
    227 // static
    228 aura::Window* Shell::GetPrimaryRootWindow() {
    229   CHECK(HasInstance());
    230   return GetInstance()->display_controller()->GetPrimaryRootWindow();
    231 }
    232 
    233 // static
    234 aura::Window* Shell::GetTargetRootWindow() {
    235   CHECK(HasInstance());
    236   Shell* shell = GetInstance();
    237   if (shell->scoped_target_root_window_)
    238     return shell->scoped_target_root_window_;
    239   return shell->target_root_window_;
    240 }
    241 
    242 // static
    243 gfx::Screen* Shell::GetScreen() {
    244   return gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
    245 }
    246 
    247 // static
    248 aura::Window::Windows Shell::GetAllRootWindows() {
    249   CHECK(HasInstance());
    250   return Shell::GetInstance()->display_controller()->
    251       GetAllRootWindows();
    252 }
    253 
    254 // static
    255 aura::Window* Shell::GetContainer(aura::Window* root_window,
    256                                   int container_id) {
    257   return root_window->GetChildById(container_id);
    258 }
    259 
    260 // static
    261 const aura::Window* Shell::GetContainer(const aura::Window* root_window,
    262                                         int container_id) {
    263   return root_window->GetChildById(container_id);
    264 }
    265 
    266 // static
    267 std::vector<aura::Window*> Shell::GetContainersFromAllRootWindows(
    268     int container_id,
    269     aura::Window* priority_root) {
    270   std::vector<aura::Window*> containers;
    271   aura::Window::Windows root_windows = GetAllRootWindows();
    272   for (aura::Window::Windows::const_iterator it = root_windows.begin();
    273        it != root_windows.end(); ++it) {
    274     aura::Window* container = (*it)->GetChildById(container_id);
    275     if (container) {
    276       if (priority_root && priority_root->Contains(container))
    277         containers.insert(containers.begin(), container);
    278       else
    279         containers.push_back(container);
    280     }
    281   }
    282   return containers;
    283 }
    284 
    285 void Shell::ShowContextMenu(const gfx::Point& location_in_screen,
    286                             ui::MenuSourceType source_type) {
    287   // No context menus if there is no session with an active user.
    288   if (!session_state_delegate_->NumberOfLoggedInUsers())
    289     return;
    290   // No context menus when screen is locked.
    291   if (session_state_delegate_->IsScreenLocked())
    292     return;
    293 
    294   aura::Window* root =
    295       wm::GetRootWindowMatching(gfx::Rect(location_in_screen, gfx::Size()));
    296   GetRootWindowController(root)
    297       ->ShowContextMenu(location_in_screen, source_type);
    298 }
    299 
    300 void Shell::ShowAppList(aura::Window* window) {
    301   // If the context window is not given, show it on the target root window.
    302   if (!window)
    303     window = GetTargetRootWindow();
    304   if (!app_list_controller_)
    305     app_list_controller_.reset(new AppListController);
    306   app_list_controller_->Show(window);
    307 }
    308 
    309 void Shell::DismissAppList() {
    310   if (!app_list_controller_)
    311     return;
    312   app_list_controller_->Dismiss();
    313 }
    314 
    315 void Shell::ToggleAppList(aura::Window* window) {
    316   if (app_list_controller_ && app_list_controller_->IsVisible()) {
    317     DismissAppList();
    318     return;
    319   }
    320 
    321   ShowAppList(window);
    322 }
    323 
    324 bool Shell::GetAppListTargetVisibility() const {
    325   return app_list_controller_.get() &&
    326       app_list_controller_->GetTargetVisibility();
    327 }
    328 
    329 aura::Window* Shell::GetAppListWindow() {
    330   return app_list_controller_.get() ? app_list_controller_->GetWindow() : NULL;
    331 }
    332 
    333 app_list::AppListView* Shell::GetAppListView() {
    334   return app_list_controller_.get() ? app_list_controller_->GetView() : NULL;
    335 }
    336 
    337 bool Shell::IsSystemModalWindowOpen() const {
    338   if (simulate_modal_window_open_for_testing_)
    339     return true;
    340   const std::vector<aura::Window*> containers = GetContainersFromAllRootWindows(
    341       kShellWindowId_SystemModalContainer, NULL);
    342   for (std::vector<aura::Window*>::const_iterator cit = containers.begin();
    343        cit != containers.end(); ++cit) {
    344     for (aura::Window::Windows::const_iterator wit = (*cit)->children().begin();
    345          wit != (*cit)->children().end(); ++wit) {
    346       if ((*wit)->GetProperty(aura::client::kModalKey) ==
    347           ui::MODAL_TYPE_SYSTEM && (*wit)->TargetVisibility()) {
    348         return true;
    349       }
    350     }
    351   }
    352   return false;
    353 }
    354 
    355 views::NonClientFrameView* Shell::CreateDefaultNonClientFrameView(
    356     views::Widget* widget) {
    357   // Use translucent-style window frames for dialogs.
    358   return new CustomFrameViewAsh(widget);
    359 }
    360 
    361 void Shell::RotateFocus(Direction direction) {
    362   focus_cycler_->RotateFocus(direction == FORWARD ? FocusCycler::FORWARD
    363                                                   : FocusCycler::BACKWARD);
    364 }
    365 
    366 void Shell::SetDisplayWorkAreaInsets(Window* contains,
    367                                      const gfx::Insets& insets) {
    368   if (!display_controller_->UpdateWorkAreaOfDisplayNearestWindow(
    369           contains, insets)) {
    370     return;
    371   }
    372   FOR_EACH_OBSERVER(ShellObserver, observers_,
    373                     OnDisplayWorkAreaInsetsChanged());
    374 }
    375 
    376 void Shell::OnLoginStateChanged(user::LoginStatus status) {
    377   FOR_EACH_OBSERVER(ShellObserver, observers_, OnLoginStateChanged(status));
    378 }
    379 
    380 void Shell::OnLoginUserProfilePrepared() {
    381   CreateShelf();
    382   CreateKeyboard();
    383 }
    384 
    385 void Shell::UpdateAfterLoginStatusChange(user::LoginStatus status) {
    386   RootWindowControllerList controllers = GetAllRootWindowControllers();
    387   for (RootWindowControllerList::iterator iter = controllers.begin();
    388        iter != controllers.end(); ++iter)
    389     (*iter)->UpdateAfterLoginStatusChange(status);
    390 }
    391 
    392 void Shell::OnAppTerminating() {
    393   FOR_EACH_OBSERVER(ShellObserver, observers_, OnAppTerminating());
    394 }
    395 
    396 void Shell::OnLockStateChanged(bool locked) {
    397   FOR_EACH_OBSERVER(ShellObserver, observers_, OnLockStateChanged(locked));
    398 #ifndef NDEBUG
    399   // Make sure that there is no system modal in Lock layer when unlocked.
    400   if (!locked) {
    401     std::vector<aura::Window*> containers = GetContainersFromAllRootWindows(
    402         kShellWindowId_LockSystemModalContainer, GetPrimaryRootWindow());
    403     for (std::vector<aura::Window*>::const_iterator iter = containers.begin();
    404          iter != containers.end(); ++iter) {
    405       DCHECK_EQ(0u, (*iter)->children().size());
    406     }
    407   }
    408 #endif
    409 }
    410 
    411 void Shell::OnCastingSessionStartedOrStopped(bool started) {
    412 #if defined(OS_CHROMEOS) && defined(USE_X11)
    413   if (projecting_observer_)
    414     projecting_observer_->OnCastingSessionStartedOrStopped(started);
    415 #endif
    416 }
    417 
    418 void Shell::OnOverviewModeStarting() {
    419   FOR_EACH_OBSERVER(ShellObserver, observers_, OnOverviewModeStarting());
    420 }
    421 
    422 void Shell::OnOverviewModeEnding() {
    423   FOR_EACH_OBSERVER(ShellObserver, observers_, OnOverviewModeEnding());
    424 }
    425 
    426 void Shell::OnMaximizeModeStarted() {
    427   FOR_EACH_OBSERVER(ShellObserver, observers_, OnMaximizeModeStarted());
    428 }
    429 
    430 void Shell::OnMaximizeModeEnded() {
    431   FOR_EACH_OBSERVER(ShellObserver, observers_, OnMaximizeModeEnded());
    432 }
    433 
    434 void Shell::OnRootWindowAdded(aura::Window* root_window) {
    435   FOR_EACH_OBSERVER(ShellObserver, observers_, OnRootWindowAdded(root_window));
    436 }
    437 
    438 void Shell::CreateShelf() {
    439   RootWindowControllerList controllers = GetAllRootWindowControllers();
    440   for (RootWindowControllerList::iterator iter = controllers.begin();
    441        iter != controllers.end(); ++iter)
    442     (*iter)->shelf()->CreateShelf();
    443 }
    444 
    445 void Shell::OnShelfCreatedForRootWindow(aura::Window* root_window) {
    446   FOR_EACH_OBSERVER(ShellObserver,
    447                     observers_,
    448                     OnShelfCreatedForRootWindow(root_window));
    449 }
    450 
    451 void Shell::CreateKeyboard() {
    452   // TODO(bshe): Primary root window controller may not be the controller to
    453   // attach virtual keyboard. See http://crbug.com/303429
    454   InitKeyboard();
    455   GetPrimaryRootWindowController()->
    456       ActivateKeyboard(keyboard::KeyboardController::GetInstance());
    457 }
    458 
    459 void Shell::DeactivateKeyboard() {
    460   if (keyboard::KeyboardController::GetInstance()) {
    461     RootWindowControllerList controllers = GetAllRootWindowControllers();
    462     for (RootWindowControllerList::iterator iter = controllers.begin();
    463         iter != controllers.end(); ++iter) {
    464       (*iter)->DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
    465     }
    466   }
    467   keyboard::KeyboardController::ResetInstance(NULL);
    468 }
    469 
    470 void Shell::ShowShelf() {
    471   RootWindowControllerList controllers = GetAllRootWindowControllers();
    472   for (RootWindowControllerList::iterator iter = controllers.begin();
    473        iter != controllers.end(); ++iter)
    474     (*iter)->ShowShelf();
    475 }
    476 
    477 void Shell::AddShellObserver(ShellObserver* observer) {
    478   observers_.AddObserver(observer);
    479 }
    480 
    481 void Shell::RemoveShellObserver(ShellObserver* observer) {
    482   observers_.RemoveObserver(observer);
    483 }
    484 
    485 #if defined(OS_CHROMEOS)
    486 bool Shell::ShouldSaveDisplaySettings() {
    487   return !((maximize_mode_controller_->IsMaximizeModeWindowManagerEnabled() &&
    488             maximize_mode_controller_->
    489                 ignore_display_configuration_updates()) ||
    490            resolution_notification_controller_->DoesNotificationTimeout());
    491 }
    492 #endif
    493 
    494 void Shell::UpdateShelfVisibility() {
    495   RootWindowControllerList controllers = GetAllRootWindowControllers();
    496   for (RootWindowControllerList::iterator iter = controllers.begin();
    497        iter != controllers.end(); ++iter)
    498     if ((*iter)->shelf())
    499       (*iter)->UpdateShelfVisibility();
    500 }
    501 
    502 void Shell::SetShelfAutoHideBehavior(ShelfAutoHideBehavior behavior,
    503                                      aura::Window* root_window) {
    504   ash::ShelfLayoutManager::ForShelf(root_window)->SetAutoHideBehavior(behavior);
    505 }
    506 
    507 ShelfAutoHideBehavior Shell::GetShelfAutoHideBehavior(
    508     aura::Window* root_window) const {
    509   return ash::ShelfLayoutManager::ForShelf(root_window)->auto_hide_behavior();
    510 }
    511 
    512 void Shell::SetShelfAlignment(ShelfAlignment alignment,
    513                               aura::Window* root_window) {
    514   if (ash::ShelfLayoutManager::ForShelf(root_window)->SetAlignment(alignment)) {
    515     FOR_EACH_OBSERVER(
    516         ShellObserver, observers_, OnShelfAlignmentChanged(root_window));
    517   }
    518 }
    519 
    520 ShelfAlignment Shell::GetShelfAlignment(const aura::Window* root_window) {
    521   return GetRootWindowController(root_window)
    522       ->GetShelfLayoutManager()
    523       ->GetAlignment();
    524 }
    525 
    526 void Shell::SetDimming(bool should_dim) {
    527   RootWindowControllerList controllers = GetAllRootWindowControllers();
    528   for (RootWindowControllerList::iterator iter = controllers.begin();
    529        iter != controllers.end(); ++iter)
    530     (*iter)->screen_dimmer()->SetDimming(should_dim);
    531 }
    532 
    533 void Shell::NotifyFullscreenStateChange(bool is_fullscreen,
    534                                         aura::Window* root_window) {
    535   FOR_EACH_OBSERVER(ShellObserver, observers_, OnFullscreenStateChanged(
    536       is_fullscreen, root_window));
    537 }
    538 
    539 void Shell::CreateModalBackground(aura::Window* window) {
    540   if (!modality_filter_) {
    541     modality_filter_.reset(new SystemModalContainerEventFilter(this));
    542     AddPreTargetHandler(modality_filter_.get());
    543   }
    544   RootWindowControllerList controllers = GetAllRootWindowControllers();
    545   for (RootWindowControllerList::iterator iter = controllers.begin();
    546        iter != controllers.end(); ++iter)
    547     (*iter)->GetSystemModalLayoutManager(window)->CreateModalBackground();
    548 }
    549 
    550 void Shell::OnModalWindowRemoved(aura::Window* removed) {
    551   RootWindowControllerList controllers = GetAllRootWindowControllers();
    552   bool activated = false;
    553   for (RootWindowControllerList::iterator iter = controllers.begin();
    554        iter != controllers.end() && !activated; ++iter) {
    555     activated = (*iter)->GetSystemModalLayoutManager(removed)->
    556         ActivateNextModalWindow();
    557   }
    558   if (!activated) {
    559     RemovePreTargetHandler(modality_filter_.get());
    560     modality_filter_.reset();
    561     for (RootWindowControllerList::iterator iter = controllers.begin();
    562          iter != controllers.end(); ++iter)
    563       (*iter)->GetSystemModalLayoutManager(removed)->DestroyModalBackground();
    564   }
    565 }
    566 
    567 WebNotificationTray* Shell::GetWebNotificationTray() {
    568   return GetPrimaryRootWindowController()->shelf()->
    569       status_area_widget()->web_notification_tray();
    570 }
    571 
    572 bool Shell::HasPrimaryStatusArea() {
    573   ShelfWidget* shelf = GetPrimaryRootWindowController()->shelf();
    574   return shelf && shelf->status_area_widget();
    575 }
    576 
    577 SystemTray* Shell::GetPrimarySystemTray() {
    578   return GetPrimaryRootWindowController()->GetSystemTray();
    579 }
    580 
    581 ShelfDelegate* Shell::GetShelfDelegate() {
    582   if (!shelf_delegate_) {
    583     shelf_model_.reset(new ShelfModel);
    584     // Creates ShelfItemDelegateManager before ShelfDelegate.
    585     shelf_item_delegate_manager_.reset(
    586         new ShelfItemDelegateManager(shelf_model_.get()));
    587 
    588     shelf_delegate_.reset(delegate_->CreateShelfDelegate(shelf_model_.get()));
    589     scoped_ptr<ShelfItemDelegate> controller(new AppListShelfItemDelegate);
    590 
    591     // Finding the shelf model's location of the app list and setting its
    592     // ShelfItemDelegate.
    593     int app_list_index = shelf_model_->GetItemIndexForType(TYPE_APP_LIST);
    594     DCHECK_GE(app_list_index, 0);
    595     ShelfID app_list_id = shelf_model_->items()[app_list_index].id;
    596     DCHECK(app_list_id);
    597     shelf_item_delegate_manager_->SetShelfItemDelegate(app_list_id,
    598                                                        controller.Pass());
    599     shelf_window_watcher_.reset(new ShelfWindowWatcher(
    600         shelf_model_.get(), shelf_item_delegate_manager_.get()));
    601   }
    602   return shelf_delegate_.get();
    603 }
    604 
    605 void Shell::SetTouchHudProjectionEnabled(bool enabled) {
    606   if (is_touch_hud_projection_enabled_ == enabled)
    607     return;
    608 
    609   is_touch_hud_projection_enabled_ = enabled;
    610   FOR_EACH_OBSERVER(ShellObserver, observers_,
    611                     OnTouchHudProjectionToggled(enabled));
    612 }
    613 
    614 #if defined(OS_CHROMEOS)
    615 ash::FirstRunHelper* Shell::CreateFirstRunHelper() {
    616   return new ash::FirstRunHelperImpl;
    617 }
    618 
    619 void Shell::SetCursorCompositingEnabled(bool enabled) {
    620   display_controller_->cursor_window_controller()->SetCursorCompositingEnabled(
    621       enabled);
    622   native_cursor_manager_->SetNativeCursorEnabled(!enabled);
    623 }
    624 #endif  // defined(OS_CHROMEOS)
    625 
    626 void Shell::DoInitialWorkspaceAnimation() {
    627   return GetPrimaryRootWindowController()->workspace_controller()->
    628       DoInitialAnimation();
    629 }
    630 
    631 ////////////////////////////////////////////////////////////////////////////////
    632 // Shell, private:
    633 
    634 Shell::Shell(ShellDelegate* delegate)
    635     : target_root_window_(NULL),
    636       scoped_target_root_window_(NULL),
    637       delegate_(delegate),
    638       window_positioner_(new WindowPositioner),
    639       activation_client_(NULL),
    640       accelerometer_controller_(new AccelerometerController()),
    641 #if defined(OS_CHROMEOS)
    642       display_configurator_(new ui::DisplayConfigurator()),
    643 #endif  // defined(OS_CHROMEOS)
    644       native_cursor_manager_(new AshNativeCursorManager),
    645       cursor_manager_(
    646           scoped_ptr< ::wm::NativeCursorManager>(native_cursor_manager_)),
    647       simulate_modal_window_open_for_testing_(false),
    648       is_touch_hud_projection_enabled_(false) {
    649   DCHECK(delegate_.get());
    650   gpu_support_.reset(delegate_->CreateGPUSupport());
    651   display_manager_.reset(new DisplayManager);
    652   display_controller_.reset(new DisplayController);
    653 #if defined(OS_CHROMEOS) && defined(USE_X11)
    654   user_metrics_recorder_.reset(new UserMetricsRecorder);
    655 #endif  // defined(OS_CHROMEOS)
    656 
    657 #if defined(OS_CHROMEOS)
    658   PowerStatus::Initialize();
    659 #endif
    660 }
    661 
    662 Shell::~Shell() {
    663   TRACE_EVENT0("shutdown", "ash::Shell::Destructor");
    664 
    665   delegate_->PreShutdown();
    666 
    667   views::FocusManagerFactory::Install(NULL);
    668 
    669   // Remove the focus from any window. This will prevent overhead and side
    670   // effects (e.g. crashes) from changing focus during shutdown.
    671   // See bug crbug.com/134502.
    672   aura::client::GetFocusClient(GetPrimaryRootWindow())->FocusWindow(NULL);
    673 
    674   // Please keep in same order as in Init() because it's easy to miss one.
    675   if (window_modality_controller_)
    676     window_modality_controller_.reset();
    677 #if defined(OS_CHROMEOS) && defined(USE_X11)
    678   RemovePreTargetHandler(magnifier_key_scroll_handler_.get());
    679   magnifier_key_scroll_handler_.reset();
    680 
    681   RemovePreTargetHandler(speech_feedback_handler_.get());
    682   speech_feedback_handler_.reset();
    683 #endif
    684   RemovePreTargetHandler(user_activity_detector_.get());
    685   RemovePreTargetHandler(overlay_filter_.get());
    686   RemovePreTargetHandler(input_method_filter_.get());
    687   RemovePreTargetHandler(accelerator_filter_.get());
    688   RemovePreTargetHandler(event_transformation_handler_.get());
    689   RemovePreTargetHandler(toplevel_window_event_handler_.get());
    690   RemovePostTargetHandler(toplevel_window_event_handler_.get());
    691   RemovePreTargetHandler(system_gesture_filter_.get());
    692   RemovePreTargetHandler(keyboard_metrics_filter_.get());
    693   RemovePreTargetHandler(mouse_cursor_filter_.get());
    694 
    695   // TooltipController is deleted with the Shell so removing its references.
    696   RemovePreTargetHandler(tooltip_controller_.get());
    697 
    698   // Destroy maximize mode controller early on since it has some observers which
    699   // need to be removed.
    700   maximize_mode_controller_->Shutdown();
    701   maximize_mode_controller_.reset();
    702 
    703   // AppList needs to be released before shelf layout manager, which is
    704   // destroyed with shelf container in the loop below. However, app list
    705   // container is now on top of shelf container and released after it.
    706   // TODO(xiyuan): Move it back when app list container is no longer needed.
    707   app_list_controller_.reset();
    708 
    709 #if defined(OS_CHROMEOS)
    710   // Destroy the LastWindowClosedLogoutReminder before the
    711   // LogoutConfirmationController.
    712   last_window_closed_logout_reminder_.reset();
    713 
    714   // Destroy the LogoutConfirmationController before the SystemTrayDelegate.
    715   logout_confirmation_controller_.reset();
    716 #endif
    717 
    718   // Destroy SystemTrayDelegate before destroying the status area(s).
    719   system_tray_delegate_->Shutdown();
    720   system_tray_delegate_.reset();
    721 
    722   locale_notification_controller_.reset();
    723 
    724   // Drag-and-drop must be canceled prior to close all windows.
    725   drag_drop_controller_.reset();
    726 
    727   // Controllers who have WindowObserver added must be deleted
    728   // before |display_controller_| is deleted.
    729 
    730 #if defined(OS_CHROMEOS)
    731   // VideoActivityNotifier must be deleted before |video_detector_| is
    732   // deleted because it's observing video activity through
    733   // VideoDetectorObserver interface.
    734   video_activity_notifier_.reset();
    735 #endif  // defined(OS_CHROMEOS)
    736   video_detector_.reset();
    737   high_contrast_controller_.reset();
    738 
    739   shadow_controller_.reset();
    740   resize_shadow_controller_.reset();
    741 
    742   window_cycle_controller_.reset();
    743   window_selector_controller_.reset();
    744   mru_window_tracker_.reset();
    745 
    746   // |shelf_window_watcher_| has a weak pointer to |shelf_Model_|
    747   // and has window observers.
    748   shelf_window_watcher_.reset();
    749 
    750   // Destroy all child windows including widgets.
    751   display_controller_->CloseChildWindows();
    752   display_controller_->CloseNonDesktopDisplay();
    753 
    754   // Chrome implementation of shelf delegate depends on FocusClient,
    755   // so must be deleted before |focus_client_|.
    756   shelf_delegate_.reset();
    757   focus_client_.reset();
    758 
    759   // Destroy SystemTrayNotifier after destroying SystemTray as TrayItems
    760   // needs to remove observers from it.
    761   system_tray_notifier_.reset();
    762 
    763   // These need a valid Shell instance to clean up properly, so explicitly
    764   // delete them before invalidating the instance.
    765   // Alphabetical. TODO(oshima): sort.
    766   magnification_controller_.reset();
    767   partial_magnification_controller_.reset();
    768   tooltip_controller_.reset();
    769   event_client_.reset();
    770   nested_accelerator_controller_.reset();
    771   toplevel_window_event_handler_.reset();
    772   visibility_controller_.reset();
    773   // |shelf_item_delegate_manager_| observes |shelf_model_|. It must be
    774   // destroyed before |shelf_model_| is destroyed.
    775   shelf_item_delegate_manager_.reset();
    776   shelf_model_.reset();
    777 
    778   power_button_controller_.reset();
    779   lock_state_controller_.reset();
    780 
    781 #if defined(OS_CHROMEOS)
    782   resolution_notification_controller_.reset();
    783 #endif
    784   desktop_background_controller_.reset();
    785   mouse_cursor_filter_.reset();
    786 
    787 #if defined(OS_CHROMEOS) && defined(USE_X11)
    788   touch_transformer_controller_.reset();
    789 #endif  // defined(OS_CHROMEOS) && defined(USE_X11)
    790 
    791   // This also deletes all RootWindows. Note that we invoke Shutdown() on
    792   // DisplayController before resetting |display_controller_|, since destruction
    793   // of its owned RootWindowControllers relies on the value.
    794   display_manager_->CreateScreenForShutdown();
    795   display_controller_->Shutdown();
    796   display_controller_.reset();
    797   virtual_keyboard_controller_.reset();
    798   screen_position_controller_.reset();
    799   accessibility_delegate_.reset();
    800   new_window_delegate_.reset();
    801   media_delegate_.reset();
    802 
    803   keyboard::KeyboardController::ResetInstance(NULL);
    804 
    805 #if defined(OS_CHROMEOS)
    806   if (display_change_observer_)
    807     display_configurator_->RemoveObserver(display_change_observer_.get());
    808   if (display_configurator_animation_)
    809     display_configurator_->RemoveObserver(
    810         display_configurator_animation_.get());
    811   if (display_error_observer_)
    812     display_configurator_->RemoveObserver(display_error_observer_.get());
    813   if (projecting_observer_)
    814     display_configurator_->RemoveObserver(projecting_observer_.get());
    815   display_change_observer_.reset();
    816 #endif  // defined(OS_CHROMEOS)
    817 
    818 #if defined(OS_CHROMEOS)
    819   PowerStatus::Shutdown();
    820 #endif
    821 
    822   DCHECK(instance_ == this);
    823   instance_ = NULL;
    824 }
    825 
    826 void Shell::Init(const ShellInitParams& init_params) {
    827   delegate_->PreInit();
    828   bool display_initialized = display_manager_->InitFromCommandLine();
    829 #if defined(OS_CHROMEOS)
    830   display_configurator_->Init(!gpu_support_->IsPanelFittingDisabled());
    831   display_configurator_animation_.reset(new DisplayConfiguratorAnimation());
    832   display_configurator_->AddObserver(display_configurator_animation_.get());
    833 
    834   projecting_observer_.reset(new ProjectingObserver());
    835   display_configurator_->AddObserver(projecting_observer_.get());
    836 
    837   if (!display_initialized && base::SysInfo::IsRunningOnChromeOS()) {
    838     display_change_observer_.reset(new DisplayChangeObserver);
    839     // Register |display_change_observer_| first so that the rest of
    840     // observer gets invoked after the root windows are configured.
    841     display_configurator_->AddObserver(display_change_observer_.get());
    842     display_error_observer_.reset(new DisplayErrorObserver());
    843     display_configurator_->AddObserver(display_error_observer_.get());
    844     display_configurator_->set_state_controller(display_change_observer_.get());
    845     display_configurator_->set_mirroring_controller(display_manager_.get());
    846     display_configurator_->ForceInitialConfigure(
    847         delegate_->IsFirstRunAfterBoot() ? kChromeOsBootColor : 0);
    848     display_initialized = true;
    849   }
    850 #endif  // defined(OS_CHROMEOS)
    851   if (!display_initialized)
    852     display_manager_->InitDefaultDisplay();
    853 
    854   display_manager_->InitFontParams();
    855 
    856   // Install the custom factory first so that views::FocusManagers for Tray,
    857   // Shelf, and WallPaper could be created by the factory.
    858   views::FocusManagerFactory::Install(new AshFocusManagerFactory);
    859 
    860   aura::Env::CreateInstance(true);
    861   aura::Env::GetInstance()->set_context_factory(init_params.context_factory);
    862 
    863   // The WindowModalityController needs to be at the front of the input event
    864   // pretarget handler list to ensure that it processes input events when modal
    865   // windows are active.
    866   window_modality_controller_.reset(
    867       new ::wm::WindowModalityController(this));
    868 
    869   env_filter_.reset(new ::wm::CompoundEventFilter);
    870   AddPreTargetHandler(env_filter_.get());
    871 
    872   ::wm::FocusController* focus_controller =
    873       new ::wm::FocusController(new wm::AshFocusRules);
    874   focus_client_.reset(focus_controller);
    875   activation_client_ = focus_controller;
    876   activation_client_->AddObserver(this);
    877   focus_cycler_.reset(new FocusCycler());
    878 
    879   screen_position_controller_.reset(new ScreenPositionController);
    880 
    881   display_controller_->Start();
    882   display_controller_->CreatePrimaryHost(
    883       ShellInitParamsToAshWindowTreeHostInitParams(init_params));
    884   virtual_keyboard_controller_.reset(new VirtualKeyboardController);
    885   aura::Window* root_window = display_controller_->GetPrimaryRootWindow();
    886   target_root_window_ = root_window;
    887 
    888 #if defined(OS_CHROMEOS)
    889   resolution_notification_controller_.reset(
    890       new ResolutionNotificationController);
    891 #endif
    892 
    893   cursor_manager_.SetDisplay(GetScreen()->GetPrimaryDisplay());
    894 
    895   nested_accelerator_controller_.reset(
    896       new ::wm::NestedAcceleratorController(new NestedAcceleratorDelegate));
    897   accelerator_controller_.reset(new AcceleratorController);
    898   maximize_mode_controller_.reset(new MaximizeModeController());
    899 
    900 #if defined(OS_CHROMEOS) && defined(USE_X11)
    901   magnifier_key_scroll_handler_ = MagnifierKeyScroller::CreateHandler().Pass();
    902   AddPreTargetHandler(magnifier_key_scroll_handler_.get());
    903   speech_feedback_handler_ = SpokenFeedbackToggler::CreateHandler().Pass();
    904   AddPreTargetHandler(speech_feedback_handler_.get());
    905 #endif
    906 
    907   // The order in which event filters are added is significant.
    908 
    909   // wm::UserActivityDetector passes events to observers, so let them get
    910   // rewritten first.
    911   user_activity_detector_.reset(new ::wm::UserActivityDetector);
    912   AddPreTargetHandler(user_activity_detector_.get());
    913 
    914   overlay_filter_.reset(new OverlayEventFilter);
    915   AddPreTargetHandler(overlay_filter_.get());
    916   AddShellObserver(overlay_filter_.get());
    917 
    918   input_method_filter_.reset(new ::wm::InputMethodEventFilter(
    919       root_window->GetHost()->GetAcceleratedWidget()));
    920   AddPreTargetHandler(input_method_filter_.get());
    921 
    922   accelerator_filter_.reset(new ::wm::AcceleratorFilter(
    923       scoped_ptr< ::wm::AcceleratorDelegate>(new AcceleratorDelegate).Pass()));
    924   AddPreTargetHandler(accelerator_filter_.get());
    925 
    926   event_transformation_handler_.reset(new EventTransformationHandler);
    927   AddPreTargetHandler(event_transformation_handler_.get());
    928 
    929   toplevel_window_event_handler_.reset(new ToplevelWindowEventHandler);
    930 
    931   system_gesture_filter_.reset(new SystemGestureEventFilter);
    932   AddPreTargetHandler(system_gesture_filter_.get());
    933 
    934   keyboard_metrics_filter_.reset(new KeyboardUMAEventFilter);
    935   AddPreTargetHandler(keyboard_metrics_filter_.get());
    936 
    937   // The keyboard system must be initialized before the RootWindowController is
    938   // created.
    939 #if defined(OS_CHROMEOS)
    940     keyboard::InitializeKeyboard();
    941 #endif
    942 
    943 #if defined(OS_CHROMEOS)
    944   sticky_keys_controller_.reset(new StickyKeysController);
    945 #endif
    946 
    947   lock_state_controller_.reset(new LockStateController);
    948   power_button_controller_.reset(new PowerButtonController(
    949       lock_state_controller_.get()));
    950 #if defined(OS_CHROMEOS)
    951   // Pass the initial display state to PowerButtonController.
    952   power_button_controller_->OnDisplayModeChanged(
    953       display_configurator_->cached_displays());
    954 #endif
    955   AddShellObserver(lock_state_controller_.get());
    956 
    957   drag_drop_controller_.reset(new DragDropController);
    958   mouse_cursor_filter_.reset(new MouseCursorEventFilter());
    959   PrependPreTargetHandler(mouse_cursor_filter_.get());
    960 
    961   // Create Controllers that may need root window.
    962   // TODO(oshima): Move as many controllers before creating
    963   // RootWindowController as possible.
    964   visibility_controller_.reset(new AshVisibilityController);
    965 
    966   magnification_controller_.reset(
    967       MagnificationController::CreateInstance());
    968   mru_window_tracker_.reset(new MruWindowTracker(activation_client_));
    969 
    970   partial_magnification_controller_.reset(
    971       new PartialMagnificationController());
    972 
    973   autoclick_controller_.reset(AutoclickController::CreateInstance());
    974 
    975   high_contrast_controller_.reset(new HighContrastController);
    976   video_detector_.reset(new VideoDetector);
    977   window_selector_controller_.reset(new WindowSelectorController());
    978   window_cycle_controller_.reset(new WindowCycleController());
    979 
    980   tooltip_controller_.reset(
    981       new views::corewm::TooltipController(
    982           scoped_ptr<views::corewm::Tooltip>(
    983               new views::corewm::TooltipAura(gfx::SCREEN_TYPE_ALTERNATE))));
    984   AddPreTargetHandler(tooltip_controller_.get());
    985 
    986   event_client_.reset(new EventClientImpl);
    987 
    988   // This controller needs to be set before SetupManagedWindowMode.
    989   desktop_background_controller_.reset(new DesktopBackgroundController());
    990   user_wallpaper_delegate_.reset(delegate_->CreateUserWallpaperDelegate());
    991 
    992   session_state_delegate_.reset(delegate_->CreateSessionStateDelegate());
    993   accessibility_delegate_.reset(delegate_->CreateAccessibilityDelegate());
    994   new_window_delegate_.reset(delegate_->CreateNewWindowDelegate());
    995   media_delegate_.reset(delegate_->CreateMediaDelegate());
    996 
    997   resize_shadow_controller_.reset(new ResizeShadowController());
    998   shadow_controller_.reset(
    999       new ::wm::ShadowController(activation_client_));
   1000 
   1001   // Create system_tray_notifier_ before the delegate.
   1002   system_tray_notifier_.reset(new ash::SystemTrayNotifier());
   1003 
   1004   // Initialize system_tray_delegate_ before initializing StatusAreaWidget.
   1005   system_tray_delegate_.reset(delegate()->CreateSystemTrayDelegate());
   1006   DCHECK(system_tray_delegate_.get());
   1007 
   1008   locale_notification_controller_.reset(new LocaleNotificationController);
   1009 
   1010   // Initialize system_tray_delegate_ after StatusAreaWidget is created.
   1011   system_tray_delegate_->Initialize();
   1012 
   1013 #if defined(OS_CHROMEOS)
   1014   // Create the LogoutConfirmationController after the SystemTrayDelegate.
   1015   logout_confirmation_controller_.reset(new LogoutConfirmationController(
   1016       base::Bind(&SystemTrayDelegate::SignOut,
   1017                  base::Unretained(system_tray_delegate_.get()))));
   1018 #endif
   1019 
   1020 #if defined(OS_CHROMEOS) && defined(USE_X11)
   1021   // Create TouchTransformerController before DisplayController::InitDisplays()
   1022   // since TouchTransformerController listens on
   1023   // DisplayController::Observer::OnDisplaysInitialized().
   1024   touch_transformer_controller_.reset(new TouchTransformerController());
   1025 #endif  // defined(OS_CHROMEOS) && defined(USE_X11)
   1026 
   1027   display_controller_->InitDisplays();
   1028 
   1029   // It needs to be created after RootWindowController has been created
   1030   // (which calls OnWindowResized has been called, otherwise the
   1031   // widget will not paint when restoring after a browser crash.  Also it needs
   1032   // to be created after InitSecondaryDisplays() to initialize the wallpapers in
   1033   // the correct size.
   1034   user_wallpaper_delegate_->InitializeWallpaper();
   1035 
   1036   if (initially_hide_cursor_)
   1037     cursor_manager_.HideCursor();
   1038   cursor_manager_.SetCursor(ui::kCursorPointer);
   1039 
   1040 #if defined(OS_CHROMEOS)
   1041   // Set accelerator controller delegates.
   1042   accelerator_controller_->SetBrightnessControlDelegate(
   1043       scoped_ptr<ash::BrightnessControlDelegate>(
   1044           new ash::system::BrightnessControllerChromeos).Pass());
   1045 
   1046   power_event_observer_.reset(new PowerEventObserver());
   1047   user_activity_notifier_.reset(
   1048       new ui::UserActivityPowerManagerNotifier(user_activity_detector_.get()));
   1049   video_activity_notifier_.reset(
   1050       new VideoActivityNotifier(video_detector_.get()));
   1051   bluetooth_notification_controller_.reset(new BluetoothNotificationController);
   1052   last_window_closed_logout_reminder_.reset(new LastWindowClosedLogoutReminder);
   1053 #endif
   1054 
   1055   weak_display_manager_factory_.reset(
   1056       new base::WeakPtrFactory<DisplayManager>(display_manager_.get()));
   1057   // The compositor thread and main message loop have to be running in
   1058   // order to create mirror window. Run it after the main message loop
   1059   // is started.
   1060   base::MessageLoopForUI::current()->PostTask(
   1061       FROM_HERE,
   1062       base::Bind(&DisplayManager::CreateMirrorWindowIfAny,
   1063                  weak_display_manager_factory_->GetWeakPtr()));
   1064 }
   1065 
   1066 void Shell::InitKeyboard() {
   1067   if (keyboard::IsKeyboardEnabled()) {
   1068     if (keyboard::KeyboardController::GetInstance()) {
   1069       RootWindowControllerList controllers = GetAllRootWindowControllers();
   1070       for (RootWindowControllerList::iterator iter = controllers.begin();
   1071            iter != controllers.end(); ++iter) {
   1072         (*iter)->DeactivateKeyboard(
   1073             keyboard::KeyboardController::GetInstance());
   1074       }
   1075     }
   1076     keyboard::KeyboardControllerProxy* proxy =
   1077         delegate_->CreateKeyboardControllerProxy();
   1078     keyboard::KeyboardController::ResetInstance(
   1079         new keyboard::KeyboardController(proxy));
   1080   }
   1081 }
   1082 
   1083 void Shell::InitRootWindow(aura::Window* root_window) {
   1084   DCHECK(activation_client_);
   1085   DCHECK(visibility_controller_.get());
   1086   DCHECK(drag_drop_controller_.get());
   1087 
   1088   aura::client::SetFocusClient(root_window, focus_client_.get());
   1089   input_method_filter_->SetInputMethodPropertyInRootWindow(root_window);
   1090   aura::client::SetActivationClient(root_window, activation_client_);
   1091   ::wm::FocusController* focus_controller =
   1092       static_cast< ::wm::FocusController*>(activation_client_);
   1093   root_window->AddPreTargetHandler(focus_controller);
   1094   aura::client::SetVisibilityClient(root_window, visibility_controller_.get());
   1095   aura::client::SetDragDropClient(root_window, drag_drop_controller_.get());
   1096   aura::client::SetScreenPositionClient(root_window,
   1097                                         screen_position_controller_.get());
   1098   aura::client::SetCursorClient(root_window, &cursor_manager_);
   1099   aura::client::SetTooltipClient(root_window, tooltip_controller_.get());
   1100   aura::client::SetEventClient(root_window, event_client_.get());
   1101 
   1102   aura::client::SetWindowMoveClient(root_window,
   1103       toplevel_window_event_handler_.get());
   1104   root_window->AddPreTargetHandler(toplevel_window_event_handler_.get());
   1105   root_window->AddPostTargetHandler(toplevel_window_event_handler_.get());
   1106 
   1107   if (nested_accelerator_controller_) {
   1108     aura::client::SetDispatcherClient(root_window,
   1109                                       nested_accelerator_controller_.get());
   1110   }
   1111 }
   1112 
   1113 bool Shell::CanWindowReceiveEvents(aura::Window* window) {
   1114   RootWindowControllerList controllers = GetAllRootWindowControllers();
   1115   for (RootWindowControllerList::iterator iter = controllers.begin();
   1116        iter != controllers.end(); ++iter) {
   1117     SystemModalContainerLayoutManager* layout_manager =
   1118         (*iter)->GetSystemModalLayoutManager(window);
   1119     if (layout_manager && layout_manager->CanWindowReceiveEvents(window))
   1120       return true;
   1121     // Allow events to fall through to the virtual keyboard even if displaying
   1122     // a system modal dialog.
   1123     if ((*iter)->IsVirtualKeyboardWindow(window))
   1124       return true;
   1125   }
   1126 
   1127   return false;
   1128 }
   1129 
   1130 ////////////////////////////////////////////////////////////////////////////////
   1131 // Shell, ui::EventTarget overrides:
   1132 
   1133 bool Shell::CanAcceptEvent(const ui::Event& event) {
   1134   return true;
   1135 }
   1136 
   1137 ui::EventTarget* Shell::GetParentTarget() {
   1138   return aura::Env::GetInstance();
   1139 }
   1140 
   1141 scoped_ptr<ui::EventTargetIterator> Shell::GetChildIterator() const {
   1142   return scoped_ptr<ui::EventTargetIterator>();
   1143 }
   1144 
   1145 ui::EventTargeter* Shell::GetEventTargeter() {
   1146   NOTREACHED();
   1147   return NULL;
   1148 }
   1149 
   1150 void Shell::OnEvent(ui::Event* event) {
   1151 }
   1152 
   1153 ////////////////////////////////////////////////////////////////////////////////
   1154 // Shell, aura::client::ActivationChangeObserver implementation:
   1155 
   1156 void Shell::OnWindowActivated(aura::Window* gained_active,
   1157                               aura::Window* lost_active) {
   1158   if (gained_active)
   1159     target_root_window_ = gained_active->GetRootWindow();
   1160 }
   1161 
   1162 }  // namespace ash
   1163