Move gfx::Display/Screen to display::Display/Screen in aura/events

ui/aura/window.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 "ui/aura/window.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 16 matching lines @@
 #include "ui/aura/client/window_stacking_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/scoped_canvas.h"
-#include "ui/gfx/screen.h"
 
 namespace aura {
 
 class ScopedCursorHider {
  public:
   explicit ScopedCursorHider(Window* window)
       : window_(window),
         hid_cursor_(false) {
     if (!window_->IsRootWindow())
       return;
     const bool cursor_is_in_bounds = window_->GetBoundsInScreen().Contains(
         Env::GetInstance()->last_mouse_location());
     client::CursorClient* cursor_client = client::GetCursorClient(window_);
     if (cursor_is_in_bounds && cursor_client &&
         cursor_client->IsCursorVisible()) {
       cursor_client->HideCursor();
       hid_cursor_ = true;
     }
   }
   ~ScopedCursorHider() {
     if (!window_->IsRootWindow())
       return;
 
     // Update the device scale factor of the cursor client only when the last
     // mouse location is on this root window.
     if (hid_cursor_) {
       client::CursorClient* cursor_client = client::GetCursorClient(window_);
       if (cursor_client) {
-        const gfx::Display& display =
-            gfx::Screen::GetScreen()->GetDisplayNearestWindow(window_);
+        const display::Display& display =
+            display::Screen::GetScreen()->GetDisplayNearestWindow(window_);
         cursor_client->SetDisplay(display);
         cursor_client->ShowCursor();
       }
     }
   }
 
  private:
   Window* window_;
   bool hid_cursor_;
 
@@ skipping 232 matching lines @@
       const gfx::Size& min_size = delegate_->GetMinimumSize();
       final_bounds.set_width(std::max(min_size.width(), final_bounds.width()));
       final_bounds.set_height(std::max(min_size.height(),
                                        final_bounds.height()));
     }
     SetBoundsInternal(final_bounds);
   }
 }
 
 void Window::SetBoundsInScreen(const gfx::Rect& new_bounds_in_screen,
-                               const gfx::Display& dst_display) {
+                               const display::Display& dst_display) {
   Window* root = GetRootWindow();
   if (root) {
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     screen_position_client->SetBounds(this, new_bounds_in_screen, dst_display);
     return;
   }
   SetBounds(new_bounds_in_screen);
 }
 
@@ skipping 780 matching lines @@
     layer_name = "Unnamed Window";
 
   if (id_ != -1)
     layer_name += " " + base::IntToString(id_);
 
   layer()->set_name(layer_name);
 #endif
 }
 
 }  // namespace aura