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

ash/display/screen_position_controller.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/screen_position_controller.h"
 
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/common/window_state.h"
 #include "ash/wm/system_modal_container_layout_manager.h"
 #include "ash/wm/window_properties.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/dip_util.h"
-#include "ui/gfx/display.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace ash {
 namespace {
 
 // Return true if the window or its ancestor has |kStayInSameRootWindowkey|
 // property.
 bool ShouldStayInSameRootWindow(const aura::Window* window) {
   return window && (window->GetProperty(kStayInSameRootWindowKey) ||
                     ShouldStayInSameRootWindow(window->parent()));
 }
 
 // Move all transient children to |dst_root|, including the ones in
 // the child windows and transient children of the transient children.
-void MoveAllTransientChildrenToNewRoot(const gfx::Display& display,
+void MoveAllTransientChildrenToNewRoot(const display::Display& display,
                                        aura::Window* window) {
   aura::Window* dst_root = Shell::GetInstance()
                                ->window_tree_host_manager()
                                ->GetRootWindowForDisplayId(display.id());
   aura::Window::Windows transient_children =
       ::wm::GetTransientChildren(window);
   for (aura::Window::Windows::iterator iter = transient_children.begin();
        iter != transient_children.end(); ++iter) {
     aura::Window* transient_child = *iter;
     int container_id = transient_child->parent()->id();
@@ skipping 67 matching lines @@
   *target_root = root_window;
   *point = point_in_root;
 }
 
 void ScreenPositionController::ConvertPointToScreen(
     const aura::Window* window,
     gfx::Point* point) {
   const aura::Window* root = window->GetRootWindow();
   aura::Window::ConvertPointToTarget(window, root, point);
   const gfx::Point display_origin =
-      gfx::Screen::GetScreen()
+      display::Screen::GetScreen()
           ->GetDisplayNearestWindow(const_cast<aura::Window*>(root))
           .bounds()
           .origin();
   point->Offset(display_origin.x(), display_origin.y());
 }
 
 void ScreenPositionController::ConvertPointFromScreen(
     const aura::Window* window,
     gfx::Point* point) {
   const aura::Window* root = window->GetRootWindow();
   const gfx::Point display_origin =
-      gfx::Screen::GetScreen()
+      display::Screen::GetScreen()
           ->GetDisplayNearestWindow(const_cast<aura::Window*>(root))
           .bounds()
           .origin();
   point->Offset(-display_origin.x(), -display_origin.y());
   aura::Window::ConvertPointToTarget(root, window, point);
 }
 
 void ScreenPositionController::ConvertHostPointToScreen(
     aura::Window* root_window,
     gfx::Point* point) {
   aura::Window* root = root_window->GetRootWindow();
   aura::Window* target_root = nullptr;
   ConvertHostPointToRelativeToRootWindow(root, Shell::GetAllRootWindows(),
                                          point, &target_root);
   ConvertPointToScreen(target_root, point);
 }
 
 void ScreenPositionController::SetBounds(aura::Window* window,
                                          const gfx::Rect& bounds,
-                                         const gfx::Display& display) {
+                                         const display::Display& display) {
   DCHECK_NE(-1, display.id());
   if (!window->parent()->GetProperty(kUsesScreenCoordinatesKey)) {
     window->SetBounds(bounds);
     return;
   }
 
   // Don't move a window to other root window if:
   // a) the window is a transient window. It moves when its
   //    transient_parent moves.
   // b) if the window or its ancestor has kStayInSameRootWindowkey. It's
@@ skipping 51 matching lines @@
         activation_client->ActivateWindow(active);
       }
       // TODO(oshima): We should not have to update the bounds again
       // below in theory, but we currently do need as there is a code
       // that assumes that the bounds will never be overridden by the
       // layout mananger. We should have more explicit control how
       // constraints are applied by the layout manager.
     }
   }
   gfx::Point origin(bounds.origin());
-  const gfx::Point display_origin = gfx::Screen::GetScreen()
+  const gfx::Point display_origin = display::Screen::GetScreen()
                                         ->GetDisplayNearestWindow(window)
                                         .bounds()
                                         .origin();
   origin.Offset(-display_origin.x(), -display_origin.y());
   window->SetBounds(gfx::Rect(origin, bounds.size()));
 }
 
 }  // namespace ash