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

ash/display/display_util.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/display_util.h"
 
 #include <algorithm>
 
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/shell.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_tree_host.h"
-#include "ui/gfx/display.h"
+#include "ui/display/display.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/wm/core/coordinate_conversion.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #endif
 
 namespace ash {
@@ skipping 117 matching lines @@
             [](const DisplayMode& a, const DisplayMode& b) {
               return a.GetSizeInDIP(false).GetArea() <
                      b.GetSizeInDIP(false).GetArea();
             });
   return display_mode_list;
 }
 
 bool GetDisplayModeForResolution(const DisplayInfo& info,
                                  const gfx::Size& resolution,
                                  DisplayMode* out) {
-  if (gfx::Display::IsInternalDisplayId(info.id()))
+  if (display::Display::IsInternalDisplayId(info.id()))
     return false;
 
   const std::vector<DisplayMode>& modes = info.display_modes();
   DCHECK_NE(0u, modes.size());
   DisplayMode target_mode;
   target_mode.size = resolution;
   std::vector<DisplayMode>::const_iterator iter = std::find_if(
       modes.begin(), modes.end(), [resolution](const DisplayMode& mode) {
         return mode.size == resolution;
       });
   if (iter == modes.end()) {
     LOG(WARNING) << "Unsupported resolution was requested:"
                  << resolution.ToString();
     return false;
   }
   *out = *iter;
   return true;
 }
 
 bool GetDisplayModeForNextUIScale(const DisplayInfo& info,
                                   bool up,
                                   DisplayMode* out) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->IsActiveDisplayId(info.id()) ||
-      !gfx::Display::IsInternalDisplayId(info.id())) {
+      !display::Display::IsInternalDisplayId(info.id())) {
     return false;
   }
   const std::vector<DisplayMode>& modes = info.display_modes();
   ScaleComparator comparator(info.configured_ui_scale());
   auto iter = std::find_if(modes.begin(), modes.end(), comparator);
   FindNextMode(iter, modes, up, out);
   return true;
 }
 
 bool GetDisplayModeForNextResolution(const DisplayInfo& info,
                                      bool up,
                                      DisplayMode* out) {
-  if (gfx::Display::IsInternalDisplayId(info.id()))
+  if (display::Display::IsInternalDisplayId(info.id()))
     return false;
   const std::vector<DisplayMode>& modes = info.display_modes();
   DisplayMode tmp(info.size_in_pixel(), 0.0f, false, false);
   tmp.device_scale_factor = info.device_scale_factor();
   gfx::Size resolution = tmp.GetSizeInDIP(false);
   auto iter = std::find_if(modes.begin(), modes.end(),
                            [resolution](const DisplayMode& mode) {
                              return mode.GetSizeInDIP(false) == resolution;
                            });
   FindNextMode(iter, modes, up, out);
   return true;
 }
 
 bool SetDisplayUIScale(int64_t id, float ui_scale) {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   if (!display_manager->IsActiveDisplayId(id) ||
-      !gfx::Display::IsInternalDisplayId(id)) {
+      !display::Display::IsInternalDisplayId(id)) {
     return false;
   }
   const DisplayInfo& info = display_manager->GetDisplayInfo(id);
   DisplayMode mode;
   if (!GetDisplayModeForUIScale(info, ui_scale, &mode))
     return false;
   return display_manager->SetDisplayMode(id, mode);
 }
 
 bool HasDisplayModeForUIScale(const DisplayInfo& info, float ui_scale) {
   ScaleComparator comparator(ui_scale);
   const std::vector<DisplayMode>& modes = info.display_modes();
   return std::find_if(modes.begin(), modes.end(), comparator) != modes.end();
 }
 
-bool ComputeBoundary(const gfx::Display& a_display,
-                     const gfx::Display& b_display,
+bool ComputeBoundary(const display::Display& a_display,
+                     const display::Display& b_display,
                      gfx::Rect* a_edge_in_screen,
                      gfx::Rect* b_edge_in_screen) {
   const gfx::Rect& a_bounds = a_display.bounds();
   const gfx::Rect& b_bounds = b_display.bounds();
 
   // Find touching side.
   int rx = std::max(a_bounds.x(), b_bounds.x());
   int ry = std::max(a_bounds.y(), b_bounds.y());
   int rr = std::min(a_bounds.right(), b_bounds.right());
   int rb = std::min(a_bounds.bottom(), b_bounds.bottom());
@@ skipping 121 matching lines @@
           &new_point_in_screen);
     } else {
       new_point_in_screen = point_in_native;
       host->ConvertPointFromNativeScreen(&new_point_in_screen);
       ::wm::ConvertPointToScreen(host->window(), &new_point_in_screen);
     }
     aura::Env::GetInstance()->set_last_mouse_location(new_point_in_screen);
   }
 }
 
-int FindDisplayIndexContainingPoint(const std::vector<gfx::Display>& displays,
-                                    const gfx::Point& point_in_screen) {
+int FindDisplayIndexContainingPoint(
+    const std::vector<display::Display>& displays,
+    const gfx::Point& point_in_screen) {
   auto iter = std::find_if(displays.begin(), displays.end(),
-                           [point_in_screen](const gfx::Display& display) {
+                           [point_in_screen](const display::Display& display) {
                              return display.bounds().Contains(point_in_screen);
                            });
   return iter == displays.end() ? -1 : (iter - displays.begin());
 }
 
 display::DisplayIdList CreateDisplayIdList(const display::DisplayList& list) {
   return GenerateDisplayIdList(
       list.begin(), list.end(),
-      [](const gfx::Display& display) { return display.id(); });
+      [](const display::Display& display) { return display.id(); });
 }
 
 void SortDisplayIdList(display::DisplayIdList* ids) {
   std::sort(ids->begin(), ids->end(),
             [](int64_t a, int64_t b) { return CompareDisplayIds(a, b); });
 }
 
 std::string DisplayIdListToString(const display::DisplayIdList& list) {
   std::stringstream s;
   const char* sep = "";
   for (int64_t id : list) {
     s << sep << id;
     sep = ",";
   }
   return s.str();
 }
 
 bool CompareDisplayIds(int64_t id1, int64_t id2) {
   DCHECK_NE(id1, id2);
   // Output index is stored in the first 8 bits. See GetDisplayIdFromEDID
   // in edid_parser.cc.
   int index_1 = id1 & 0xFF;
   int index_2 = id2 & 0xFF;
   DCHECK_NE(index_1, index_2) << id1 << " and " << id2;
-  return gfx::Display::IsInternalDisplayId(id1) ||
-         (index_1 < index_2 && !gfx::Display::IsInternalDisplayId(id2));
+  return display::Display::IsInternalDisplayId(id1) ||
+         (index_1 < index_2 && !display::Display::IsInternalDisplayId(id2));
 }
 
 }  // namespace ash