Fix namespace for src/ui/display/.

ui/display/win/screen_win.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/display/win/screen_win.h"
 
 #include <windows.h>
 #include <shellscalingapi.h>
 
 #include <algorithm>
@@ skipping 17 matching lines @@
 namespace display {
 namespace win {
 namespace {
 
 // TODO(robliao): http://crbug.com/615514 Remove when ScreenWin usage is
 // resolved with Desktop Aura and WindowTreeHost.
 ScreenWin* g_screen_win_instance = nullptr;
 
 float GetMonitorScaleFactor(HMONITOR monitor) {
   DCHECK(monitor);
-  if (display::Display::HasForceDeviceScaleFactor())
-    return display::Display::GetForcedDeviceScaleFactor();
+  if (Display::HasForceDeviceScaleFactor())
+    return Display::GetForcedDeviceScaleFactor();
 
   if (base::win::IsProcessPerMonitorDpiAware()) {
     static auto get_dpi_for_monitor_func = [](){
       using GetDpiForMonitorPtr = decltype(::GetDpiForMonitor)*;
       HMODULE shcore_dll = ::LoadLibrary(L"shcore.dll");
       if (shcore_dll) {
         return reinterpret_cast<GetDpiForMonitorPtr>(
                    ::GetProcAddress(shcore_dll, "GetDpiForMonitor"));
       }
       return static_cast<GetDpiForMonitorPtr>(nullptr);
@@ skipping 21 matching lines @@
               const DisplayInfo& display_info) {
             if (DisplayInfosTouch(ref_display_info, display_info)) {
               touching_display_infos.push_back(display_info);
               return true;
             }
             return false;
           }), display_infos->end());
   return touching_display_infos;
 }
 
-display::Display CreateDisplayFromDisplayInfo(const DisplayInfo& display_info) {
-  display::Display display(display_info.id());
+Display CreateDisplayFromDisplayInfo(const DisplayInfo& display_info) {
+  Display display(display_info.id());
   float scale_factor = display_info.device_scale_factor();
   display.set_device_scale_factor(scale_factor);
   display.set_work_area(
       gfx::ScaleToEnclosingRect(display_info.screen_work_rect(),
                                 1.0f / scale_factor));
   display.set_bounds(gfx::ScaleToEnclosingRect(display_info.screen_rect(),
                      1.0f / scale_factor));
   display.set_rotation(display_info.rotation());
   return display;
 }
@@ skipping 22 matching lines @@
   auto primary_display_iter = std::find_if(
       display_infos_remaining.begin(), display_infos_remaining.end(), [](
           const DisplayInfo& display_info) {
         return display_info.screen_rect().origin().IsOrigin();
       });
   DCHECK(primary_display_iter != display_infos_remaining.end()) <<
       "Missing primary display.";
 
   std::vector<DisplayInfo> available_parents;
   available_parents.push_back(*primary_display_iter);
-  display::DisplayLayoutBuilder builder(primary_display_iter->id());
+  DisplayLayoutBuilder builder(primary_display_iter->id());
   display_infos_remaining.erase(primary_display_iter);
   // Build the tree and determine DisplayPlacements along the way.
   while (available_parents.size()) {
     const DisplayInfo parent = available_parents.back();
     available_parents.pop_back();
     for (const auto& child :
          FindAndRemoveTouchingDisplayInfos(parent, &display_infos_remaining)) {
       builder.AddDisplayPlacement(CalculateDisplayPlacement(parent, child));
       available_parents.push_back(child);
     }
   }
 
   // Layout and create the ScreenWinDisplays.
-  std::vector<display::Display> displays;
+  std::vector<Display> displays;
   for (const auto& display_info : display_infos)
     displays.push_back(CreateDisplayFromDisplayInfo(display_info));
 
-  std::unique_ptr<display::DisplayLayout> layout(builder.Build());
+  std::unique_ptr<DisplayLayout> layout(builder.Build());
   layout->ApplyToDisplayList(&displays, nullptr, 0);
 
   std::vector<ScreenWinDisplay> screen_win_displays;
   const size_t num_displays = display_infos.size();
   for (size_t i = 0; i < num_displays; ++i)
     screen_win_displays.emplace_back(displays[i], display_infos[i]);
 
   return screen_win_displays;
 }
 
-std::vector<display::Display> ScreenWinDisplaysToDisplays(
+std::vector<Display> ScreenWinDisplaysToDisplays(
     const std::vector<ScreenWinDisplay>& screen_win_displays) {
-  std::vector<display::Display> displays;
+  std::vector<Display> displays;
   for (const auto& screen_win_display : screen_win_displays)
     displays.push_back(screen_win_display.display());
 
   return displays;
 }
 
 MONITORINFOEX MonitorInfoFromHMONITOR(HMONITOR monitor) {
   MONITORINFOEX monitor_info;
   ::ZeroMemory(&monitor_info, sizeof(monitor_info));
   monitor_info.cbSize = sizeof(monitor_info);
@@ skipping 46 matching lines @@
 ScreenWin::~ScreenWin() {
   DCHECK_EQ(g_screen_win_instance, this);
   g_screen_win_instance = nullptr;
 }
 
 // static
 gfx::Point ScreenWin::ScreenToDIPPoint(const gfx::Point& pixel_point) {
   const ScreenWinDisplay screen_win_display =
       GetScreenWinDisplayVia(&ScreenWin::GetScreenWinDisplayNearestScreenPoint,
                              pixel_point);
-  const display::Display display = screen_win_display.display();
+  const Display display = screen_win_display.display();
   return ScalePointRelative(screen_win_display.pixel_bounds().origin(),
                             display.bounds().origin(),
                             1.0f / display.device_scale_factor(),
                             pixel_point);
 }
 
 // static
 gfx::Point ScreenWin::DIPToScreenPoint(const gfx::Point& dip_point) {
   const ScreenWinDisplay screen_win_display =
       GetScreenWinDisplayVia(&ScreenWin::GetScreenWinDisplayNearestDIPPoint,
                              dip_point);
-  const display::Display display = screen_win_display.display();
+  const Display display = screen_win_display.display();
   return ScalePointRelative(display.bounds().origin(),
                             screen_win_display.pixel_bounds().origin(),
                             display.device_scale_factor(),
                             dip_point);
 }
 
 // static
 gfx::Point ScreenWin::ClientToDIPPoint(HWND hwnd,
                                        const gfx::Point& client_point) {
   return ScaleToFlooredPoint(client_point, 1.0f / GetScaleFactorForHWND(hwnd));
 }
 
 // static
 gfx::Point ScreenWin::DIPToClientPoint(HWND hwnd, const gfx::Point& dip_point) {
   float scale_factor = GetScaleFactorForHWND(hwnd);
   return ScaleToFlooredPoint(dip_point, scale_factor);
 }
 
 // static
 gfx::Rect ScreenWin::ScreenToDIPRect(HWND hwnd, const gfx::Rect& pixel_bounds) {
   const ScreenWinDisplay screen_win_display = hwnd
       ? GetScreenWinDisplayVia(&ScreenWin::GetScreenWinDisplayNearestHWND, hwnd)
       : GetScreenWinDisplayVia(
             &ScreenWin::GetScreenWinDisplayNearestScreenRect, pixel_bounds);
   float scale_factor = screen_win_display.display().device_scale_factor();
   gfx::Rect dip_rect = ScaleToEnclosingRect(pixel_bounds, 1.0f / scale_factor);
-  const display::Display display = screen_win_display.display();
+  const Display display = screen_win_display.display();
   dip_rect.set_origin(ScalePointRelative(
       screen_win_display.pixel_bounds().origin(),
       display.bounds().origin(),
       1.0f / scale_factor,
       pixel_bounds.origin()));
   return dip_rect;
 }
 
 // static
 gfx::Rect ScreenWin::DIPToScreenRect(HWND hwnd, const gfx::Rect& dip_bounds) {
   const ScreenWinDisplay screen_win_display = hwnd
       ? GetScreenWinDisplayVia(&ScreenWin::GetScreenWinDisplayNearestHWND, hwnd)
       : GetScreenWinDisplayVia(
             &ScreenWin::GetScreenWinDisplayNearestDIPRect, dip_bounds);
   float scale_factor = screen_win_display.display().device_scale_factor();
   gfx::Rect screen_rect = ScaleToEnclosingRect(dip_bounds, scale_factor);
-  const display::Display display = screen_win_display.display();
+  const Display display = screen_win_display.display();
   screen_rect.set_origin(ScalePointRelative(
       display.bounds().origin(),
       screen_win_display.pixel_bounds().origin(),
       scale_factor,
       dip_bounds.origin()));
   return screen_rect;
 }
 
 // static
 gfx::Rect ScreenWin::ClientToDIPRect(HWND hwnd, const gfx::Rect& pixel_bounds) {
@@ skipping 87 matching lines @@
 
 gfx::NativeWindow ScreenWin::GetWindowAtScreenPoint(const gfx::Point& point) {
   gfx::Point point_in_pixels = DIPToScreenPoint(point);
   return GetNativeWindowFromHWND(WindowFromPoint(point_in_pixels.ToPOINT()));
 }
 
 int ScreenWin::GetNumDisplays() const {
   return static_cast<int>(screen_win_displays_.size());
 }
 
-const std::vector<display::Display>& ScreenWin::GetAllDisplays() const {
+const std::vector<Display>& ScreenWin::GetAllDisplays() const {
   return displays_;
 }
 
-display::Display ScreenWin::GetDisplayNearestWindow(
-    gfx::NativeView window) const {
+Display ScreenWin::GetDisplayNearestWindow(gfx::NativeView window) const {
   HWND window_hwnd = GetHWNDFromNativeView(window);
   if (!window_hwnd) {
     // When |window| isn't rooted to a display, we should just return the
     // default display so we get some correct display information like the
     // scaling factor.
     return GetPrimaryDisplay();
   }
   ScreenWinDisplay screen_win_display =
       GetScreenWinDisplayNearestHWND(window_hwnd);
   return screen_win_display.display();
 }
 
 Display ScreenWin::GetDisplayNearestPoint(const gfx::Point& point) const {
   gfx::Point screen_point(DIPToScreenPoint(point));
   ScreenWinDisplay screen_win_display =
       GetScreenWinDisplayNearestScreenPoint(screen_point);
   return screen_win_display.display();
 }
 
-display::Display ScreenWin::GetDisplayMatching(
-    const gfx::Rect& match_rect) const {
+Display ScreenWin::GetDisplayMatching(const gfx::Rect& match_rect) const {
   ScreenWinDisplay screen_win_display =
       GetScreenWinDisplayNearestScreenRect(match_rect);
   return screen_win_display.display();
 }
 
-display::Display ScreenWin::GetPrimaryDisplay() const {
+Display ScreenWin::GetPrimaryDisplay() const {
   return GetPrimaryScreenWinDisplay().display();
 }
 
-void ScreenWin::AddObserver(display::DisplayObserver* observer) {
+void ScreenWin::AddObserver(DisplayObserver* observer) {
   change_notifier_.AddObserver(observer);
 }
 
-void ScreenWin::RemoveObserver(display::DisplayObserver* observer) {
+void ScreenWin::RemoveObserver(DisplayObserver* observer) {
   change_notifier_.RemoveObserver(observer);
 }
 
 gfx::Rect ScreenWin::ScreenToDIPRectInWindow(
     gfx::NativeView view, const gfx::Rect& screen_rect) const {
   HWND hwnd = view ? GetHWNDFromNativeView(view) : nullptr;
   return ScreenToDIPRect(hwnd, screen_rect);
 }
 
 gfx::Rect ScreenWin::DIPToScreenRectInWindow(gfx::NativeView view,
@@ skipping 43 matching lines @@
   return ::GetSystemMetrics(metric);
 }
 
 void ScreenWin::OnWndProc(HWND hwnd,
                           UINT message,
                           WPARAM wparam,
                           LPARAM lparam) {
   if (message != WM_DISPLAYCHANGE)
     return;
 
-  std::vector<display::Display> old_displays = std::move(displays_);
+  std::vector<Display> old_displays = std::move(displays_);
   UpdateFromDisplayInfos(GetDisplayInfosFromSystem());
   change_notifier_.NotifyDisplaysChanged(old_displays, displays_);
 }
 
 ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestHWND(HWND hwnd)
     const {
   return GetScreenWinDisplay(MonitorInfoFromWindow(hwnd,
                                                    MONITOR_DEFAULTTONEAREST));
 }
 
 ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestScreenRect(
     const gfx::Rect& screen_rect) const {
   return GetScreenWinDisplay(MonitorInfoFromScreenRect(screen_rect));
 }
 
 ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestScreenPoint(
     const gfx::Point& screen_point) const {
   return GetScreenWinDisplay(MonitorInfoFromScreenPoint(screen_point));
 }
 
 ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestDIPPoint(
     const gfx::Point& dip_point) const {
   ScreenWinDisplay primary_screen_win_display;
   for (const auto& screen_win_display : screen_win_displays_) {
-    display::Display display = screen_win_display.display();
+    Display display = screen_win_display.display();
     const gfx::Rect dip_bounds = display.bounds();
     if (dip_bounds.Contains(dip_point))
       return screen_win_display;
     else if (dip_bounds.origin().IsOrigin())
       primary_screen_win_display = screen_win_display;
   }
   return primary_screen_win_display;
 }
 
 ScreenWinDisplay ScreenWin::GetScreenWinDisplayNearestDIPRect(
     const gfx::Rect& dip_rect) const {
   ScreenWinDisplay closest_screen_win_display;
   int64_t closest_distance_squared = INT64_MAX;
   for (const auto& screen_win_display : screen_win_displays_) {
-    display::Display display = screen_win_display.display();
+    Display display = screen_win_display.display();
     gfx::Rect dip_bounds = display.bounds();
     if (dip_rect.Intersects(dip_bounds))
       return screen_win_display;
     int64_t distance_squared = SquaredDistanceBetweenRects(dip_rect,
                                                            dip_bounds);
     if (distance_squared < closest_distance_squared) {
       closest_distance_squared = distance_squared;
       closest_screen_win_display = screen_win_display;
     }
   }
   return closest_screen_win_display;
 }
 
 ScreenWinDisplay ScreenWin::GetPrimaryScreenWinDisplay() const {
   MONITORINFOEX monitor_info = MonitorInfoFromWindow(nullptr,
                                                      MONITOR_DEFAULTTOPRIMARY);
   ScreenWinDisplay screen_win_display = GetScreenWinDisplay(monitor_info);
-  display::Display display = screen_win_display.display();
+  Display display = screen_win_display.display();
   // The Windows primary monitor is defined to have an origin of (0, 0).
   DCHECK_EQ(0, display.bounds().origin().x());
   DCHECK_EQ(0, display.bounds().origin().y());
   return screen_win_display;
 }
 
 ScreenWinDisplay ScreenWin::GetScreenWinDisplay(
     const MONITORINFOEX& monitor_info) const {
   int64_t id = DisplayInfo::DeviceIdFromDeviceName(monitor_info.szDevice);
   for (const auto& screen_win_display : screen_win_displays_) {
@@ skipping 29 matching lines @@
     if (std::find(unique_scale_factors.begin(), unique_scale_factors.end(),
                   reported_scale) == unique_scale_factors.end()) {
       unique_scale_factors.push_back(reported_scale);
       UMA_HISTOGRAM_SPARSE_SLOWLY("UI.DeviceScale", reported_scale);
     }
   }
 }
 
 }  // namespace win
 }  // namespace display