Detect and fix overlapping displays

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 "ui/display/manager/display_manager.h"
 
 #include "ash/accelerators/accelerator_commands_aura.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/display/display_configuration_controller.h"
@@ skipping 357 matching lines @@
         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",
+
+    // The above layout causes an overlap between [P] and [2], making [2]'s
+    // bounds be "-310,-290 400x300" if the overlap is not fixed. The overlap
+    // must be detected and fixed and [2] is shifted up to remove the overlap.
+    EXPECT_EQ("-310,-300 400x300",
               display_manager()->GetDisplayAt(2).bounds().ToString());
   }
   {
     // Layout: [1]
     //         [P][2]
     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);
@@ skipping 68 matching lines @@
               display_manager()->GetDisplayAt(4).bounds().ToString());
     // 3rd is the left of 4th.
     EXPECT_EQ("-290,480 300x200",
               display_manager()->GetDisplayAt(3).bounds().ToString());
     // 1st is the bottom of 3rd.
     EXPECT_EQ("-280,680 320x200",
               display_manager()->GetDisplayAt(1).bounds().ToString());
   }
 }
 
+// Makes sure that layouts with overlapped displays are detected and fixed when
+// applied.
+TEST_P(DisplayManagerTest, NoOverlappedDisplays) {
+  if (!SupportsMultipleDisplays())
+    return;
+
+  int64_t primary_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
+  {
+    // Layout with multiple overlaps and special cases:
+    //
+    //            +-----+
+    //            |  6  |
+    //            |     |
+    //       +----+-+   |
+    //       |  5 | |   |
+    //  +----+----+ |   |
+    //  | 7  |    | |   |
+    //  +----+----+-+---+---+-+---------+
+    //       |      |   P   | |   2     |
+    //       +------+       | |         +----------+
+    //              |       | |         |     3    |
+    //              |       | |         |          |
+    //              +--+----+-+-+-+-----+--+       |
+    //                 |    1   | |   4 |  |       |
+    //                 |        | |     +--+-------+
+    //                 |        | |        |
+    //                 +--------+ +--------+
+
+    display::DisplayIdList list = display::test::CreateDisplayIdListN(
+        8, primary_id, primary_id + 1, primary_id + 2, primary_id + 3,
+        primary_id + 4, primary_id + 5, primary_id + 6, primary_id + 7);
+    display::DisplayLayoutBuilder builder(primary_id);
+    builder.AddDisplayPlacement(list[1], primary_id,
+                                display::DisplayPlacement::BOTTOM, 50);
+    builder.AddDisplayPlacement(list[2], list[1],
+                                display::DisplayPlacement::TOP, 300);
+    builder.AddDisplayPlacement(list[3], list[2],
+                                display::DisplayPlacement::RIGHT, 30);
+    builder.AddDisplayPlacement(list[4], list[2],
+                                display::DisplayPlacement::BOTTOM, 400);
+    builder.AddDisplayPlacement(list[5], primary_id,
+                                display::DisplayPlacement::LEFT, -300);
+    builder.AddDisplayPlacement(list[6], primary_id,
+                                display::DisplayPlacement::TOP, -250);
+    builder.AddDisplayPlacement(list[7], list[6],
+                                display::DisplayPlacement::LEFT, 250);
+    display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
+        list, builder.Build());
+
+    UpdateDisplay(
+        "480x400,480x400,480x400,480x400,480x400,480x400,480x400,530x150");
+
+    // The resulting layout after overlaps had been removed:
+    //
+    //    +-------+
+    //    |   5   |
+    //    |       +-----+
+    //    |       |  6  |
+    //    |       |     |
+    //    |       |     |
+    //    |       |     |
+    //  +-+-------+     |
+    //  | 7       |     |
+    //  +---------+-+---+----+---------+
+    //              |   P    |   2     |
+    //              |        |         +----------+
+    //              |        |         |     3    |
+    //              |        |         |          |
+    //              +--+-----+-+-------+          |
+    //                 |   1   |       |          |
+    //                 |       |  +----+---+------+
+    //                 |       |  |   4    |
+    //                 +-------+  |        |
+    //                            |        |
+    //                            +--------+
+
+    EXPECT_EQ(8U, display_manager()->GetNumDisplays());
+
+    EXPECT_EQ("0,0 480x400",
+              display_manager()->GetDisplayAt(0).bounds().ToString());
+    EXPECT_EQ("50,400 480x400",
+              display_manager()->GetDisplayAt(1).bounds().ToString());
+    EXPECT_EQ("480,0 480x400",
+              display_manager()->GetDisplayAt(2).bounds().ToString());
+    EXPECT_EQ("960,30 480x400",
+              display_manager()->GetDisplayAt(3).bounds().ToString());
+    EXPECT_EQ("730,430 480x400",
+              display_manager()->GetDisplayAt(4).bounds().ToString());
+    EXPECT_EQ("-730,-550 480x400",
+              display_manager()->GetDisplayAt(5).bounds().ToString());
+    EXPECT_EQ("-250,-400 480x400",
+              display_manager()->GetDisplayAt(6).bounds().ToString());
+    EXPECT_EQ("-780,-150 530x150",
+              display_manager()->GetDisplayAt(7).bounds().ToString());
+
+    // Expect that the displays have been reparented correctly, such that a
+    // child is always touching its parent.
+    display::DisplayLayoutBuilder expected_layout_builder(primary_id);
+    expected_layout_builder.AddDisplayPlacement(
+        list[1], primary_id, display::DisplayPlacement::BOTTOM, 50);
+    expected_layout_builder.AddDisplayPlacement(
+        list[2], list[1], display::DisplayPlacement::TOP, 430);
+    expected_layout_builder.AddDisplayPlacement(
+        list[3], list[2], display::DisplayPlacement::RIGHT, 30);
+    // [4] became a child of [3] instead of [2] as they no longer touch.
+    expected_layout_builder.AddDisplayPlacement(
+        list[4], list[3], display::DisplayPlacement::BOTTOM, -230);
+    // [5] became a child of [6] instead of [P] as they no longer touch.
+    expected_layout_builder.AddDisplayPlacement(
+        list[5], list[6], display::DisplayPlacement::LEFT, -150);
+    expected_layout_builder.AddDisplayPlacement(
+        list[6], primary_id, display::DisplayPlacement::TOP, -250);
+    expected_layout_builder.AddDisplayPlacement(
+        list[7], list[6], display::DisplayPlacement::LEFT, 250);
+
+    const display::DisplayLayout& layout =
+        display_manager()->GetCurrentResolvedDisplayLayout();
+    EXPECT_TRUE(
+        layout.HasSamePlacementList(*(expected_layout_builder.Build())));
+  }
+
+  {
+    // The following is a layout with an overlap that requires, if two displays
+    // have the same Y, that they're sorted from right to left for the
+    // de-intersecting algorithm to work successfully.
+    //
+    // +---------+---------+
+    // |    1    |    P    |
+    // |         |         |
+    // +---------+         |
+    // |         |         |
+    // +---------+---------+
+    // |    2    |
+    // |         |
+    // +---------+
+
+    display::DisplayIdList list = display::test::CreateDisplayIdListN(
+        3, primary_id, primary_id + 1, primary_id + 2);
+    display::DisplayLayoutBuilder builder(primary_id);
+    builder.AddDisplayPlacement(list[1], primary_id,
+                                display::DisplayPlacement::LEFT, 0);
+    builder.AddDisplayPlacement(list[2], primary_id,
+                                display::DisplayPlacement::LEFT, 250);
+    display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
+        list, builder.Build());
+    UpdateDisplay("696x500,696x500,696x500");
+
+    // The expected layout should be:
+    //
+    // +---------+---------+
+    // |    1    |    P    |
+    // |         |         |
+    // |         |         |
+    // |         |         |
+    // +---------+---------+
+    // |    2    |
+    // |         |
+    // |         |
+    // |         |
+    // +---------+
+
+    EXPECT_EQ(3U, display_manager()->GetNumDisplays());
+    EXPECT_EQ("0,0 696x500",
+              display_manager()->GetDisplayAt(0).bounds().ToString());
+    EXPECT_EQ("-696,0 696x500",
+              display_manager()->GetDisplayAt(1).bounds().ToString());
+    EXPECT_EQ("-696,500 696x500",
+              display_manager()->GetDisplayAt(2).bounds().ToString());
+  }
+
+  {
+    // The following is similar to the above but with two displays having the
+    // same X, they should be sorted from top to bottom for the
+    // de-intersecting algorithm to work successfully.
+    //
+    //    +------+--+------+
+    //    |  2   |  | 1    |
+    //    |      |  |      |
+    //    |      |  |      |
+    //    |      |  |      |
+    //    +------+--+------+
+    //           |    P    |
+    //           |         |
+    //           |         |
+    //           |         |
+    //           +---------+
+    //
+
+    display::DisplayIdList list = display::test::CreateDisplayIdListN(
+        3, primary_id, primary_id + 1, primary_id + 2);
+    display::DisplayLayoutBuilder builder(primary_id);
+    builder.AddDisplayPlacement(list[1], primary_id,
+                                display::DisplayPlacement::TOP, 0);
+    builder.AddDisplayPlacement(list[2], primary_id,
+                                display::DisplayPlacement::TOP, -348);
+    display_manager()->layout_store()->RegisterLayoutForDisplayIdList(
+        list, builder.Build());
+    UpdateDisplay("696x500,696x500,696x500");
+
+    // The expected layout should be:
+    //
+    // +---------+---------+
+    // |    2    |    1    |
+    // |         |         |
+    // |         |         |
+    // |         |         |
+    // +---------+---------+
+    //           |    P    |
+    //           |         |
+    //           |         |
+    //           |         |
+    //           +---------+
+    //
+
+    EXPECT_EQ(3U, display_manager()->GetNumDisplays());
+    EXPECT_EQ("0,0 696x500",
+              display_manager()->GetDisplayAt(0).bounds().ToString());
+    EXPECT_EQ("0,-500 696x500",
+              display_manager()->GetDisplayAt(1).bounds().ToString());
+    EXPECT_EQ("-696,-500 696x500",
+              display_manager()->GetDisplayAt(2).bounds().ToString());
+  }
+}
+
 TEST_P(DisplayManagerTest, NoMirrorInThreeDisplays) {
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("640x480,320x200,400x300");
   ash::Shell::GetInstance()->display_configuration_controller()->SetMirrorMode(
       true, true);
   EXPECT_FALSE(display_manager()->IsInMirrorMode());
   EXPECT_EQ(3u, display_manager()->GetNumDisplays());
 #if defined(OS_CHROMEOS)
@@ skipping 2080 matching lines @@
   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