Move display_finder to ui/display

ash/display/screen_ash.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/display/screen_ash.h"
 
 #include "ash/display/display_manager.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/wm/aura/wm_window_aura.h"
 #include "ash/wm/common/root_window_finder.h"
 #include "base/logging.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/display/display.h"
+#include "ui/display/display_finder.h"
 #include "ui/display/screen.h"
-#include "ui/gfx/display_finder.h"
 
 namespace ash {
 
 namespace {
 
 DisplayManager* GetDisplayManager() {
   return Shell::GetInstance()->display_manager();
 }
 
 class ScreenForShutdown : public display::Screen {
@@ skipping 12 matching lines @@
   int GetNumDisplays() const override { return display_list_.size(); }
   std::vector<display::Display> GetAllDisplays() const override {
     return display_list_;
   }
   display::Display GetDisplayNearestWindow(
       gfx::NativeView view) const override {
     return primary_display_;
   }
   display::Display GetDisplayNearestPoint(
       const gfx::Point& point) const override {
-    return *gfx::FindDisplayNearestPoint(display_list_, point);
+    return *display::FindDisplayNearestPoint(display_list_, point);
   }
   display::Display GetDisplayMatching(
       const gfx::Rect& match_rect) const override {
     const display::Display* matching =
-        gfx::FindDisplayWithBiggestIntersection(display_list_, match_rect);
+        display::FindDisplayWithBiggestIntersection(display_list_, match_rect);
     // Fallback to the primary display if there is no matching display.
     return matching ? *matching : GetPrimaryDisplay();
   }
   display::Display GetPrimaryDisplay() const override {
     return primary_display_;
   }
   void AddObserver(display::DisplayObserver* observer) override {
     NOTREACHED() << "Observer should not be added during shutdown";
   }
   void RemoveObserver(display::DisplayObserver* observer) override {}
@@ skipping 85 matching lines @@
 
 display::Display ScreenAsh::GetDisplayNearestPoint(
     const gfx::Point& point) const {
   const display::Display& display =
       GetDisplayManager()->FindDisplayContainingPoint(point);
   if (display.is_valid())
     return display;
   // Fallback to the display that has the shortest Manhattan distance from
   // the |point|. This is correct in the only areas that matter, namely in the
   // corners between the physical screens.
-  return *gfx::FindDisplayNearestPoint(
+  return *display::FindDisplayNearestPoint(
       GetDisplayManager()->active_display_list(), point);
 }
 
 display::Display ScreenAsh::GetDisplayMatching(
     const gfx::Rect& match_rect) const {
   if (match_rect.IsEmpty())
     return GetDisplayNearestPoint(match_rect.origin());
-  const display::Display* matching = gfx::FindDisplayWithBiggestIntersection(
-      GetDisplayManager()->active_display_list(), match_rect);
+  const display::Display* matching =
+      display::FindDisplayWithBiggestIntersection(
+          GetDisplayManager()->active_display_list(), match_rect);
   // Fallback to the primary display if there is no matching display.
   return matching ? *matching : GetPrimaryDisplay();
 }
 
 display::Display ScreenAsh::GetPrimaryDisplay() const {
   return GetDisplayManager()->GetDisplayForId(
       WindowTreeHostManager::GetPrimaryDisplayId());
 }
 
 void ScreenAsh::AddObserver(display::DisplayObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ScreenAsh::RemoveObserver(display::DisplayObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 display::Screen* ScreenAsh::CloneForShutdown() {
   return new ScreenForShutdown(this);
 }
 
 }  // namespace ash