Rename gfx::Display/Screen to display::Display/Screen in ash

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>
@@ skipping 26 matching lines @@
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #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/compositor/compositor.h"
+#include "ui/display/display.h"
 #include "ui/display/manager/display_layout.h"
-#include "ui/gfx/display.h"
-#include "ui/gfx/screen.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"
 #include "ui/gfx/x/x11_types.h"  // nogncheck
 
 // Including this at the bottom to avoid other
 // potential conflict with chrome headers.
 #include <X11/extensions/Xrandr.h>
@@ skipping 17 matching lines @@
 #if defined(USE_OZONE) && defined(OS_CHROMEOS)
 // Add 20% more cursor motion on non-integrated displays.
 const float kCursorMultiplierForExternalDisplays = 1.2f;
 #endif
 
 DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
 void SetDisplayPropertiesOnHost(AshWindowTreeHost* ash_host,
-                                const gfx::Display& display) {
+                                const display::Display& display) {
   DisplayInfo info = GetDisplayManager()->GetDisplayInfo(display.id());
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
 #if defined(OS_CHROMEOS)
 #if defined(USE_X11)
   // Native window property (Atom in X11) that specifies the display's
   // rotation, scale factor and if it's internal display.  They are
   // read and used by touchpad/mouse driver directly on X (contact
   // adlr@ for more details on touchpad/mouse driver side). The value
   // of the rotation is one of 0 (normal), 1 (90 degrees clockwise), 2
   // (180 degree) or 3 (270 degrees clockwise).  The value of the
   // scale factor is in percent (100, 140, 200 etc).
   const char kRotationProp[] = "_CHROME_DISPLAY_ROTATION";
   const char kScaleFactorProp[] = "_CHROME_DISPLAY_SCALE_FACTOR";
   const char kInternalProp[] = "_CHROME_DISPLAY_INTERNAL";
   const char kCARDINAL[] = "CARDINAL";
   int xrandr_rotation = RR_Rotate_0;
   switch (info.GetActiveRotation()) {
-    case gfx::Display::ROTATE_0:
+    case display::Display::ROTATE_0:
       xrandr_rotation = RR_Rotate_0;
       break;
-    case gfx::Display::ROTATE_90:
+    case display::Display::ROTATE_90:
       xrandr_rotation = RR_Rotate_90;
       break;
-    case gfx::Display::ROTATE_180:
+    case display::Display::ROTATE_180:
       xrandr_rotation = RR_Rotate_180;
       break;
-    case gfx::Display::ROTATE_270:
+    case display::Display::ROTATE_270:
       xrandr_rotation = RR_Rotate_270;
       break;
   }
 
   int internal = display.IsInternal() ? 1 : 0;
   gfx::AcceleratedWidget xwindow = host->GetAcceleratedWidget();
   ui::SetIntProperty(xwindow, kInternalProp, kCARDINAL, internal);
   ui::SetIntProperty(xwindow, kRotationProp, kCARDINAL, xrandr_rotation);
   ui::SetIntProperty(xwindow, kScaleFactorProp, kCARDINAL,
                      100 * display.device_scale_factor());
@@ skipping 106 matching lines @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHostManager
 
 WindowTreeHostManager::WindowTreeHostManager()
     : primary_tree_host_for_replace_(nullptr),
       focus_activation_store_(new FocusActivationStore()),
       cursor_window_controller_(new CursorWindowController()),
       mirror_window_controller_(new MirrorWindowController()),
-      cursor_display_id_for_restore_(gfx::Display::kInvalidDisplayID),
+      cursor_display_id_for_restore_(display::Display::kInvalidDisplayID),
       weak_ptr_factory_(this) {
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
-  primary_display_id = gfx::Display::kInvalidDisplayID;
+  primary_display_id = display::Display::kInvalidDisplayID;
 }
 
 WindowTreeHostManager::~WindowTreeHostManager() {}
 
 void WindowTreeHostManager::Start() {
-  gfx::Screen::GetScreen()->AddObserver(this);
+  display::Screen::GetScreen()->AddObserver(this);
   Shell::GetInstance()->display_manager()->set_delegate(this);
 }
 
 void WindowTreeHostManager::Shutdown() {
   FOR_EACH_OBSERVER(Observer, observers_, OnWindowTreeHostManagerShutdown());
 
   // Unset the display manager's delegate here because
   // DisplayManager outlives WindowTreeHostManager.
   Shell::GetInstance()->display_manager()->set_delegate(nullptr);
 
   cursor_window_controller_.reset();
   mirror_window_controller_.reset();
 
-  gfx::Screen::GetScreen()->RemoveObserver(this);
+  display::Screen::GetScreen()->RemoveObserver(this);
 
-  int64_t primary_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
+  int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
 
   // Delete non primary root window controllers first, then
   // delete the primary root window controller.
   aura::Window::Windows root_windows =
       WindowTreeHostManager::GetAllRootWindows();
   std::vector<RootWindowController*> to_delete;
   RootWindowController* primary_rwc = nullptr;
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     RootWindowController* rwc = GetRootWindowController(*iter);
     if (GetRootWindowSettings(*iter)->display_id == primary_id)
       primary_rwc = rwc;
     else
       to_delete.push_back(rwc);
   }
   CHECK(primary_rwc);
 
   STLDeleteElements(&to_delete);
   delete primary_rwc;
 }
 
 void WindowTreeHostManager::CreatePrimaryHost(
     const AshWindowTreeHostInitParams& init_params) {
-  const gfx::Display& primary_candidate =
+  const display::Display& primary_candidate =
       GetDisplayManager()->GetPrimaryDisplayCandidate();
   primary_display_id = primary_candidate.id();
-  CHECK_NE(gfx::Display::kInvalidDisplayID, primary_display_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();
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
-    const gfx::Display& display = display_manager->GetDisplayAt(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_EACH_OBSERVER(Observer, observers_, OnDisplaysInitialized());
 }
 
 void WindowTreeHostManager::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowTreeHostManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 // static
 int64_t WindowTreeHostManager::GetPrimaryDisplayId() {
-  CHECK_NE(gfx::Display::kInvalidDisplayID, primary_display_id);
+  CHECK_NE(display::Display::kInvalidDisplayID, primary_display_id);
   return primary_display_id;
 }
 
 aura::Window* WindowTreeHostManager::GetPrimaryRootWindow() {
   return GetRootWindowForDisplayId(primary_display_id);
 }
 
 aura::Window* WindowTreeHostManager::GetRootWindowForDisplayId(int64_t id) {
   AshWindowTreeHost* host = GetAshWindowTreeHostForDisplayId(id);
   CHECK(host);
@@ skipping 52 matching lines @@
     RootWindowController* controller =
         GetRootWindowController(GetWindow(it->second));
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
 void WindowTreeHostManager::SetPrimaryDisplayId(int64_t id) {
   // TODO(oshima): Move primary display management to DisplayManager.
-  DCHECK_NE(gfx::Display::kInvalidDisplayID, id);
-  if (id == gfx::Display::kInvalidDisplayID || primary_display_id == id ||
+  DCHECK_NE(display::Display::kInvalidDisplayID, id);
+  if (id == display::Display::kInvalidDisplayID || primary_display_id == id ||
       window_tree_hosts_.size() < 2) {
     return;
   }
   // TODO(oshima): Implement swapping primary for 2> displays.
   if (GetDisplayManager()->GetNumDisplays() > 2)
     return;
 
-  const gfx::Display& new_primary_display =
+  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();
   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;
 
-  gfx::Display old_primary_display =
-      gfx::Screen::GetScreen()->GetPrimaryDisplay();
+  display::Display old_primary_display =
+      display::Screen::GetScreen()->GetPrimaryDisplay();
   DCHECK_EQ(old_primary_display.id(), primary_display_id);
 
   // Swap root windows between current and new primary display.
   AshWindowTreeHost* primary_host = window_tree_hosts_[primary_display_id];
   CHECK(primary_host);
   CHECK_NE(primary_host, non_primary_host);
 
   window_tree_hosts_[new_primary_display.id()] = primary_host;
   GetRootWindowSettings(GetWindow(primary_host))->display_id =
       new_primary_display.id();
@@ skipping 27 matching lines @@
   GetDisplayManager()->set_force_bounds_changed(true);
   GetDisplayManager()->UpdateDisplays();
   GetDisplayManager()->set_force_bounds_changed(false);
 }
 
 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 = gfx::Screen::GetScreen()->GetCursorScreenPoint();
+  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();
 
   aura::Window* dst_root_window = nullptr;
   for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
-    const gfx::Display& display = display_manager->GetDisplayAt(i);
+    const display::Display& display = display_manager->GetDisplayAt(i);
     const DisplayInfo 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;
       target_location_in_native = cursor_location_in_native_coords_for_restore_;
       break;
     }
     gfx::Point center = display.bounds().CenterPoint();
@@ skipping 15 matching lines @@
     }
   }
 
   gfx::Point target_location_in_root = target_location_in_native;
   dst_root_window->GetHost()->ConvertPointFromNativeScreen(
       &target_location_in_root);
 
 #if defined(USE_OZONE)
   gfx::Point target_location_in_screen = target_location_in_root;
   ::wm::ConvertPointToScreen(dst_root_window, &target_location_in_screen);
-  const gfx::Display& target_display =
+  const display::Display& target_display =
       display_manager->FindDisplayContainingPoint(target_location_in_screen);
   // If the original location isn't on any of new display, let ozone move
   // the cursor.
   if (!target_display.is_valid())
     return;
   int64_t target_display_id = target_display.id();
 
   // Do not move the cursor if the cursor's location did not change. This avoids
   // moving (and showing) the cursor:
   // - At startup.
@@ skipping 23 matching lines @@
   dst_root_window->MoveCursorTo(target_location_in_root);
 #endif
 }
 
 bool WindowTreeHostManager::UpdateWorkAreaOfDisplayNearestWindow(
     const aura::Window* window,
     const gfx::Insets& insets) {
   const aura::Window* root_window = window->GetRootWindow();
   int64_t id = GetRootWindowSettings(root_window)->display_id;
   // if id is |kInvaildDisplayID|, it's being deleted.
-  DCHECK(id != gfx::Display::kInvalidDisplayID);
+  DCHECK(id != display::Display::kInvalidDisplayID);
   return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
 }
 
-void WindowTreeHostManager::OnDisplayAdded(const gfx::Display& display) {
+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)) {
-    DCHECK_EQ(gfx::Display::kInvalidDisplayID, primary_display_id);
+    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(
         ash_host->AsWindowTreeHost()->window(), false);
@@ skipping 37 matching lines @@
     window_tree_hosts_[display.id()] = primary_tree_host_for_replace_;
     GetRootWindowSettings(GetWindow(primary_tree_host_for_replace_))
         ->display_id = display.id();
     primary_tree_host_for_replace_ = nullptr;
     const DisplayInfo& display_info =
         GetDisplayManager()->GetDisplayInfo(display.id());
     AshWindowTreeHost* ash_host = window_tree_hosts_[display.id()];
     ash_host->AsWindowTreeHost()->SetBounds(display_info.bounds_in_native());
     SetDisplayPropertiesOnHost(ash_host, display);
   } else {
-    if (primary_display_id == gfx::Display::kInvalidDisplayID)
+    if (primary_display_id == display::Display::kInvalidDisplayID)
       primary_display_id = display.id();
     DCHECK(!window_tree_hosts_.empty());
     AshWindowTreeHost* ash_host =
         AddWindowTreeHostForDisplay(display, AshWindowTreeHostInitParams());
     RootWindowController::CreateForSecondaryDisplay(ash_host);
   }
 }
 
 void WindowTreeHostManager::DeleteHost(AshWindowTreeHost* host_to_delete) {
   ClearDisplayPropertiesOnHost(host_to_delete);
   RootWindowController* controller =
       GetRootWindowController(GetWindow(host_to_delete));
   DCHECK(controller);
   controller->MoveWindowsTo(GetPrimaryRootWindow());
   // Delete most of root window related objects, but don't delete
   // root window itself yet because the stack may be using it.
   controller->Shutdown();
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, controller);
 }
 
-void WindowTreeHostManager::OnDisplayRemoved(const gfx::Display& display) {
+void WindowTreeHostManager::OnDisplayRemoved(const display::Display& display) {
   AshWindowTreeHost* host_to_delete = window_tree_hosts_[display.id()];
   CHECK(host_to_delete) << display.ToString();
 
   // When the primary root window's display is removed, move the primary
   // root to the other display.
   if (primary_display_id == display.id()) {
     // Temporarily store the primary root window in
     // |primary_root_window_for_replace_| when replacing the display.
     if (window_tree_hosts_.size() == 1) {
-      primary_display_id = gfx::Display::kInvalidDisplayID;
+      primary_display_id = display::Display::kInvalidDisplayID;
       primary_tree_host_for_replace_ = host_to_delete;
       // Display for root window will be deleted when the Primary RootWindow
       // is deleted by the Shell.
       window_tree_hosts_.erase(display.id());
       return;
     }
     for (const auto& pair : window_tree_hosts_) {
       if (pair.first != display.id()) {
         primary_display_id = pair.first;
         break;
       }
     }
-    CHECK_NE(gfx::Display::kInvalidDisplayID, primary_display_id);
+    CHECK_NE(display::Display::kInvalidDisplayID, primary_display_id);
 
     AshWindowTreeHost* primary_host = host_to_delete;
     // Delete the other host instead.
     host_to_delete = window_tree_hosts_[primary_display_id];
     GetRootWindowSettings(GetWindow(host_to_delete))->display_id = display.id();
 
     // Setup primary root.
     window_tree_hosts_[primary_display_id] = primary_host;
     GetRootWindowSettings(GetWindow(primary_host))->display_id =
         primary_display_id;
 
     OnDisplayMetricsChanged(
         GetDisplayManager()->GetDisplayForId(primary_display_id),
         DISPLAY_METRIC_BOUNDS);
   }
 
   DeleteHost(host_to_delete);
 
   // The window tree host should be erased at last because some handlers can
   // access to the host through GetRootWindowForDisplayId() during
   // MoveWindowsTo(). See http://crbug.com/415222
   window_tree_hosts_.erase(display.id());
 }
 
-void WindowTreeHostManager::OnDisplayMetricsChanged(const gfx::Display& display,
-                                                    uint32_t metrics) {
+void WindowTreeHostManager::OnDisplayMetricsChanged(
+    const display::Display& display,
+    uint32_t metrics) {
   if (!(metrics & (DISPLAY_METRIC_BOUNDS | DISPLAY_METRIC_ROTATION |
                    DISPLAY_METRIC_DEVICE_SCALE_FACTOR)))
     return;
   const DisplayInfo& display_info =
       GetDisplayManager()->GetDisplayInfo(display.id());
   DCHECK(!display_info.bounds_in_native().IsEmpty());
   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) {
-  gfx::Display display = gfx::Screen::GetScreen()->GetDisplayNearestWindow(
-      const_cast<aura::Window*>(host->window()));
+  display::Display display =
+      display::Screen::GetScreen()->GetDisplayNearestWindow(
+          const_cast<aura::Window*>(host->window()));
 
   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) {
@@ skipping 12 matching lines @@
   // always on the desktop display (the visible cursor on the non-desktop
   // display is drawn through compositor mirroring). Therefore, it's unnecessary
   // to handle the cursor_window at all. See: http://crbug.com/412910
   if (!cursor_window_controller_->is_cursor_compositing_enabled())
     cursor_window_controller_->UpdateContainer();
 }
 
 void WindowTreeHostManager::PreDisplayConfigurationChange(bool clear_focus) {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
   focus_activation_store_->Store(clear_focus);
-  gfx::Screen* screen = gfx::Screen::GetScreen();
+  display::Screen* screen = display::Screen::GetScreen();
   gfx::Point point_in_screen = screen->GetCursorScreenPoint();
   cursor_location_in_screen_coords_for_restore_ = point_in_screen;
 
-  gfx::Display display = screen->GetDisplayNearestPoint(point_in_screen);
+  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() {
   focus_activation_store_->Restore();
 
   DisplayManager* display_manager = GetDisplayManager();
   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 (gfx::Screen::GetScreen()->GetNumDisplays() > 1) {
-      SetPrimaryDisplayId(layout.primary_id == gfx::Display::kInvalidDisplayID
+    if (display::Screen::GetScreen()->GetNumDisplays() > 1) {
+      SetPrimaryDisplayId(layout.primary_id ==
+                                  display::Display::kInvalidDisplayID
                               ? list[0]
                               : layout.primary_id);
     }
   }
 
-  for (const gfx::Display& display : display_manager->active_display_list()) {
+  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_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
   UpdateMouseLocationAfterDisplayChange();
 }
 
 ui::EventDispatchDetails WindowTreeHostManager::DispatchKeyEventPostIME(
     ui::KeyEvent* event) {
   // Getting the active root window to dispatch the event. This isn't
   // significant as the event will be sent to the window resolved by
   // aura::client::FocusClient which is FocusController in ash.
   aura::Window* active_window = wm::GetActiveWindow();
   aura::Window* root_window = active_window ? active_window->GetRootWindow()
                                             : Shell::GetPrimaryRootWindow();
   return root_window->GetHost()->DispatchKeyEventPostIME(event);
 }
 
 AshWindowTreeHost* WindowTreeHostManager::AddWindowTreeHostForDisplay(
-    const gfx::Display& display,
+    const display::Display& display,
     const AshWindowTreeHostInitParams& init_params) {
   static int host_count = 0;
   const DisplayInfo& 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;
   AshWindowTreeHost* ash_host = AshWindowTreeHost::Create(params_with_bounds);
   aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
@@ skipping 24 matching lines @@
   SetDisplayPropertiesOnHost(ash_host, display);
 
 #if defined(OS_CHROMEOS)
   if (switches::ConstrainPointerToRoot())
     ash_host->ConfineCursorToRootWindow();
 #endif
   return ash_host;
 }
 
 }  // namespace ash