Moves maintaining root_window_for_new_windows_ to Shell

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 <utility>
 
@@ skipping 226 matching lines @@
   return root_window ? root_window->GetRootWindowController() : nullptr;
 }
 
 // static
 aura::Window* Shell::GetPrimaryRootWindow() {
   CHECK(HasInstance());
   return instance_->wm_shell_->GetPrimaryRootWindow()->aura_window();
 }
 
 // static
-aura::Window* Shell::GetTargetRootWindow() {
-  CHECK(WmShell::HasInstance());
-  return WmWindow::GetAuraWindow(WmShell::Get()->GetRootWindowForNewWindows());
+aura::Window* Shell::GetRootWindowForNewWindows() {
+  CHECK(Shell::HasInstance());
+  return WmWindow::GetAuraWindow(Shell::GetWmRootWindowForNewWindows());
 }
 
 // static
-int64_t Shell::GetTargetDisplayId() {
-  return display::Screen::GetScreen()
-      ->GetDisplayNearestWindow(GetTargetRootWindow())
-      .id();
+WmWindow* Shell::GetWmRootWindowForNewWindows() {
+  CHECK(Shell::HasInstance());
+  Shell* shell = Shell::GetInstance();
+  if (shell->scoped_root_window_for_new_windows_)
+    return shell->scoped_root_window_for_new_windows_;
+  return shell->root_window_for_new_windows_;
 }
 
 // static
 aura::Window::Windows Shell::GetAllRootWindows() {
   CHECK(HasInstance());
   aura::Window::Windows windows;
   for (WmWindow* window : instance_->wm_shell_->GetAllRootWindows())
     windows.push_back(window->aura_window());
   return windows;
 }
@@ skipping 74 matching lines @@
   keyboard::KeyboardController::ResetInstance(nullptr);
 }
 
 bool Shell::ShouldSaveDisplaySettings() {
   DCHECK(!wm_shell_->IsRunningInMash());
   return !(
       screen_orientation_controller_->ignore_display_configuration_updates() ||
       resolution_notification_controller_->DoesNotificationTimeout());
 }
 
+aura::client::ActivationClient* Shell::activation_client() {
+  return focus_controller_.get();
+}
+
 void Shell::UpdateShelfVisibility() {
   for (WmWindow* root : wm_shell_->GetAllRootWindows())
     root->GetRootWindowController()->GetShelf()->UpdateVisibilityState();
 }
 
 WebNotificationTray* Shell::GetWebNotificationTray() {
   return GetPrimaryRootWindowController()
       ->GetStatusAreaWidget()
       ->web_notification_tray();
 }
@@ skipping 35 matching lines @@
       ->workspace_controller()
       ->DoInitialAnimation();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 Shell::Shell(std::unique_ptr<WmShell> wm_shell)
     : wm_shell_(std::move(wm_shell)),
       link_handler_model_factory_(nullptr),
-      activation_client_(nullptr),
       display_configurator_(new display::DisplayConfigurator()),
       native_cursor_manager_(nullptr),
       simulate_modal_window_open_for_testing_(false),
       is_touch_hud_projection_enabled_(false) {
   // TODO(sky): better refactor cash/mash dependencies. Perhaps put all cash
   // state on WmShellAura. http://crbug.com/671246.
 
   if (!wm_shell_->IsRunningInMash()) {
     gpu_support_.reset(wm_shell_->delegate()->CreateGPUSupport());
     display_manager_.reset(ScreenAsh::CreateDisplayManager());
@@ skipping 127 matching lines @@
   // WindowTreeHostManager before resetting |window_tree_host_manager_|, since
   // destruction
   // of its owned RootWindowControllers relies on the value.
   ScreenAsh::CreateScreenForShutdown();
   display_configuration_controller_.reset();
 
   // AppListDelegateImpl depends upon AppList.
   app_list_delegate_impl_.reset();
 
   wm_shell_->Shutdown();
-  // Depends on |focus_client_|, so must be destroyed before.
+  // Depends on |focus_controller_|, so must be destroyed before.
   window_tree_host_manager_.reset();
-  focus_client_.reset();
+  focus_controller_->RemoveObserver(this);
+  focus_controller_.reset();
   screen_position_controller_.reset();
 
   keyboard::KeyboardController::ResetInstance(nullptr);
 
   display_color_manager_.reset();
   if (display_change_observer_)
     display_configurator_->RemoveObserver(display_change_observer_.get());
   if (display_error_observer_)
     display_configurator_->RemoveObserver(display_error_observer_.get());
   if (projecting_observer_) {
@@ skipping 100 matching lines @@
   }
 
   // The WindowModalityController needs to be at the front of the input event
   // pretarget handler list to ensure that it processes input events when modal
   // windows are active.
   window_modality_controller_.reset(new ::wm::WindowModalityController(this));
 
   env_filter_.reset(new ::wm::CompoundEventFilter);
   AddPreTargetHandler(env_filter_.get());
 
-  wm::AshFocusRules* focus_rules = new wm::AshFocusRules();
-
-  ::wm::FocusController* focus_controller =
-      new ::wm::FocusController(focus_rules);
-  focus_client_.reset(focus_controller);
-  activation_client_ = focus_controller;
-  // TODO(sky): Shell should implement ActivationChangeObserver, not WmShell.
-  activation_client_->AddObserver(wm_shell_.get());
+  // FocusController takes ownership of AshFocusRules.
+  focus_controller_ =
+      base::MakeUnique<::wm::FocusController>(new wm::AshFocusRules());
+  focus_controller_->AddObserver(this);
 
   screen_position_controller_.reset(new ScreenPositionController);
 
   wm_shell_->CreatePrimaryHost();
-  wm_shell_->set_root_window_for_new_windows(
-      WmWindow::Get(GetPrimaryRootWindow()));
+  root_window_for_new_windows_ = WmWindow::Get(GetPrimaryRootWindow());
 
   if (!is_mash) {
     resolution_notification_controller_.reset(
         new ResolutionNotificationController);
   }
 
   if (cursor_manager_) {
     cursor_manager_->SetDisplay(
         display::Screen::GetScreen()->GetPrimaryDisplay());
   }
@@ skipping 104 matching lines @@
 
   event_client_.reset(new EventClientImpl);
 
   session_state_delegate_.reset(
       wm_shell_->delegate()->CreateSessionStateDelegate());
   // Must occur after Shell has installed its early pre-target handlers (for
   // example, WindowModalityController).
   wm_shell_->CreatePointerWatcherAdapter();
 
   resize_shadow_controller_.reset(new ResizeShadowController());
-  shadow_controller_.reset(new ::wm::ShadowController(activation_client_));
+  shadow_controller_.reset(new ::wm::ShadowController(focus_controller_.get()));
 
   wm_shell_->SetSystemTrayDelegate(
       base::WrapUnique(wm_shell_->delegate()->CreateSystemTrayDelegate()));
 
   // Create AshTouchTransformController before
   // WindowTreeHostManager::InitDisplays()
   // since AshTouchTransformController listens on
   // WindowTreeHostManager::Observer::OnDisplaysInitialized().
   if (!is_mash) {
     touch_transformer_controller_.reset(new AshTouchTransformController(
@@ skipping 59 matching lines @@
       }
     }
     keyboard::KeyboardController::ResetInstance(
         new keyboard::KeyboardController(
             wm_shell_->delegate()->CreateKeyboardUI(),
             virtual_keyboard_controller_.get()));
   }
 }
 
 void Shell::InitRootWindow(aura::Window* root_window) {
-  DCHECK(activation_client_);
+  DCHECK(focus_controller_);
   DCHECK(visibility_controller_.get());
   DCHECK(drag_drop_controller_.get());
 
-  aura::client::SetFocusClient(root_window, focus_client_.get());
-  aura::client::SetActivationClient(root_window, activation_client_);
-  ::wm::FocusController* focus_controller =
-      static_cast<::wm::FocusController*>(activation_client_);
-  root_window->AddPreTargetHandler(focus_controller);
+  aura::client::SetFocusClient(root_window, focus_controller_.get());
+  aura::client::SetActivationClient(root_window, focus_controller_.get());
+  root_window->AddPreTargetHandler(focus_controller_.get());
   aura::client::SetVisibilityClient(root_window, visibility_controller_.get());
   aura::client::SetDragDropClient(root_window, drag_drop_controller_.get());
   aura::client::SetScreenPositionClient(root_window,
                                         screen_position_controller_.get());
   aura::client::SetCursorClient(root_window, cursor_manager_.get());
   aura::client::SetTooltipClient(root_window, tooltip_controller_.get());
   aura::client::SetEventClient(root_window, event_client_.get());
 
   aura::client::SetWindowMoveClient(root_window,
                                     toplevel_window_event_handler_.get());
@@ skipping 38 matching lines @@
 
 std::unique_ptr<ui::EventTargetIterator> Shell::GetChildIterator() const {
   return std::unique_ptr<ui::EventTargetIterator>();
 }
 
 ui::EventTargeter* Shell::GetEventTargeter() {
   NOTREACHED();
   return nullptr;
 }
 
+void Shell::OnWindowActivated(
+    aura::client::ActivationChangeObserver::ActivationReason reason,
+    aura::Window* gained_active,
+    aura::Window* lost_active) {
+  WmWindow* gained_active_wm = WmWindow::Get(gained_active);
+  if (gained_active_wm)
+    root_window_for_new_windows_ = gained_active_wm->GetRootWindow();
+}
+
 }  // namespace ash