Add DisplayPlacement/Layout mojoms + StructTraits.

Add mojoms and StructTraits so that a complete DisplayLayout can be
serialized. This includes DisplayPlacement and some enums. DisplayLayout
is serialized via unique_ptr since it is normally stored as a
unique_ptr.

This is required to pass the DisplayLayout from mus-ws to chrome for the
display options page.

BUG=686848

Review-Url: https://codereview.chromium.org/2661663002
Cr-Commit-Position: refs/heads/master@{#447990}

ui/display/display_layout.cc

@@ -382,6 +382,18 @@ DisplayPlacement::DisplayPlacement(const DisplayPlacement& placement)
       offset(placement.offset),
       offset_reference(placement.offset_reference) {}
 
+bool DisplayPlacement::operator==(const DisplayPlacement& other) const {
+  return display_id == other.display_id &&
+         parent_display_id == other.parent_display_id &&
+         position == other.position &&
+         offset == other.offset &&
+         offset_reference == other.offset_reference;
+}
+
+bool DisplayPlacement::operator!=(const DisplayPlacement& other) const {
+  return !operator==(other);
+}
+
 DisplayPlacement& DisplayPlacement::Swap() {
   switch (position) {
     case TOP:
@@ -569,19 +581,7 @@ std::unique_ptr<DisplayLayout> DisplayLayout::Copy() const {
 }
 
 bool DisplayLayout::HasSamePlacementList(const DisplayLayout& layout) const {
-  if (placement_list.size() != layout.placement_list.size())
-    return false;
-  for (size_t index = 0; index < placement_list.size(); index++) {
-    const DisplayPlacement& placement1 = placement_list[index];
-    const DisplayPlacement& placement2 = layout.placement_list[index];
-    if (placement1.position != placement2.position ||
-        placement1.offset != placement2.offset ||
-        placement1.display_id != placement2.display_id ||
-        placement1.parent_display_id != placement2.parent_display_id) {
-      return false;
-    }
-  }
-  return true;
+  return placement_list == layout.placement_list;
 }
 
 std::string DisplayLayout::ToString() const {

ui/display/display_layout.h

@@ -69,6 +69,9 @@ struct DISPLAY_EXPORT DisplayPlacement {
 
   DisplayPlacement(const DisplayPlacement& placement);
 
+  bool operator==(const DisplayPlacement& other) const;
+  bool operator!=(const DisplayPlacement& other) const;
+
   DisplayPlacement& Swap();
 
   std::string ToString() const;

ui/display/mojo/BUILD.gn

@@ -7,6 +7,7 @@ import("//mojo/public/tools/bindings/mojom.gni")
 mojom("interfaces") {
   sources = [
     "display.mojom",
+    "display_layout.mojom",
     "display_mode.mojom",
   ]
 

ui/display/mojo/display_layout.mojom

+// Copyright 2017 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.
+
+module display.mojom;
+
+// Corresponds to display::DisplayPlacement::Position.
+enum Position {
+  TOP,
+  RIGHT,
+  BOTTOM,
+  LEFT,
+};
+
+// Corresponds to display::DisplayPlacement::OffsetReference.
+enum OffsetReference {
+  TOP_LEFT,
+  BOTTOM_RIGHT,
+};
+
+// Corresponds to display::DisplayPlacement.
+struct DisplayPlacement {
+  int64 display_id;
+  int64 parent_display_id;
+  Position position;
+  int32 offset;
+  OffsetReference offset_reference;
+};
+
+// Corresponds to display::DisplayLayout.
+struct DisplayLayout {
+  bool mirrored;
+  bool default_unified;
+  int64 primary_display_id;
+  array<DisplayPlacement> placement_list;
+};

ui/display/mojo/display_layout.typemap

+# Copyright 2017 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.
+
+mojom = "//ui/display/mojo/display_layout.mojom"
+public_headers = [ "//ui/display/display_layout.h" ]
+traits_headers = [ "//ui/display/mojo/display_layout_struct_traits.h" ]
+sources = [
+  "//ui/display/mojo/display_layout_struct_traits.cc",
+]
+public_deps = [
+  "//ui/display",
+]
+
+type_mappings = [
+  "display.mojom.Position=display::DisplayPlacement::Position",
+  "display.mojom.OffsetReference=display::DisplayPlacement::OffsetReference",
+  "display.mojom.DisplayPlacement=display::DisplayPlacement",
+  "display.mojom.DisplayLayout=std::unique_ptr<display::DisplayLayout>[move_only]",
+]

ui/display/mojo/display_layout_struct_traits.cc

+// Copyright 2017 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/mojo/display_layout_struct_traits.h"
+
+namespace mojo {
+
+display::mojom::Position
+EnumTraits<display::mojom::Position, display::DisplayPlacement::Position>::
+    ToMojom(display::DisplayPlacement::Position rotation) {
+  switch (rotation) {
+    case display::DisplayPlacement::TOP:
+      return display::mojom::Position::TOP;
+    case display::DisplayPlacement::RIGHT:
+      return display::mojom::Position::RIGHT;
+    case display::DisplayPlacement::BOTTOM:
+      return display::mojom::Position::BOTTOM;
+    case display::DisplayPlacement::LEFT:
+      return display::mojom::Position::LEFT;
+  }
+  NOTREACHED();
+  return display::mojom::Position::TOP;
+}
+
+bool EnumTraits<display::mojom::Position, display::DisplayPlacement::Position>::
+    FromMojom(display::mojom::Position rotation,
+              display::DisplayPlacement::Position* out) {
+  switch (rotation) {
+    case display::mojom::Position::TOP:
+      *out = display::DisplayPlacement::TOP;
+      return true;
+    case display::mojom::Position::RIGHT:
+      *out = display::DisplayPlacement::RIGHT;
+      return true;
+    case display::mojom::Position::BOTTOM:
+      *out = display::DisplayPlacement::BOTTOM;
+      return true;
+    case display::mojom::Position::LEFT:
+      *out = display::DisplayPlacement::LEFT;
+      return true;
+  }
+  return false;
+}
+
+display::mojom::OffsetReference
+EnumTraits<display::mojom::OffsetReference,
+           display::DisplayPlacement::OffsetReference>::
+    ToMojom(display::DisplayPlacement::OffsetReference rotation) {
+  switch (rotation) {
+    case display::DisplayPlacement::TOP_LEFT:
+      return display::mojom::OffsetReference::TOP_LEFT;
+    case display::DisplayPlacement::BOTTOM_RIGHT:
+      return display::mojom::OffsetReference::BOTTOM_RIGHT;
+  }
+  NOTREACHED();
+  return display::mojom::OffsetReference::TOP_LEFT;
+}
+
+bool EnumTraits<display::mojom::OffsetReference,
+                display::DisplayPlacement::OffsetReference>::
+    FromMojom(display::mojom::OffsetReference rotation,
+              display::DisplayPlacement::OffsetReference* out) {
+  switch (rotation) {
+    case display::mojom::OffsetReference::TOP_LEFT:
+      *out = display::DisplayPlacement::TOP_LEFT;
+      return true;
+    case display::mojom::OffsetReference::BOTTOM_RIGHT:
+      *out = display::DisplayPlacement::BOTTOM_RIGHT;
+      return true;
+  }
+  return false;
+}
+
+bool StructTraits<display::mojom::DisplayPlacementDataView,
+                  display::DisplayPlacement>::
+    Read(display::mojom::DisplayPlacementDataView data,
+         display::DisplayPlacement* out) {
+  out->display_id = data.display_id();
+  out->parent_display_id = data.parent_display_id();
+  out->offset = data.offset();
+
+  if (!data.ReadPosition(&out->position))
+    return false;
+
+  if (!data.ReadOffsetReference(&out->offset_reference))
+    return false;
+
+  return true;
+}
+
+bool StructTraits<display::mojom::DisplayLayoutDataView,
+                  std::unique_ptr<display::DisplayLayout>>::
+    Read(display::mojom::DisplayLayoutDataView data,
+         std::unique_ptr<display::DisplayLayout>* out) {
+  auto display_layout = base::MakeUnique<display::DisplayLayout>();
+
+  if (!data.ReadPlacementList(&display_layout->placement_list))
+    return false;
+
+  display_layout->mirrored = data.mirrored();
+  display_layout->default_unified = data.default_unified();
+  display_layout->primary_id = data.primary_display_id();
+
+  *out = std::move(display_layout);
+
+  return true;
+}
+
+}  // namespace mojo

ui/display/mojo/display_layout_struct_traits.h

+// Copyright 2017 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.
+
+#ifndef UI_DISPLAY_MOJO_DISPLAY_LAYOUT_STRUCT_TRAITS_H_
+#define UI_DISPLAY_MOJO_DISPLAY_LAYOUT_STRUCT_TRAITS_H_
+
+#include <memory>
+#include <vector>
+
+#include "ui/display/display_layout.h"
+#include "ui/display/mojo/display_layout.mojom.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<display::mojom::Position,
+                  display::DisplayPlacement::Position> {
+  static display::mojom::Position ToMojom(
+      display::DisplayPlacement::Position type);
+  static bool FromMojom(display::mojom::Position type,
+                        display::DisplayPlacement::Position* output);
+};
+
+template <>
+struct EnumTraits<display::mojom::OffsetReference,
+                  display::DisplayPlacement::OffsetReference> {
+  static display::mojom::OffsetReference ToMojom(
+      display::DisplayPlacement::OffsetReference type);
+  static bool FromMojom(display::mojom::OffsetReference type,
+                        display::DisplayPlacement::OffsetReference* output);
+};
+
+template <>
+struct StructTraits<display::mojom::DisplayPlacementDataView,
+                    display::DisplayPlacement> {
+  static int64_t display_id(const display::DisplayPlacement& placement) {
+    return placement.display_id;
+  }
+
+  static int64_t parent_display_id(const display::DisplayPlacement& placement) {
+    return placement.parent_display_id;
+  }
+
+  static display::DisplayPlacement::Position position(
+      const display::DisplayPlacement& placement) {
+    return placement.position;
+  }
+
+  static int offset(const display::DisplayPlacement& placement) {
+    return placement.offset;
+  }
+
+  static display::DisplayPlacement::OffsetReference offset_reference(
+      const display::DisplayPlacement& placement) {
+    return placement.offset_reference;
+  }
+
+  static bool Read(display::mojom::DisplayPlacementDataView data,
+                   display::DisplayPlacement* out);
+};
+
+template <>
+struct StructTraits<display::mojom::DisplayLayoutDataView,
+                    std::unique_ptr<display::DisplayLayout>> {
+  static bool mirrored(const std::unique_ptr<display::DisplayLayout>& layout) {
+    return layout->mirrored;
+  }
+
+  static bool default_unified(
+      const std::unique_ptr<display::DisplayLayout>& layout) {
+    return layout->default_unified;
+  }
+
+  static int64_t primary_display_id(
+      const std::unique_ptr<display::DisplayLayout>& layout) {
+    return layout->primary_id;
+  }
+
+  static const std::vector<display::DisplayPlacement>& placement_list(
+      const std::unique_ptr<display::DisplayLayout>& layout) {
+    return layout->placement_list;
+  }
+
+  static bool Read(display::mojom::DisplayLayoutDataView data,
+                   std::unique_ptr<display::DisplayLayout>* out);
+};
+
+}  // namespace mojo
+
+#endif  // UI_DISPLAY_MOJO_DISPLAY_LAYOUT_STRUCT_TRAITS_H_

ui/display/mojo/display_struct_traits.cc

@@ -76,7 +76,7 @@ bool EnumTraits<display::mojom::TouchSupport, display::Display::TouchSupport>::
       return true;
   }
   NOTREACHED();
-  return display::Display::TOUCH_SUPPORT_UNKNOWN;
+  return false;
 }
 
 bool StructTraits<display::mojom::DisplayDataView, display::Display>::Read(

ui/display/mojo/display_struct_traits_test.mojom

@@ -5,6 +5,7 @@
 module display.mojom;
 
 import "ui/display/mojo/display.mojom";
+import "ui/display/mojo/display_layout.mojom";
 import "ui/display/mojo/display_mode.mojom";
 
 interface DisplayStructTraitsTest {
@@ -13,5 +14,10 @@ interface DisplayStructTraitsTest {
 
   [Sync]
   EchoDisplayMode(DisplayMode in) => (DisplayMode out);
-};
 
+  [Sync]
+  EchoDisplayPlacement(DisplayPlacement in) => (DisplayPlacement out);
+
+  [Sync]
+  EchoDisplayLayout(DisplayLayout in) => (DisplayLayout out);
+};
\ No newline at end of file

ui/display/mojo/display_struct_traits_unittest.cc

@@ -6,15 +6,19 @@
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/display.h"
+#include "ui/display/display_layout.h"
 #include "ui/display/mojo/display_struct_traits_test.mojom.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace display {
-
 namespace {
 
+constexpr int64_t kDisplayId1 = 123;
+constexpr int64_t kDisplayId2 = 456;
+constexpr int64_t kDisplayId3 = 789;
+
 class DisplayStructTraitsTest : public testing::Test,
                                 public mojom::DisplayStructTraitsTest {
  public:
@@ -37,6 +41,17 @@ class DisplayStructTraitsTest : public testing::Test,
     callback.Run(std::move(in));
   }
 
+  void EchoDisplayPlacement(
+      const DisplayPlacement& in,
+      const EchoDisplayPlacementCallback& callback) override {
+    callback.Run(in);
+  }
+
+  void EchoDisplayLayout(std::unique_ptr<display::DisplayLayout> in,
+                         const EchoDisplayLayoutCallback& callback) override {
+    callback.Run(std::move(in));
+  }
+
   base::MessageLoop loop_;  // A MessageLoop is needed for Mojo IPC to work.
   mojo::BindingSet<mojom::DisplayStructTraitsTest> traits_test_bindings_;
 
@@ -54,14 +69,22 @@ void CheckDisplaysEqual(const Display& input, const Display& output) {
   EXPECT_EQ(input.maximum_cursor_size(), output.maximum_cursor_size());
 }
 
+void CheckDisplayLayoutsEqual(const DisplayLayout& input,
+                              const DisplayLayout& output) {
+  EXPECT_NE(&input, &output);  // Make sure they aren't the same object.
+  EXPECT_EQ(input.placement_list, output.placement_list);
+  EXPECT_EQ(input.mirrored, output.mirrored);
+  EXPECT_EQ(input.default_unified, output.default_unified);
+  EXPECT_EQ(input.primary_id, output.primary_id);
+}
+
 }  // namespace
 
 TEST_F(DisplayStructTraitsTest, DefaultDisplayValues) {
   Display input(5);
 
-  mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
   Display output;
-  proxy->EchoDisplay(input, &output);
+  GetTraitsTestProxy()->EchoDisplay(input, &output);
 
   CheckDisplaysEqual(input, output);
 }
@@ -78,18 +101,15 @@ TEST_F(DisplayStructTraitsTest, SetAllDisplayValues) {
   input.set_touch_support(Display::TOUCH_SUPPORT_AVAILABLE);
   input.set_maximum_cursor_size(maximum_cursor_size);
 
-  mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
   Display output;
-  proxy->EchoDisplay(input, &output);
+  GetTraitsTestProxy()->EchoDisplay(input, &output);
 
   CheckDisplaysEqual(input, output);
 }
 
 TEST_F(DisplayStructTraitsTest, DefaultDisplayMode) {
-  // Prepare sample input with random values
-
   std::unique_ptr<DisplayMode> input =
-      base::MakeUnique<DisplayMode>(gfx::Size(15, 29), true, 61.0);
+      base::MakeUnique<DisplayMode>(gfx::Size(1024, 768), true, 61.0);
 
   mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
   std::unique_ptr<DisplayMode> output;
@@ -103,4 +123,100 @@ TEST_F(DisplayStructTraitsTest, DefaultDisplayMode) {
   EXPECT_EQ(input->refresh_rate(), output->refresh_rate());
 }
 
+TEST_F(DisplayStructTraitsTest, DisplayPlacementFlushAtTop) {
+  DisplayPlacement input;
+  input.display_id = kDisplayId1;
+  input.parent_display_id = kDisplayId2;
+  input.position = DisplayPlacement::TOP;
+  input.offset = 0;
+  input.offset_reference = DisplayPlacement::TOP_LEFT;
+
+  DisplayPlacement output;
+  GetTraitsTestProxy()->EchoDisplayPlacement(input, &output);
+
+  EXPECT_EQ(input, output);
+}
+
+TEST_F(DisplayStructTraitsTest, DisplayPlacementWithOffset) {
+  DisplayPlacement input;
+  input.display_id = kDisplayId1;
+  input.parent_display_id = kDisplayId2;
+  input.position = DisplayPlacement::BOTTOM;
+  input.offset = -100;
+  input.offset_reference = DisplayPlacement::BOTTOM_RIGHT;
+
+  DisplayPlacement output;
+  GetTraitsTestProxy()->EchoDisplayPlacement(input, &output);
+
+  EXPECT_EQ(input, output);
+}
+
+TEST_F(DisplayStructTraitsTest, DisplayLayoutTwoExtended) {
+  DisplayPlacement placement;
+  placement.display_id = kDisplayId1;
+  placement.parent_display_id = kDisplayId2;
+  placement.position = DisplayPlacement::RIGHT;
+  placement.offset = 0;
+  placement.offset_reference = DisplayPlacement::TOP_LEFT;
+
+  auto input = base::MakeUnique<DisplayLayout>();
+  input->placement_list.push_back(placement);
+  input->primary_id = kDisplayId2;
+  input->mirrored = false;
+  input->default_unified = true;
+
+  std::unique_ptr<DisplayLayout> output;
+  GetTraitsTestProxy()->EchoDisplayLayout(input->Copy(), &output);
+
+  CheckDisplayLayoutsEqual(*input, *output);
+}
+
+TEST_F(DisplayStructTraitsTest, DisplayLayoutThreeExtended) {
+  DisplayPlacement placement1;
+  placement1.display_id = kDisplayId2;
+  placement1.parent_display_id = kDisplayId1;
+  placement1.position = DisplayPlacement::LEFT;
+  placement1.offset = 0;
+  placement1.offset_reference = DisplayPlacement::TOP_LEFT;
+
+  DisplayPlacement placement2;
+  placement2.display_id = kDisplayId3;
+  placement2.parent_display_id = kDisplayId1;
+  placement2.position = DisplayPlacement::RIGHT;
+  placement2.offset = -100;
+  placement2.offset_reference = DisplayPlacement::BOTTOM_RIGHT;
+
+  auto input = base::MakeUnique<DisplayLayout>();
+  input->placement_list.push_back(placement1);
+  input->placement_list.push_back(placement2);
+  input->primary_id = kDisplayId1;
+  input->mirrored = false;
+  input->default_unified = false;
+
+  std::unique_ptr<DisplayLayout> output;
+  GetTraitsTestProxy()->EchoDisplayLayout(input->Copy(), &output);
+
+  CheckDisplayLayoutsEqual(*input, *output);
+}
+
+TEST_F(DisplayStructTraitsTest, DisplayLayoutTwoMirrored) {
+  DisplayPlacement placement;
+  placement.display_id = kDisplayId1;
+  placement.parent_display_id = kDisplayId2;
+  placement.position = DisplayPlacement::RIGHT;
+  placement.offset = 0;
+  placement.offset_reference = DisplayPlacement::TOP_LEFT;
+
+  auto input = base::MakeUnique<DisplayLayout>();
+  input->placement_list.push_back(placement);
+  input->primary_id = kDisplayId2;
+  input->mirrored = true;
+  input->default_unified = true;
+
+  std::unique_ptr<DisplayLayout> output;
+  GetTraitsTestProxy()->EchoDisplayLayout(input->Copy(), &output);
+
+  CheckDisplayLayoutsEqual(*input, *output);
+}
+
 }  // namespace display

ui/display/mojo/typemaps.gni

@@ -4,5 +4,6 @@
 
 typemaps = [
   "//ui/display/mojo/display.typemap",
+  "//ui/display/mojo/display_layout.typemap",
   "//ui/display/mojo/display_mode.typemap",
 ]