Move DisplayLayout and DisplayLayoutBuilder From ash To ui/display

chrome/browser/extensions/display_info_provider_chromeos.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 "chrome/browser/extensions/display_info_provider_chromeos.h"
 
 #include <stdint.h>
 
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "base/strings/string_number_conversions.h"
 #include "extensions/common/api/system_display.h"
+#include "ui/display/manager/display_layout.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace extensions {
 
 using api::system_display::Bounds;
 using api::system_display::DisplayUnitInfo;
 using api::system_display::DisplayProperties;
 using api::system_display::Insets;
@@ skipping 35 matching lines @@
   // vector orthogonal (and facing the positive side) to |vector| is positive.
   //
   // An orthogonal vector of (a, b) is (b, -a), as the scalar product of these
   // two is 0.
   // So, (x, y) is over (a, b) if x * b + y * (-a) >= 0, which is equivalent to
   // x * b >= y * a.
   return static_cast<int64_t>(point.x()) * static_cast<int64_t>(vector.y()) >=
          static_cast<int64_t>(point.y()) * static_cast<int64_t>(vector.x());
 }
 
-// Created ash::DisplayPlacement value for |rectangle| compared to the
+// Created display::DisplayPlacement value for |rectangle| compared to the
 // |reference|
 // rectangle.
 // The layout consists of two values:
 //   - position: Whether the rectangle is positioned left, right, over or under
 //     the reference.
 //   - offset: The rectangle's offset from the reference origin along the axis
 //     opposite the position direction (if the rectangle is left or right along
 //     y-axis, otherwise along x-axis).
 // The rectangle's position is calculated by dividing the space in areas defined
 // by the |reference|'s diagonals and finding the area |rectangle|'s center
@@ skipping 10 matching lines @@
 // | REFERENCE           |
 // |                     |
 // |                     |
 // +---------------------+
 //                 +-------------------------------------------------+
 //                 | RECTANGLE               x                       |
 //                 +-------------------------------------------------+
 //
 // The rectangle shares an egde with the reference's bottom edge, but it's
 // center point is in the left area.
-ash::DisplayPlacement CreatePlacementForRectangles(
+display::DisplayPlacement CreatePlacementForRectangles(
     const gfx::Rect& reference,
     const gfx::Rect& rectangle) {
   // Translate coordinate system so origin is in the reference's top left point
   // (so the reference's down-diagonal vector starts in the (0, 0)) and scale it
   // up by two (to avoid division when calculating the rectangle's center
   // point).
   gfx::Point center(2 * (rectangle.x() - reference.x()) + rectangle.width(),
                     2 * (rectangle.y() - reference.y()) + rectangle.height());
   gfx::Point down_diag(2 * reference.width(), 2 * reference.height());
 
   bool is_top_right = PointIsOverRadiusVector(center, down_diag);
 
   // Translate the coordinating system again, so the bottom right point of the
   // reference is origin (so the references up-diagonal starts at (0, 0)).
   // Note that the coordinate system is scaled by 2.
   center.Offset(0, -2 * reference.height());
   // Choose the vector orientation so the points on the diagonal are considered
   // to be left.
   gfx::Point up_diag(-2 * reference.width(), 2 * reference.height());
 
   bool is_bottom_right = PointIsOverRadiusVector(center, up_diag);
 
-  ash::DisplayPlacement::Position position;
+  display::DisplayPlacement::Position position;
   if (is_top_right) {
-    position = is_bottom_right ? ash::DisplayPlacement::RIGHT
-                               : ash::DisplayPlacement::TOP;
+    position = is_bottom_right ? display::DisplayPlacement::RIGHT
+                               : display::DisplayPlacement::TOP;
   } else {
-    position = is_bottom_right ? ash::DisplayPlacement::BOTTOM
-                               : ash::DisplayPlacement::LEFT;
+    position = is_bottom_right ? display::DisplayPlacement::BOTTOM
+                               : display::DisplayPlacement::LEFT;
   }
 
   // If the rectangle with the calculated position would not have common side
   // with the reference, try to position it so it shares another edge with the
   // reference.
   if (is_top_right == is_bottom_right) {
     if (rectangle.y() > reference.y() + reference.height()) {
       // The rectangle is left or right, but completely under the reference.
-      position = ash::DisplayPlacement::BOTTOM;
+      position = display::DisplayPlacement::BOTTOM;
     } else if (rectangle.y() + rectangle.height() < reference.y()) {
       // The rectangle is left or right, but completely over the reference.
-      position = ash::DisplayPlacement::TOP;
+      position = display::DisplayPlacement::TOP;
     }
   } else {
     if (rectangle.x() > reference.x() + reference.width()) {
       // The rectangle is over or under, but completely right of the reference.
-      position = ash::DisplayPlacement::RIGHT;
+      position = display::DisplayPlacement::RIGHT;
     } else if (rectangle.x() + rectangle.width() < reference.x()) {
       // The rectangle is over or under, but completely left of the reference.
-      position = ash::DisplayPlacement::LEFT;
+      position = display::DisplayPlacement::LEFT;
     }
   }
-  int offset = (position == ash::DisplayPlacement::LEFT ||
-                position == ash::DisplayPlacement::RIGHT)
+  int offset = (position == display::DisplayPlacement::LEFT ||
+                position == display::DisplayPlacement::RIGHT)
                    ? rectangle.y()
                    : rectangle.x();
-  return ash::DisplayPlacement(position, offset);
+  return display::DisplayPlacement(position, offset);
 }
 
 // Updates the display layout for the target display in reference to the primary
 // display.
 void UpdateDisplayLayout(const gfx::Rect& primary_display_bounds,
                          int64_t primary_display_id,
                          const gfx::Rect& target_display_bounds,
                          int64_t target_display_id) {
-  ash::DisplayPlacement placement(CreatePlacementForRectangles(
+  display::DisplayPlacement placement(CreatePlacementForRectangles(
       primary_display_bounds, target_display_bounds));
   placement.display_id = target_display_id;
   placement.parent_display_id = primary_display_id;
 
-  scoped_ptr<ash::DisplayLayout> layout(new ash::DisplayLayout);
+  scoped_ptr<display::DisplayLayout> layout(new display::DisplayLayout);
   layout->placement_list.push_back(placement);
   layout->primary_id = primary_display_id;
 
   ash::Shell::GetInstance()
       ->display_configuration_controller()
       ->SetDisplayLayout(std::move(layout), false /* user_action */);
 }
 
 // Validates that parameters passed to the SetInfo function are valid for the
 // desired display and the current display manager state.
@@ skipping 234 matching lines @@
   }
   return all_displays;
 }
 
 // static
 DisplayInfoProvider* DisplayInfoProvider::Create() {
   return new DisplayInfoProviderChromeOS();
 }
 
 }  // namespace extensions