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

ash/display/unified_mouse_warp_controller.cc

 // Copyright 2015 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/unified_mouse_warp_controller.h"
 
 #include <cmath>
 
 #include "ash/display/display_manager.h"
 #include "ash/display/display_util.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/shell.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/layout.h"
 #include "ui/display/manager/display_layout.h"
+#include "ui/display/screen.h"
 #include "ui/events/event_utils.h"
-#include "ui/gfx/screen.h"
 #include "ui/wm/core/coordinate_conversion.h"
 
 namespace ash {
 
 namespace {
 
 AshWindowTreeHost* GetMirroringAshWindowTreeHostForDisplayId(
     int64_t display_id) {
   return Shell::GetInstance()
       ->window_tree_host_manager()
@@ skipping 15 matching lines @@
   if (index < 0)
     return nullptr;
   return GetMirroringAshWindowTreeHostForDisplayId(
              mirroring_display_list[index].id())->AsWindowTreeHost();
 }
 #endif
 
 }  // namespace
 
 UnifiedMouseWarpController::UnifiedMouseWarpController()
-    : current_cursor_display_id_(gfx::Display::kInvalidDisplayID),
+    : current_cursor_display_id_(display::Display::kInvalidDisplayID),
       update_location_for_test_(false) {}
 
 UnifiedMouseWarpController::~UnifiedMouseWarpController() {
 }
 
 bool UnifiedMouseWarpController::WarpMouseCursor(ui::MouseEvent* event) {
   // Mirroring windows are created asynchronously, so compute the edge
   // beounds when we received an event instead of in constructor.
   if (first_edge_bounds_in_native_.IsEmpty())
     ComputeBounds();
 
   aura::Window* target = static_cast<aura::Window*>(event->target());
   gfx::Point point_in_unified_host = event->location();
   ::wm::ConvertPointToScreen(target, &point_in_unified_host);
   // The display bounds of the mirroring windows isn't scaled, so
   // transform back to the host coordinates.
   target->GetHost()->GetRootTransform().TransformPoint(&point_in_unified_host);
 
-  if (current_cursor_display_id_ != gfx::Display::kInvalidDisplayID) {
+  if (current_cursor_display_id_ != display::Display::kInvalidDisplayID) {
     aura::client::CursorClient* cursor_client =
         aura::client::GetCursorClient(target->GetRootWindow());
     if (cursor_client) {
       display::DisplayList mirroring_display_list =
           Shell::GetInstance()
               ->display_manager()
               ->software_mirroring_display_list();
       int index = FindDisplayIndexContainingPoint(mirroring_display_list,
                                                   point_in_unified_host);
       if (index >= 0) {
-        const gfx::Display& new_display = mirroring_display_list[index];
+        const display::Display& new_display = mirroring_display_list[index];
         if (current_cursor_display_id_ != new_display.id()) {
           cursor_client->SetDisplay(new_display);
-          current_cursor_display_id_ = gfx::Display::kInvalidDisplayID;
+          current_cursor_display_id_ = display::Display::kInvalidDisplayID;
         }
       }
     }
   }
 
   // A native event may not exist in unit test.
   if (!event->HasNativeEvent())
     return false;
 
   gfx::Point point_in_native =
@@ skipping 23 matching lines @@
   display::DisplayList display_list = Shell::GetInstance()
                                           ->display_manager()
                                           ->software_mirroring_display_list();
 
   if (display_list.size() < 2) {
     LOG(ERROR) << "Mirroring Display lost during re-configuration";
     return;
   }
   LOG_IF(ERROR, display_list.size() > 2) << "Only two displays are supported";
 
-  const gfx::Display& first = display_list[0];
-  const gfx::Display& second = display_list[1];
+  const display::Display& first = display_list[0];
+  const display::Display& second = display_list[1];
   bool success = ComputeBoundary(first, second, &first_edge_bounds_in_native_,
                                  &second_edge_bounds_in_native_);
   DCHECK(success);
 
   first_edge_bounds_in_native_ =
       GetNativeEdgeBounds(GetMirroringAshWindowTreeHostForDisplayId(first.id()),
                           first_edge_bounds_in_native_);
 
   second_edge_bounds_in_native_ = GetNativeEdgeBounds(
       GetMirroringAshWindowTreeHostForDisplayId(second.id()),
@@ skipping 17 matching lines @@
       in_first_edge ? display_list[0].id() : display_list[1].id();
   AshWindowTreeHost* target_ash_host =
       GetMirroringAshWindowTreeHostForDisplayId(
           in_first_edge ? display_list[1].id() : display_list[0].id());
   MoveCursorTo(target_ash_host, point_in_unified_host,
                update_mouse_location_now);
   return true;
 }
 
 }  // namespace ash