Relocate display_manager from ash to ui

ash/display/window_tree_host_manager.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/display/window_tree_host_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/system/tray/system_tray.h"
 #include "ash/display/cursor_window_controller.h"
-#include "ash/display/display_manager.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/host/ash_window_tree_host_init_params.h"
 #include "ash/host/root_window_transformer.h"
 #include "ash/ime/input_method_event_handler.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
@@ skipping 11 matching lines @@
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/compositor.h"
 #include "ui/display/display.h"
 #include "ui/display/manager/display_layout.h"
 #include "ui/display/manager/display_layout_store.h"
+#include "ui/display/manager/display_manager.h"
 #include "ui/display/screen.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/public/activation_client.h"
 
 #if defined(USE_X11)
 #include "ui/base/x/x11_util.h"  // nogncheck
 #include "ui/gfx/x/x11_types.h"  // nogncheck
 
 // Including this at the bottom to avoid other
 // potential conflict with chrome headers.
@@ skipping 13 matching lines @@
 // during the shutdown instead of always keeping two display instances
 // (one here and another one in display_manager) in sync, which is error prone.
 // This is initialized in the constructor, and then in CreatePrimaryHost().
 int64_t primary_display_id = -1;
 
 #if defined(USE_OZONE) && defined(OS_CHROMEOS)
 // Add 20% more cursor motion on non-integrated displays.
 const float kCursorMultiplierForExternalDisplays = 1.2f;
 #endif
 
-DisplayManager* GetDisplayManager() {
+display::DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
 void SetDisplayPropertiesOnHost(AshWindowTreeHost* ash_host,
                                 const display::Display& display) {
   display::ManagedDisplayInfo info =
       GetDisplayManager()->GetDisplayInfo(display.id());
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
 #if defined(OS_CHROMEOS)
 #if defined(USE_X11)
@@ skipping 201 matching lines @@
   const display::Display& primary_candidate =
       GetDisplayManager()->GetPrimaryDisplayCandidate();
   primary_display_id = primary_candidate.id();
   CHECK_NE(display::Display::kInvalidDisplayID, primary_display_id);
   AddWindowTreeHostForDisplay(primary_candidate, init_params);
 }
 
 void WindowTreeHostManager::InitHosts() {
   RootWindowController::CreateForPrimaryDisplay(
       window_tree_hosts_[primary_display_id]);
-  DisplayManager* display_manager = GetDisplayManager();
+  display::DisplayManager* display_manager = GetDisplayManager();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const display::Display& display = display_manager->GetDisplayAt(i);
     if (primary_display_id != display.id()) {
       AshWindowTreeHost* ash_host =
           AddWindowTreeHostForDisplay(display, AshWindowTreeHostInitParams());
       RootWindowController::CreateForSecondaryDisplay(ash_host);
     }
   }
 
   for (auto& observer : observers_)
@@ skipping 91 matching lines @@
     return;
 
   const display::Display& new_primary_display =
       GetDisplayManager()->GetDisplayForId(id);
   if (!new_primary_display.is_valid()) {
     LOG(ERROR) << "Invalid or non-existent display is requested:"
                << new_primary_display.ToString();
     return;
   }
 
-  DisplayManager* display_manager = GetDisplayManager();
+  display::DisplayManager* display_manager = GetDisplayManager();
   DCHECK(new_primary_display.is_valid());
   DCHECK(display_manager->GetDisplayForId(new_primary_display.id()).is_valid());
 
   AshWindowTreeHost* non_primary_host =
       window_tree_hosts_[new_primary_display.id()];
   LOG_IF(ERROR, !non_primary_host)
       << "Unknown display is requested in SetPrimaryDisplay: id="
       << new_primary_display.id();
   if (!non_primary_host)
     return;
@@ skipping 44 matching lines @@
 
 void WindowTreeHostManager::UpdateMouseLocationAfterDisplayChange() {
   // If the mouse is currently on a display in native location,
   // use the same native location. Otherwise find the display closest
   // to the current cursor location in screen coordinates.
 
   gfx::Point point_in_screen =
       display::Screen::GetScreen()->GetCursorScreenPoint();
   gfx::Point target_location_in_native;
   int64_t closest_distance_squared = -1;
-  DisplayManager* display_manager = GetDisplayManager();
+  display::DisplayManager* display_manager = GetDisplayManager();
 
   aura::Window* dst_root_window = nullptr;
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
     const display::Display& display = display_manager->GetDisplayAt(i);
     const display::ManagedDisplayInfo display_info =
         display_manager->GetDisplayInfo(display.id());
     aura::Window* root_window = GetRootWindowForDisplayId(display.id());
     if (display_info.bounds_in_native().Contains(
             cursor_location_in_native_coords_for_restore_)) {
       dst_root_window = root_window;
@@ skipping 73 matching lines @@
   DCHECK(id != display::Display::kInvalidDisplayID);
   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
 }
 
 void WindowTreeHostManager::OnDisplayAdded(const display::Display& display) {
 #if defined(OS_CHROMEOS)
   // If we're switching from/to offscreen WTH, we need to
   // create new WTH for primary display instead of reusing.
   if (primary_tree_host_for_replace_ &&
       (GetRootWindowSettings(GetWindow(primary_tree_host_for_replace_))
-               ->display_id == DisplayManager::kUnifiedDisplayId ||
-       display.id() == DisplayManager::kUnifiedDisplayId)) {
+               ->display_id == display::DisplayManager::kUnifiedDisplayId ||
+       display.id() == display::DisplayManager::kUnifiedDisplayId)) {
     DCHECK_EQ(display::Display::kInvalidDisplayID, primary_display_id);
     primary_display_id = display.id();
 
     AshWindowTreeHost* ash_host =
         AddWindowTreeHostForDisplay(display, AshWindowTreeHostInitParams());
     RootWindowController::CreateForSecondaryDisplay(ash_host);
 
     // Magnifier controllers keep pointers to the current root window.
     // Update them here to avoid accessing them later.
     Shell::GetInstance()->magnification_controller()->SwitchTargetRootWindow(
@@ skipping 127 matching lines @@
   AshWindowTreeHost* ash_host = window_tree_hosts_[display.id()];
   ash_host->AsWindowTreeHost()->SetBounds(display_info.bounds_in_native());
   SetDisplayPropertiesOnHost(ash_host, display);
 }
 
 void WindowTreeHostManager::OnHostResized(const aura::WindowTreeHost* host) {
   display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestWindow(
           const_cast<aura::Window*>(host->window()));
 
-  DisplayManager* display_manager = GetDisplayManager();
+  display::DisplayManager* display_manager = GetDisplayManager();
   if (display_manager->UpdateDisplayBounds(display.id(), host->GetBounds())) {
     mirror_window_controller_->UpdateWindow();
     cursor_window_controller_->UpdateContainer();
   }
 }
 
 void WindowTreeHostManager::CreateOrUpdateMirroringDisplay(
-    const DisplayInfoList& info_list) {
+    const display::DisplayInfoList& info_list) {
   if (GetDisplayManager()->IsInMirrorMode() ||
       GetDisplayManager()->IsInUnifiedMode()) {
     mirror_window_controller_->UpdateWindow(info_list);
     cursor_window_controller_->UpdateContainer();
   } else {
     NOTREACHED();
   }
 }
 
 void WindowTreeHostManager::CloseMirroringDisplayIfNotNecessary() {
@@ skipping 17 matching lines @@
   display::Display display = screen->GetDisplayNearestPoint(point_in_screen);
   cursor_display_id_for_restore_ = display.id();
 
   gfx::Point point_in_native = point_in_screen;
   aura::Window* root_window = GetRootWindowForDisplayId(display.id());
   ::wm::ConvertPointFromScreen(root_window, &point_in_native);
   root_window->GetHost()->ConvertPointToNativeScreen(&point_in_native);
   cursor_location_in_native_coords_for_restore_ = point_in_native;
 }
 
-void WindowTreeHostManager::PostDisplayConfigurationChange() {
+void WindowTreeHostManager::PostDisplayConfigurationChange(
+    bool must_clear_window) {
   focus_activation_store_->Restore();
 
-  DisplayManager* display_manager = GetDisplayManager();
+  display::DisplayManager* display_manager = GetDisplayManager();
   display::DisplayLayoutStore* layout_store = display_manager->layout_store();
   if (display_manager->num_connected_displays() > 1) {
     display::DisplayIdList list = display_manager->GetCurrentDisplayIdList();
     const display::DisplayLayout& layout =
         layout_store->GetRegisteredDisplayLayout(list);
     layout_store->UpdateMultiDisplayState(
         list, display_manager->IsInMirrorMode(), layout.default_unified);
     if (display::Screen::GetScreen()->GetNumDisplays() > 1) {
       SetPrimaryDisplayId(layout.primary_id ==
                                   display::Display::kInvalidDisplayID
                               ? list[0]
                               : layout.primary_id);
     }
   }
 
   for (const display::Display& display :
        display_manager->active_display_list()) {
     bool output_is_secure =
         !display_manager->IsInMirrorMode() && display.IsInternal();
     GetAshWindowTreeHostForDisplayId(display.id())
         ->AsWindowTreeHost()
         ->compositor()
         ->SetOutputIsSecure(output_is_secure);
   }
 
   for (auto& observer : observers_)
     observer.OnDisplayConfigurationChanged();
   UpdateMouseLocationAfterDisplayChange();
+
+#if defined(USE_X11) && defined(OS_CHROMEOS)
+  if (must_clear_window)
+    ui::ClearX11DefaultRootWindow();
+#endif
 }
 
 #if defined(OS_CHROMEOS)
 ui::DisplayConfigurator* WindowTreeHostManager::display_configurator() {
   return Shell::GetInstance()->display_configurator();
 }
 #endif
 
 std::string WindowTreeHostManager::GetInternalDisplayNameString() {
   return l10n_util::GetStringUTF8(IDS_ASH_INTERNAL_DISPLAY_NAME);
@@ skipping 16 matching lines @@
 
 AshWindowTreeHost* WindowTreeHostManager::AddWindowTreeHostForDisplay(
     const display::Display& display,
     const AshWindowTreeHostInitParams& init_params) {
   static int host_count = 0;
   const display::ManagedDisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display.id());
   AshWindowTreeHostInitParams params_with_bounds(init_params);
   params_with_bounds.initial_bounds = display_info.bounds_in_native();
   params_with_bounds.offscreen =
-      display.id() == DisplayManager::kUnifiedDisplayId;
+      display.id() == display::DisplayManager::kUnifiedDisplayId;
   AshWindowTreeHost* ash_host = AshWindowTreeHost::Create(params_with_bounds);
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
   if (!input_method_) {  // Singleton input method instance for Ash.
     input_method_ = ui::CreateInputMethod(this, host->GetAcceleratedWidget());
     // Makes sure the input method is focused by default when created, because
     // Ash uses singleton InputMethod and it won't call OnFocus/OnBlur when the
     // active window changed.
     input_method_->OnFocus();
     input_method_event_handler_.reset(
         new InputMethodEventHandler(input_method_.get()));
@@ skipping 16 matching lines @@
   SetDisplayPropertiesOnHost(ash_host, display);
 
 #if defined(OS_CHROMEOS)
   if (switches::ConstrainPointerToRoot())
     ash_host->ConfineCursorToRootWindow();
 #endif
   return ash_host;
 }
 
 }  // namespace ash