Move DisplayLayout and DisplayLayoutBuilder From ash To ui/display

ash/display/display_manager_unittest.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 "ash/display/display_manager.h"
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_info.h"
-#include "ash/display/display_layout_builder.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_util.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/display_manager_test_api.h"
 #include "ash/test/mirror_window_test_api.h"
 #include "ash/wm/window_state.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_observer.h"
 #include "ui/aura/window_tree_host.h"
+#include "ui/display/manager/display_layout_builder.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/display_observer.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 
 using std::vector;
 using std::string;
@@ skipping 268 matching lines @@
   // Verify calling ReconfigureDisplays doesn't change anything.
   display_manager()->ReconfigureDisplays();
   EXPECT_EQ(3U, display_manager()->GetNumDisplays());
   EXPECT_EQ("0,0 640x480",
             display_manager()->GetDisplayAt(0).bounds().ToString());
   EXPECT_EQ("640,0 320x200",
             display_manager()->GetDisplayAt(1).bounds().ToString());
   EXPECT_EQ("960,0 400x300",
             display_manager()->GetDisplayAt(2).bounds().ToString());
 
-  DisplayPlacement default_placement(DisplayPlacement::BOTTOM, 10);
+  display::DisplayPlacement default_placement(display::DisplayPlacement::BOTTOM,
+                                              10);
   display_manager()->layout_store()->SetDefaultDisplayPlacement(
       default_placement);
 
   // Test with new displays.
   UpdateDisplay("640x480");
   UpdateDisplay("640x480,320x200,400x300");
 
   EXPECT_EQ("0,0 640x480",
             display_manager()->GetDisplayAt(0).bounds().ToString());
   EXPECT_EQ("10,480 320x200",
             display_manager()->GetDisplayAt(1).bounds().ToString());
   EXPECT_EQ("20,680 400x300",
             display_manager()->GetDisplayAt(2).bounds().ToString());
 }
 
 TEST_F(DisplayManagerTest, LayoutMorethanThreeDisplaysTest) {
   if (!SupportsMultipleDisplays())
     return;
 
   int64_t primary_id = gfx::Screen::GetScreen()->GetPrimaryDisplay().id();
-  DisplayIdList list = ash::test::CreateDisplayIdListN(
+  display::DisplayIdList list = ash::test::CreateDisplayIdListN(
       3, primary_id, primary_id + 1, primary_id + 2);
   {
     // Layout: [2]
     //         [1][P]
-    DisplayLayoutBuilder builder(primary_id);
-    builder.AddDisplayPlacement(list[1], primary_id, DisplayPlacement::LEFT,
-                                10);
-    builder.AddDisplayPlacement(list[2], list[1], DisplayPlacement::TOP, 10);
+    display::DisplayLayoutBuilder builder(primary_id);
+    builder.AddDisplayPlacement(list[1], primary_id,
+                                display::DisplayPlacement::LEFT, 10);
+    builder.AddDisplayPlacement(list[2], list[1],
+                                display::DisplayPlacement::TOP, 10);
     display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
         list, builder.Build());
 
     UpdateDisplay("640x480,320x200,400x300");
 
     EXPECT_EQ(3U, display_manager()->GetNumDisplays());
 
     EXPECT_EQ("0,0 640x480",
               display_manager()->GetDisplayAt(0).bounds().ToString());
     EXPECT_EQ("-320,10 320x200",
               display_manager()->GetDisplayAt(1).bounds().ToString());
     EXPECT_EQ("-310,-290 400x300",
               display_manager()->GetDisplayAt(2).bounds().ToString());
   }
   {
     // Layout: [1]
     //         [P][2]
-    DisplayLayoutBuilder builder(primary_id);
-    builder.AddDisplayPlacement(list[1], primary_id, DisplayPlacement::TOP, 10);
-    builder.AddDisplayPlacement(list[2], primary_id, DisplayPlacement::RIGHT,
-                                10);
+    display::DisplayLayoutBuilder builder(primary_id);
+    builder.AddDisplayPlacement(list[1], primary_id,
+                                display::DisplayPlacement::TOP, 10);
+    builder.AddDisplayPlacement(list[2], primary_id,
+                                display::DisplayPlacement::RIGHT, 10);
     display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
         list, builder.Build());
 
     UpdateDisplay("640x480,320x200,400x300");
 
     EXPECT_EQ(3U, display_manager()->GetNumDisplays());
 
     EXPECT_EQ("0,0 640x480",
               display_manager()->GetDisplayAt(0).bounds().ToString());
     EXPECT_EQ("10,-200 320x200",
               display_manager()->GetDisplayAt(1).bounds().ToString());
     EXPECT_EQ("640,10 400x300",
               display_manager()->GetDisplayAt(2).bounds().ToString());
   }
   {
     // Layout: [P]
     //         [2]
     //         [1]
-    DisplayLayoutBuilder builder(primary_id);
-    builder.AddDisplayPlacement(list[1], list[2], DisplayPlacement::BOTTOM, 10);
-    builder.AddDisplayPlacement(list[2], primary_id, DisplayPlacement::BOTTOM,
-                                10);
+    display::DisplayLayoutBuilder builder(primary_id);
+    builder.AddDisplayPlacement(list[1], list[2],
+                                display::DisplayPlacement::BOTTOM, 10);
+    builder.AddDisplayPlacement(list[2], primary_id,
+                                display::DisplayPlacement::BOTTOM, 10);
     display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
         list, builder.Build());
 
     UpdateDisplay("640x480,320x200,400x300");
 
     EXPECT_EQ(3U, display_manager()->GetNumDisplays());
 
     EXPECT_EQ("0,0 640x480",
               display_manager()->GetDisplayAt(0).bounds().ToString());
     EXPECT_EQ("20,780 320x200",
               display_manager()->GetDisplayAt(1).bounds().ToString());
     EXPECT_EQ("10,480 400x300",
               display_manager()->GetDisplayAt(2).bounds().ToString());
   }
 
   {
     list = ash::test::CreateDisplayIdListN(5, primary_id, primary_id + 1,
                                            primary_id + 2, primary_id + 3,
                                            primary_id + 4);
     // Layout: [P][2]
     //      [3][4]
     //      [1]
-    DisplayLayoutBuilder builder(primary_id);
-    builder.AddDisplayPlacement(list[2], primary_id, DisplayPlacement::RIGHT,
-                                10);
-    builder.AddDisplayPlacement(list[1], list[3], DisplayPlacement::BOTTOM, 10);
-    builder.AddDisplayPlacement(list[3], list[4], DisplayPlacement::LEFT, 10);
-    builder.AddDisplayPlacement(list[4], primary_id, DisplayPlacement::BOTTOM,
-                                10);
+    display::DisplayLayoutBuilder builder(primary_id);
+    builder.AddDisplayPlacement(list[2], primary_id,
+                                display::DisplayPlacement::RIGHT, 10);
+    builder.AddDisplayPlacement(list[1], list[3],
+                                display::DisplayPlacement::BOTTOM, 10);
+    builder.AddDisplayPlacement(list[3], list[4],
+                                display::DisplayPlacement::LEFT, 10);
+    builder.AddDisplayPlacement(list[4], primary_id,
+                                display::DisplayPlacement::BOTTOM, 10);
     display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
         list, builder.Build());
 
     UpdateDisplay("640x480,320x200,400x300,300x200,200x100");
 
     EXPECT_EQ(5U, display_manager()->GetNumDisplays());
 
     EXPECT_EQ("0,0 640x480",
               display_manager()->GetDisplayAt(0).bounds().ToString());
     // 2nd is right of the primary.
@@ skipping 1134 matching lines @@
   EXPECT_EQ(2U, display_manager->num_connected_displays());
 
   UpdateDisplay("500x500,500x500");
   EXPECT_FALSE(display_manager->GetCurrentDisplayLayout().mirrored);
   EXPECT_EQ(2, gfx::Screen::GetScreen()->GetNumDisplays());
   EXPECT_EQ(2U, display_manager->num_connected_displays());
 }
 
 TEST_F(DisplayManagerTest, InvertLayout) {
   EXPECT_EQ("left, 0",
-            DisplayPlacement(DisplayPlacement::RIGHT, 0).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::RIGHT, 0)
+                .Swap()
+                .ToString());
   EXPECT_EQ("left, -100",
-            DisplayPlacement(DisplayPlacement::RIGHT, 100).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::RIGHT, 100)
+                .Swap()
+                .ToString());
   EXPECT_EQ("left, 50",
-            DisplayPlacement(DisplayPlacement::RIGHT, -50).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::RIGHT, -50)
+                .Swap()
+                .ToString());
 
   EXPECT_EQ("right, 0",
-            DisplayPlacement(DisplayPlacement::LEFT, 0).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::LEFT, 0)
+                .Swap()
+                .ToString());
   EXPECT_EQ("right, -90",
-            DisplayPlacement(DisplayPlacement::LEFT, 90).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::LEFT, 90)
+                .Swap()
+                .ToString());
   EXPECT_EQ("right, 60",
-            DisplayPlacement(DisplayPlacement::LEFT, -60).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::LEFT, -60)
+                .Swap()
+                .ToString());
 
   EXPECT_EQ("bottom, 0",
-            DisplayPlacement(DisplayPlacement::TOP, 0).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::TOP, 0)
+                .Swap()
+                .ToString());
   EXPECT_EQ("bottom, -80",
-            DisplayPlacement(DisplayPlacement::TOP, 80).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::TOP, 80)
+                .Swap()
+                .ToString());
   EXPECT_EQ("bottom, 70",
-            DisplayPlacement(DisplayPlacement::TOP, -70).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::TOP, -70)
+                .Swap()
+                .ToString());
 
   EXPECT_EQ("top, 0",
-            DisplayPlacement(DisplayPlacement::BOTTOM, 0).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::BOTTOM, 0)
+                .Swap()
+                .ToString());
   EXPECT_EQ("top, -70",
-            DisplayPlacement(DisplayPlacement::BOTTOM, 70).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::BOTTOM, 70)
+                .Swap()
+                .ToString());
   EXPECT_EQ("top, 80",
-            DisplayPlacement(DisplayPlacement::BOTTOM, -80).Swap().ToString());
+            display::DisplayPlacement(display::DisplayPlacement::BOTTOM, -80)
+                .Swap()
+                .ToString());
 }
 
 TEST_F(DisplayManagerTest, NotifyPrimaryChange) {
   if (!SupportsMultipleDisplays())
     return;
   UpdateDisplay("500x500,500x500");
   test::SwapPrimaryDisplay();
   reset();
   UpdateDisplay("500x500");
   EXPECT_FALSE(changed_metrics() & gfx::DisplayObserver::DISPLAY_METRIC_BOUNDS);
@@ skipping 150 matching lines @@
   display_info_list.push_back(d2);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   ASSERT_TRUE(display_manager()->IsInMirrorMode());
   display_manager()->SetUnifiedDesktopEnabled(true);
   EXPECT_TRUE(display_manager()->IsInMirrorMode());
 
   // The display manager automaticaclly switches to software mirroring
   // if the displays are configured to use mirroring when running on desktop.
   // This is a workdaround to force the display manager to forget
   // the mirroing layout.
-  DisplayIdList list = test::CreateDisplayIdList2(1, 2);
-  DisplayLayoutBuilder builder(
+  display::DisplayIdList list = test::CreateDisplayIdList2(1, 2);
+  display::DisplayLayoutBuilder builder(
       display_manager()->layout_store()->GetRegisteredDisplayLayout(list));
   builder.SetMirrored(false);
   display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
       list, builder.Build());
 
   // Exit from hardware mirroring.
   d2.SetBounds(gfx::Rect(0, 500, 500, 500));
   display_info_list.clear();
   display_info_list.push_back(d1);
   display_info_list.push_back(d2);
   display_manager()->OnNativeDisplaysChanged(display_info_list);
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_TRUE(display_manager()->IsInUnifiedMode());
 }
 
 TEST_F(DisplayManagerTest, UnifiedDesktopEnabledWithExtended) {
   if (!SupportsMultipleDisplays())
     return;
   // Don't check root window destruction in unified mode.
   Shell::GetPrimaryRootWindow()->RemoveObserver(this);
 
   UpdateDisplay("400x500,300x200");
-  DisplayIdList list = display_manager()->GetCurrentDisplayIdList();
-  DisplayLayoutBuilder builder(
+  display::DisplayIdList list = display_manager()->GetCurrentDisplayIdList();
+  display::DisplayLayoutBuilder builder(
       display_manager()->layout_store()->GetRegisteredDisplayLayout(list));
   builder.SetDefaultUnified(false);
   display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
       list, builder.Build());
   display_manager()->SetUnifiedDesktopEnabled(true);
   EXPECT_FALSE(display_manager()->IsInUnifiedMode());
 }
 
 TEST_F(DisplayManagerTest, UnifiedDesktopWith2xDSF) {
   if (!SupportsMultipleDisplays())
@@ skipping 199 matching lines @@
   DisplayInfo invalid_info;
   EXPECT_FALSE(GetDisplayModeForNextUIScale(invalid_info, true, &mode));
   EXPECT_FALSE(GetDisplayModeForNextUIScale(invalid_info, false, &mode));
   EXPECT_FALSE(SetDisplayUIScale(gfx::Display::kInvalidDisplayID, 1.0f));
 }
 
 // Make sure that bad layout information is ignored and does not crash.
 TEST_F(DisplayManagerTest, DontRegisterBadConfig) {
   if (!SupportsMultipleDisplays())
     return;
-  DisplayIdList list = ash::test::CreateDisplayIdList2(1, 2);
-  DisplayLayoutBuilder builder(1);
-  builder.AddDisplayPlacement(2, 1, ash::DisplayPlacement::LEFT, 0);
-  builder.AddDisplayPlacement(3, 1, ash::DisplayPlacement::BOTTOM, 0);
+  display::DisplayIdList list = ash::test::CreateDisplayIdList2(1, 2);
+  display::DisplayLayoutBuilder builder(1);
+  builder.AddDisplayPlacement(2, 1, display::DisplayPlacement::LEFT, 0);
+  builder.AddDisplayPlacement(3, 1, display::DisplayPlacement::BOTTOM, 0);
 
   display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
       list, builder.Build());
 }
 
 class ScreenShutdownTest : public test::AshTestBase {
  public:
   ScreenShutdownTest() {
   }
   ~ScreenShutdownTest() override {}
@@ skipping 164 matching lines @@
             info.GetRotation(gfx::Display::ROTATION_SOURCE_USER));
   EXPECT_EQ(gfx::Display::ROTATE_90,
             info.GetRotation(gfx::Display::ROTATION_SOURCE_ACTIVE));
 }
 
 TEST_F(DisplayManagerTest, RejectInvalidLayoutData) {
   DisplayLayoutStore* layout_store = display_manager()->layout_store();
   int64_t id1 = 10001;
   int64_t id2 = 10002;
   ASSERT_TRUE(CompareDisplayIds(id1, id2));
-  DisplayLayoutBuilder good_builder(id1);
-  good_builder.SetSecondaryPlacement(id2, DisplayPlacement::LEFT, 0);
-  scoped_ptr<DisplayLayout> good(good_builder.Build());
+  display::DisplayLayoutBuilder good_builder(id1);
+  good_builder.SetSecondaryPlacement(id2, display::DisplayPlacement::LEFT, 0);
+  scoped_ptr<display::DisplayLayout> good(good_builder.Build());
 
-  DisplayIdList good_list = test::CreateDisplayIdList2(id1, id2);
+  display::DisplayIdList good_list = test::CreateDisplayIdList2(id1, id2);
   layout_store->RegisterLayoutForDisplayIdList(good_list, good->Copy());
 
-  DisplayLayoutBuilder bad(id1);
-  bad.SetSecondaryPlacement(id2, DisplayPlacement::BOTTOM, 0);
+  display::DisplayLayoutBuilder bad(id1);
+  bad.SetSecondaryPlacement(id2, display::DisplayPlacement::BOTTOM, 0);
 
-  DisplayIdList bad_list(2);
+  display::DisplayIdList bad_list(2);
   bad_list[0] = id2;
   bad_list[1] = id1;
   layout_store->RegisterLayoutForDisplayIdList(bad_list, bad.Build());
 
   EXPECT_EQ(good->ToString(),
             layout_store->GetRegisteredDisplayLayout(good_list).ToString());
 }
 
 TEST_F(DisplayManagerTest, GuessDisplayIdFieldsInDisplayLayout) {
   int64_t id1 = 10001;
   int64_t id2 = 10002;
 
-  scoped_ptr<DisplayLayout> old_layout(new DisplayLayout);
-  old_layout->placement_list.emplace_back(DisplayPlacement::BOTTOM, 0);
+  scoped_ptr<display::DisplayLayout> old_layout(new display::DisplayLayout);
+  old_layout->placement_list.emplace_back(display::DisplayPlacement::BOTTOM, 0);
   old_layout->primary_id = id1;
 
   DisplayLayoutStore* layout_store = display_manager()->layout_store();
-  DisplayIdList list = test::CreateDisplayIdList2(id1, id2);
+  display::DisplayIdList list = test::CreateDisplayIdList2(id1, id2);
   layout_store->RegisterLayoutForDisplayIdList(list, std::move(old_layout));
-  const DisplayLayout& stored = layout_store->GetRegisteredDisplayLayout(list);
+  const display::DisplayLayout& stored =
+      layout_store->GetRegisteredDisplayLayout(list);
 
   EXPECT_EQ(id1, stored.placement_list[0].parent_display_id);
   EXPECT_EQ(id2, stored.placement_list[0].display_id);
 }
 
 #endif  // OS_CHROMEOS
 
 }  // namespace ash