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

chrome/browser/ui/autofill/popup_view_common.cc

 // Copyright 2016 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 "chrome/browser/ui/autofill/popup_view_common.h"
 
 #include <algorithm>
 #include <utility>
 
-#include "ui/gfx/display.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
-#include "ui/gfx/screen.h"
 
 namespace autofill {
 
 namespace {
 
-std::pair<int, int> CalculatePopupXAndWidth(const gfx::Display& left_display,
-                                            const gfx::Display& right_display,
-                                            int popup_required_width,
-                                            const gfx::Rect element_bounds,
-                                            bool is_rtl) {
+std::pair<int, int> CalculatePopupXAndWidth(
+    const display::Display& left_display,
+    const display::Display& right_display,
+    int popup_required_width,
+    const gfx::Rect element_bounds,

[Lei Zhang, 2016/04/28 20:13:10]

Oh, I noticed these aren't being passed in by reference.

[oshima, 2016/04/28 20:19:04]

Done.

+    bool is_rtl) {
   int leftmost_display_x = left_display.bounds().x();
   int rightmost_display_x =
       right_display.GetSizeInPixel().width() + right_display.bounds().x();
 
   // Calculate the start coordinates for the popup if it is growing right or
   // the end position if it is growing to the left, capped to screen space.
   int right_growth_start = std::max(
       leftmost_display_x, std::min(rightmost_display_x, element_bounds.x()));
   int left_growth_end =
       std::max(leftmost_display_x,
@@ skipping 16 matching lines @@
                ? grow_left
                : grow_right;
   }
   return right_available >= popup_width || right_available >= left_available
              ? grow_right
              : grow_left;
 }
 
 // Calculates the height of the popup and the y position of it. These values
 // will stay on the screen.
-std::pair<int, int> CalculatePopupYAndHeight(const gfx::Display& top_display,
-                                             const gfx::Display& bottom_display,
-                                             int popup_required_height,
-                                             const gfx::Rect element_bounds) {
+std::pair<int, int> CalculatePopupYAndHeight(
+    const display::Display& top_display,
+    const display::Display& bottom_display,
+    int popup_required_height,
+    const gfx::Rect element_bounds) {

[oshima, 2016/04/28 20:19:04]

and here too

   int topmost_display_y = top_display.bounds().y();
   int bottommost_display_y =
       bottom_display.GetSizeInPixel().height() + bottom_display.bounds().y();
 
   // Calculate the start coordinates for the popup if it is growing down or
   // the end position if it is growing up, capped to screen space.
   int top_growth_end = std::max(
       topmost_display_y, std::min(bottommost_display_y, element_bounds.y()));
   int bottom_growth_start =
       std::max(topmost_display_y,
@@ skipping 28 matching lines @@
       element_bounds.origin() +
       gfx::Vector2d(element_bounds.width() - desired_width, -desired_height);
 
   // This is the bottom right point of the popup if the popup is below the
   // element and grows to the right (since the is the lowest and furthest right
   // the popup could go).
   gfx::Point bottom_right_corner_of_popup =
       element_bounds.origin() +
       gfx::Vector2d(desired_width, element_bounds.height() + desired_height);
 
-  gfx::Display top_left_display =
+  display::Display top_left_display =
       GetDisplayNearestPoint(top_left_corner_of_popup, container_view);
-  gfx::Display bottom_right_display =
+  display::Display bottom_right_display =
       GetDisplayNearestPoint(bottom_right_corner_of_popup, container_view);
 
   std::pair<int, int> popup_x_and_width =
       CalculatePopupXAndWidth(top_left_display, bottom_right_display,
                               desired_width, element_bounds, is_rtl);
   std::pair<int, int> popup_y_and_height = CalculatePopupYAndHeight(
       top_left_display, bottom_right_display, desired_height, element_bounds);
 
   return gfx::Rect(popup_x_and_width.first, popup_y_and_height.first,
                    popup_x_and_width.second, popup_y_and_height.second);
 }
 
-gfx::Display PopupViewCommon::GetDisplayNearestPoint(
+display::Display PopupViewCommon::GetDisplayNearestPoint(
     const gfx::Point& point,
     gfx::NativeView container_view) {
-  return gfx::Screen::GetScreen()->GetDisplayNearestPoint(point);
+  return display::Screen::GetScreen()->GetDisplayNearestPoint(point);
 }
 
 }  // namespace autofill