Make GetRootWindow() return a Window instead of a RootWindow.

ash/shell.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/shell.h"
 
 #include <algorithm>
 #include <string>
 
 #include "ash/accelerators/accelerator_controller.h"
@@ skipping 184 matching lines @@
   return internal::GetRootWindowController(GetPrimaryRootWindow());
 }
 
 // static
 Shell::RootWindowControllerList Shell::GetAllRootWindowControllers() {
   return Shell::GetInstance()->display_controller()->
       GetAllRootWindowControllers();
 }
 
 // static
-aura::RootWindow* Shell::GetPrimaryRootWindow() {
+aura::Window* Shell::GetPrimaryRootWindow() {
   return GetInstance()->display_controller()->GetPrimaryRootWindow();
 }
 
 // static
-aura::RootWindow* Shell::GetTargetRootWindow() {
+aura::Window* Shell::GetTargetRootWindow() {
   Shell* shell = GetInstance();
   if (shell->scoped_target_root_window_)
     return shell->scoped_target_root_window_;
   return shell->target_root_window_;
 }
 
 // static
 gfx::Screen* Shell::GetScreen() {
   return gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
 }
 
 // static
 Shell::RootWindowList Shell::GetAllRootWindows() {
   return Shell::GetInstance()->display_controller()->
       GetAllRootWindows();
 }
 
 // static
-aura::Window* Shell::GetContainer(aura::RootWindow* root_window,
+aura::Window* Shell::GetContainer(aura::Window* root_window,
                                   int container_id) {
   return root_window->GetChildById(container_id);
 }
 
 // static
-const aura::Window* Shell::GetContainer(const aura::RootWindow* root_window,
+const aura::Window* Shell::GetContainer(const aura::Window* root_window,
                                         int container_id) {
   return root_window->GetChildById(container_id);
 }
 
 // static
 std::vector<aura::Window*> Shell::GetContainersFromAllRootWindows(
     int container_id,
-    aura::RootWindow* priority_root) {
+    aura::Window* priority_root) {
   std::vector<aura::Window*> containers;
   RootWindowList root_windows = GetAllRootWindows();
   for (RootWindowList::const_iterator it = root_windows.begin();
        it != root_windows.end(); ++it) {
     aura::Window* container = (*it)->GetChildById(container_id);
     if (container) {
       if (priority_root && priority_root->Contains(container))
         containers.insert(containers.begin(), container);
       else
         containers.push_back(container);
     }
   }
   return containers;
 }
 
 void Shell::ShowContextMenu(const gfx::Point& location_in_screen,
                             ui::MenuSourceType source_type) {
   // No context menus if there is no session with an active user.
   if (!session_state_delegate_->NumberOfLoggedInUsers())
     return;
   // No context menus when screen is locked.
   if (session_state_delegate_->IsScreenLocked())
     return;
 
-  aura::RootWindow* root =
+  aura::Window* root =
       wm::GetRootWindowMatching(gfx::Rect(location_in_screen, gfx::Size()));
   internal::GetRootWindowController(root)->
       ShowContextMenu(location_in_screen, source_type);
 }
 
 void Shell::ToggleAppList(aura::Window* window) {
   // If the context window is not given, show it on the target root window.
   if (!window)
     window = GetTargetRootWindow();
   if (!app_list_controller_)
@@ skipping 116 matching lines @@
 
 void Shell::UpdateShelfVisibility() {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     if ((*iter)->shelf())
       (*iter)->UpdateShelfVisibility();
 }
 
 void Shell::SetShelfAutoHideBehavior(ShelfAutoHideBehavior behavior,
-                                     aura::RootWindow* root_window) {
+                                     aura::Window* root_window) {
   ash::internal::ShelfLayoutManager::ForLauncher(root_window)->
       SetAutoHideBehavior(behavior);
 }
 
 ShelfAutoHideBehavior Shell::GetShelfAutoHideBehavior(
-    aura::RootWindow* root_window) const {
+    aura::Window* root_window) const {
   return ash::internal::ShelfLayoutManager::ForLauncher(root_window)->
       auto_hide_behavior();
 }
 
 void Shell::SetShelfAlignment(ShelfAlignment alignment,
-                              aura::RootWindow* root_window) {
+                              aura::Window* root_window) {
   if (ash::internal::ShelfLayoutManager::ForLauncher(root_window)->
       SetAlignment(alignment)) {
     FOR_EACH_OBSERVER(
         ShellObserver, observers_, OnShelfAlignmentChanged(root_window));
   }
 }
 
-ShelfAlignment Shell::GetShelfAlignment(aura::RootWindow* root_window) {
+ShelfAlignment Shell::GetShelfAlignment(aura::Window* root_window) {
   return internal::GetRootWindowController(root_window)->
       GetShelfLayoutManager()->GetAlignment();
 }
 
 void Shell::SetDimming(bool should_dim) {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     (*iter)->screen_dimmer()->SetDimming(should_dim);
 }
 
 void Shell::NotifyFullscreenStateChange(bool is_fullscreen,
-                                        aura::RootWindow* root_window) {
+                                        aura::Window* root_window) {
   FOR_EACH_OBSERVER(ShellObserver, observers_, OnFullscreenStateChanged(
       is_fullscreen, root_window));
 }
 
 void Shell::CreateModalBackground(aura::Window* window) {
   if (!modality_filter_) {
     modality_filter_.reset(new internal::SystemModalContainerEventFilter(this));
     AddPreTargetHandler(modality_filter_.get());
   }
   RootWindowControllerList controllers = GetAllRootWindowControllers();
@@ skipping 289 matching lines @@
   focus_client_.reset(focus_controller);
   activation_client_ = focus_controller;
   activation_client_->AddObserver(this);
   focus_cycler_.reset(new internal::FocusCycler());
 
   screen_position_controller_.reset(new internal::ScreenPositionController);
   root_window_host_factory_.reset(delegate_->CreateRootWindowHostFactory());
 
   display_controller_->Start();
   display_controller_->InitPrimaryDisplay();
-  aura::RootWindow* root_window = display_controller_->GetPrimaryRootWindow();
+  aura::Window* root_window = display_controller_->GetPrimaryRootWindow();
   target_root_window_ = root_window;
 
   resolution_notification_controller_.reset(
       new internal::ResolutionNotificationController);
 
   cursor_manager_.SetDisplay(DisplayController::GetPrimaryDisplay());
 
   nested_dispatcher_controller_.reset(new NestedDispatcherController);
   accelerator_controller_.reset(new AcceleratorController);
 
   // The order in which event filters are added is significant.
   event_rewriter_filter_.reset(new internal::EventRewriterEventFilter);
   AddPreTargetHandler(event_rewriter_filter_.get());
 
   // UserActivityDetector passes events to observers, so let them get
   // rewritten first.
   user_activity_detector_.reset(new UserActivityDetector);
   AddPreTargetHandler(user_activity_detector_.get());
 
   overlay_filter_.reset(new internal::OverlayEventFilter);
   AddPreTargetHandler(overlay_filter_.get());
   AddShellObserver(overlay_filter_.get());
 
   input_method_filter_.reset(new views::corewm::InputMethodEventFilter(
-                                 root_window->GetAcceleratedWidget()));
+      root_window->GetDispatcher()->GetAcceleratedWidget()));
   AddPreTargetHandler(input_method_filter_.get());
 
   accelerator_filter_.reset(new internal::AcceleratorFilter);
   AddPreTargetHandler(accelerator_filter_.get());
 
   event_transformation_handler_.reset(new internal::EventTransformationHandler);
   AddPreTargetHandler(event_transformation_handler_.get());
 
   system_gesture_filter_.reset(new internal::SystemGestureEventFilter);
   AddPreTargetHandler(system_gesture_filter_.get());
@@ skipping 69 matching lines @@
 
   locale_notification_controller_.reset(
       new internal::LocaleNotificationController);
 
   // Initialize system_tray_delegate_ after StatusAreaWidget is created.
   system_tray_delegate_->Initialize();
 
   // TODO(oshima): Initialize all RootWindowControllers once, and
   // initialize controller/delegates above when initializing the
   // primary root window controller.
-  internal::RootWindowController::CreateForPrimaryDisplay(root_window);
+  internal::RootWindowController::CreateForPrimaryDisplay(
+      root_window->GetDispatcher());
 
   display_controller_->InitSecondaryDisplays();
 
   // It needs to be created after RootWindowController has been created
   // (which calls OnWindowResized has been called, otherwise the
   // widget will not paint when restoring after a browser crash.  Also it needs
   // to be created after InitSecondaryDisplays() to initialize the wallpapers in
   // the correct size.
   user_wallpaper_delegate_->InitializeWallpaper();
 
@@ skipping 102 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, aura::client::ActivationChangeObserver implementation:
 
 void Shell::OnWindowActivated(aura::Window* gained_active,
                               aura::Window* lost_active) {
   if (gained_active)
     target_root_window_ = gained_active->GetRootWindow();
 }
 
 }  // namespace ash