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

ash/utility/screenshot_controller.cc

 // Copyright 2014 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/utility/screenshot_controller.h"
 
 #include <cmath>
 
 #include "ash/display/mouse_cursor_event_filter.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_util.h"
 #include "base/stl_util.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/compositor/paint_recorder.h"
+#include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/canvas.h"
-#include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/cursor_manager.h"
 
 namespace ash {
 
 namespace {
 
 // The size to increase the invalidated area in the layer to repaint. The area
 // should be slightly bigger than the actual region because the region indicator
 // rectangles are drawn outside of the selected region.
@@ skipping 13 matching lines @@
 
   aura::Window* FindWindowForEvent(ui::LocatedEvent* event) {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     aura::Window* target_root = target->GetRootWindow();
 
     aura::client::ScreenPositionClient* position_client =
         aura::client::GetScreenPositionClient(target_root);
     gfx::Point location = event->location();
     position_client->ConvertPointToScreen(target, &location);
 
-    gfx::Display display =
-        gfx::Screen::GetScreen()->GetDisplayNearestPoint(location);
+    display::Display display =
+        display::Screen::GetScreen()->GetDisplayNearestPoint(location);
 
     aura::Window* root_window = Shell::GetInstance()
                                     ->window_tree_host_manager()
                                     ->GetRootWindowForDisplayId(display.id());
 
     position_client->ConvertPointFromScreen(root_window, &location);
 
     gfx::Point target_location = event->location();
     event->set_location(location);
 
@@ skipping 124 matching lines @@
 
 void ScreenshotController::StartWindowScreenshotSession(
     ScreenshotDelegate* screenshot_delegate) {
   if (screenshot_delegate_) {
     DCHECK_EQ(screenshot_delegate_, screenshot_delegate);
     return;
   }
   screenshot_delegate_ = screenshot_delegate;
   mode_ = WINDOW;
 
-  gfx::Screen::GetScreen()->AddObserver(this);
+  display::Screen::GetScreen()->AddObserver(this);
   for (aura::Window* root : Shell::GetAllRootWindows()) {
     layers_[root] = new ScreenshotLayer(
         Shell::GetContainer(root, kShellWindowId_OverlayContainer)->layer());
   }
   SetSelectedWindow(wm::GetActiveWindow());
 
   cursor_setter_.reset(new ScopedCursorSetter(
       Shell::GetInstance()->cursor_manager(), ui::kCursorCross));
 
   EnableMouseWarp(true);
 }
 
 void ScreenshotController::StartPartialScreenshotSession(
     ScreenshotDelegate* screenshot_delegate) {
   // Already in a screenshot session.
   if (screenshot_delegate_) {
     DCHECK_EQ(screenshot_delegate_, screenshot_delegate);
     return;
   }
 
   screenshot_delegate_ = screenshot_delegate;
   mode_ = PARTIAL;
-  gfx::Screen::GetScreen()->AddObserver(this);
+  display::Screen::GetScreen()->AddObserver(this);
   for (aura::Window* root : Shell::GetAllRootWindows()) {
     layers_[root] = new ScreenshotLayer(
         Shell::GetContainer(root, kShellWindowId_OverlayContainer)->layer());
   }
 
   cursor_setter_.reset(new ScopedCursorSetter(
       Shell::GetInstance()->cursor_manager(), ui::kCursorCross));
 
   EnableMouseWarp(false);
 }
@@ skipping 40 matching lines @@
         root_window_, gfx::IntersectRects(root_window_->bounds(), region));
   }
   Cancel();
 }
 
 void ScreenshotController::Cancel() {
   mode_ = NONE;
   root_window_ = nullptr;
   SetSelectedWindow(nullptr);
   screenshot_delegate_ = nullptr;
-  gfx::Screen::GetScreen()->RemoveObserver(this);
+  display::Screen::GetScreen()->RemoveObserver(this);
   STLDeleteValues(&layers_);
   cursor_setter_.reset();
   EnableMouseWarp(true);
 }
 
 void ScreenshotController::Update(const ui::LocatedEvent& event) {
   // Update may happen without MaybeStart() if the partial screenshot session
   // starts when dragging.
   if (!root_window_)
     MaybeStart(event);
@@ skipping 131 matching lines @@
           break;
         default:
           // Do nothing.
           break;
       }
       break;
   }
   event->StopPropagation();
 }
 
-void ScreenshotController::OnDisplayAdded(const gfx::Display& new_display) {
+void ScreenshotController::OnDisplayAdded(const display::Display& new_display) {
   if (!screenshot_delegate_)
     return;
   Cancel();
 }
 
-void ScreenshotController::OnDisplayRemoved(const gfx::Display& old_display) {
+void ScreenshotController::OnDisplayRemoved(
+    const display::Display& old_display) {
   if (!screenshot_delegate_)
     return;
   Cancel();
 }
 
-void ScreenshotController::OnDisplayMetricsChanged(const gfx::Display& display,
-                                                   uint32_t changed_metrics) {}
+void ScreenshotController::OnDisplayMetricsChanged(
+    const display::Display& display,
+    uint32_t changed_metrics) {}
 
 void ScreenshotController::OnWindowDestroying(aura::Window* window) {
   SetSelectedWindow(nullptr);
 }
 
 }  // namespace ash