Remove DisplayStructTraitsTest interface.

ui/display/mojo/display_struct_traits_unittest.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 <memory>
 
 #include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#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/mojo/display_layout_struct_traits.h"
+#include "ui/display/mojo/display_mode_struct_traits.h"
+#include "ui/display/mojo/display_snapshot_mojo_struct_traits.h"
+#include "ui/display/mojo/display_struct_traits.h"
+#include "ui/display/mojo/gamma_ramp_rgb_entry_struct_traits.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot_mojo.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.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:
-  DisplayStructTraitsTest() {}
-
- protected:
-  mojom::DisplayStructTraitsTestPtr GetTraitsTestProxy() {
-    return traits_test_bindings_.CreateInterfacePtrAndBind(this);
-  }
-
- private:
-  // mojom::DisplayStructTraitsTest:
-  void EchoDisplay(const Display& in,
-                   const EchoDisplayCallback& callback) override {
-    callback.Run(in);
-  }
-
-  void EchoDisplayMode(std::unique_ptr<DisplayMode> in,
-                       const EchoDisplayModeCallback& callback) override {
-    callback.Run(std::move(in));
-  }
-
-  void EchoDisplaySnapshotMojo(
-      std::unique_ptr<DisplaySnapshotMojo> in,
-      const EchoDisplaySnapshotMojoCallback& callback) override {
-    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));
-  }
-
-  void EchoHDCPState(display::HDCPState in,
-                     const EchoHDCPStateCallback& callback) override {
-    callback.Run(in);
-  }
-
-  void EchoGammaRampRGBEntry(
-      const GammaRampRGBEntry& in,
-      const EchoGammaRampRGBEntryCallback& callback) override {
-    callback.Run(in);
-  }
-
-  base::MessageLoop loop_;  // A MessageLoop is needed for Mojo IPC to work.
-  mojo::BindingSet<mojom::DisplayStructTraitsTest> traits_test_bindings_;
-
-  DISALLOW_COPY_AND_ASSIGN(DisplayStructTraitsTest);
-};
-
 void CheckDisplaysEqual(const Display& input, const Display& output) {
   EXPECT_NE(&input, &output);  // Make sure they aren't the same object.
   EXPECT_EQ(input.id(), output.id());
   EXPECT_EQ(input.bounds(), output.bounds());
   EXPECT_EQ(input.work_area(), output.work_area());
   EXPECT_EQ(input.device_scale_factor(), output.device_scale_factor());
   EXPECT_EQ(input.rotation(), output.rotation());
   EXPECT_EQ(input.touch_support(), output.touch_support());
   EXPECT_EQ(input.maximum_cursor_size(), output.maximum_cursor_size());
 }
@@ skipping 43 matching lines @@
     EXPECT_TRUE(CompareModes(*input.current_mode(), *output.current_mode()));
 
   if (!input.native_mode())
     EXPECT_EQ(nullptr, output.native_mode());
   else
     EXPECT_TRUE(CompareModes(*input.native_mode(), *output.native_mode()));
 
   EXPECT_EQ(input.maximum_cursor_size(), output.maximum_cursor_size());
 }
 
+// Test StructTrait serialization and deserialization for copyable type. |input|
+// will be serialized and then deserialized into |output|.
+template <class MojomType, class Type>
+void SerializeAndDeserialize(const Type& input, Type* output) {
+  MojomType::Deserialize(MojomType::Serialize(&input), output);
+}
+
+// Test StructTrait serialization and deserialization for move only type.
+// |input| will be serialized and then deserialized into |output|.
+template <class MojomType, class Type>
+void SerializeAndDeserialize(Type&& input, Type* output) {
+  MojomType::Deserialize(MojomType::Serialize(&input), output);
+}
 }  // namespace
 
-TEST_F(DisplayStructTraitsTest, DefaultDisplayValues) {
+TEST(DisplayStructTraitsTest, DefaultDisplayValues) {
   Display input(5);
 
   Display output;
-  GetTraitsTestProxy()->EchoDisplay(input, &output);
+  SerializeAndDeserialize<mojom::Display>(input, &output);
 
   CheckDisplaysEqual(input, output);
 }
 
-TEST_F(DisplayStructTraitsTest, SetAllDisplayValues) {
+TEST(DisplayStructTraitsTest, SetAllDisplayValues) {
   const gfx::Rect bounds(100, 200, 500, 600);
   const gfx::Rect work_area(150, 250, 400, 500);
   const gfx::Size maximum_cursor_size(64, 64);
 
   Display input(246345234, bounds);
   input.set_work_area(work_area);
   input.set_device_scale_factor(2.0f);
   input.set_rotation(Display::ROTATE_270);
   input.set_touch_support(Display::TOUCH_SUPPORT_AVAILABLE);
   input.set_maximum_cursor_size(maximum_cursor_size);
 
   Display output;
-  GetTraitsTestProxy()->EchoDisplay(input, &output);
+  SerializeAndDeserialize<mojom::Display>(input, &output);
 
   CheckDisplaysEqual(input, output);
 }
 
-TEST_F(DisplayStructTraitsTest, DefaultDisplayMode) {
+TEST(DisplayStructTraitsTest, DefaultDisplayMode) {
   std::unique_ptr<DisplayMode> input =
       base::MakeUnique<DisplayMode>(gfx::Size(1024, 768), true, 61.0);
 
-  mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
   std::unique_ptr<DisplayMode> output;
-
-  proxy->EchoDisplayMode(input->Clone(), &output);
+  SerializeAndDeserialize<mojom::DisplayMode>(input->Clone(), &output);
 
   // We want to test each component individually to make sure each data member
   // was correctly serialized and deserialized.
   EXPECT_EQ(input->size(), output->size());
   EXPECT_EQ(input->is_interlaced(), output->is_interlaced());
   EXPECT_EQ(input->refresh_rate(), output->refresh_rate());
 }
 
-TEST_F(DisplayStructTraitsTest, DisplayPlacementFlushAtTop) {
+TEST(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);
+  SerializeAndDeserialize<mojom::DisplayPlacement>(input, &output);
 
   EXPECT_EQ(input, output);
 }
 
-TEST_F(DisplayStructTraitsTest, DisplayPlacementWithOffset) {
+TEST(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);
+  SerializeAndDeserialize<mojom::DisplayPlacement>(input, &output);
 
   EXPECT_EQ(input, output);
 }
 
-TEST_F(DisplayStructTraitsTest, DisplayLayoutTwoExtended) {
+TEST(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);
+  SerializeAndDeserialize<mojom::DisplayLayout>(input->Copy(), &output);
 
   CheckDisplayLayoutsEqual(*input, *output);
 }
 
-TEST_F(DisplayStructTraitsTest, DisplayLayoutThreeExtended) {
+TEST(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);
+  SerializeAndDeserialize<mojom::DisplayLayout>(input->Copy(), &output);
 
   CheckDisplayLayoutsEqual(*input, *output);
 }
 
-TEST_F(DisplayStructTraitsTest, DisplayLayoutTwoMirrored) {
+TEST(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);
+  SerializeAndDeserialize<mojom::DisplayLayout>(input->Copy(), &output);
 
   CheckDisplayLayoutsEqual(*input, *output);
 }
 
-TEST_F(DisplayStructTraitsTest, BasicGammaRampRGBEntry) {
+TEST(DisplayStructTraitsTest, BasicGammaRampRGBEntry) {
   const GammaRampRGBEntry input{259, 81, 16};
 
   GammaRampRGBEntry output;
-  GetTraitsTestProxy()->EchoGammaRampRGBEntry(input, &output);
+  SerializeAndDeserialize<mojom::GammaRampRGBEntry>(input, &output);
 
   EXPECT_EQ(input.r, output.r);
   EXPECT_EQ(input.g, output.g);
   EXPECT_EQ(input.b, output.b);
 }
 
 // One display mode, current and native mode nullptr.
-TEST_F(DisplayStructTraitsTest, DisplaySnapshotCurrentAndNativeModesNull) {
+TEST(DisplayStructTraitsTest, DisplaySnapshotCurrentAndNativeModesNull) {
   // Prepare sample input with random values.
   const int64_t display_id = 7;
   const gfx::Point origin(1, 2);
   const gfx::Size physical_size(5, 9);
   const gfx::Size maximum_cursor_size(3, 5);
   const DisplayConnectionType type =
       display::DISPLAY_CONNECTION_TYPE_DISPLAYPORT;
   const bool is_aspect_preserving_scaling = true;
   const bool has_overscan = true;
   const bool has_color_correction_matrix = true;
@@ skipping 11 matching lines @@
   const std::vector<uint8_t> edid = {1};
 
   std::unique_ptr<DisplaySnapshotMojo> input =
       base::MakeUnique<DisplaySnapshotMojo>(
           display_id, origin, physical_size, type, is_aspect_preserving_scaling,
           has_overscan, has_color_correction_matrix, display_name, sys_path,
           product_id, std::move(modes), edid, current_mode, native_mode,
           maximum_cursor_size);
 
   std::unique_ptr<DisplaySnapshotMojo> output;
-  GetTraitsTestProxy()->EchoDisplaySnapshotMojo(
+  SerializeAndDeserialize<mojom::DisplaySnapshotMojo>(
       DisplaySnapshotMojo::CreateFrom(*input), &output);
 
   CheckDisplaySnapShotMojoEqual(*input, *output);
 }
 
 // One display mode that is the native mode and no current mode.
-TEST_F(DisplayStructTraitsTest, DisplaySnapshotCurrentModeNull) {
+TEST(DisplayStructTraitsTest, DisplaySnapshotCurrentModeNull) {
   // Prepare sample input with random values.
   const int64_t display_id = 6;
   const gfx::Point origin(11, 32);
   const gfx::Size physical_size(55, 49);
   const gfx::Size maximum_cursor_size(13, 95);
   const DisplayConnectionType type = display::DISPLAY_CONNECTION_TYPE_VGA;
   const bool is_aspect_preserving_scaling = true;
   const bool has_overscan = true;
   const bool has_color_correction_matrix = true;
   const std::string display_name("whatever display_name");
@@ skipping 10 matching lines @@
   const std::vector<uint8_t> edid = {1};
 
   std::unique_ptr<DisplaySnapshotMojo> input =
       base::MakeUnique<DisplaySnapshotMojo>(
           display_id, origin, physical_size, type, is_aspect_preserving_scaling,
           has_overscan, has_color_correction_matrix, display_name, sys_path,
           product_id, std::move(modes), edid, current_mode, native_mode,
           maximum_cursor_size);
 
   std::unique_ptr<DisplaySnapshotMojo> output;
-  GetTraitsTestProxy()->EchoDisplaySnapshotMojo(
+  SerializeAndDeserialize<mojom::DisplaySnapshotMojo>(
       DisplaySnapshotMojo::CreateFrom(*input), &output);
 
   CheckDisplaySnapShotMojoEqual(*input, *output);
 }
 
 // Multiple display modes, both native and current mode set.
-TEST_F(DisplayStructTraitsTest, DisplaySnapshotExternal) {
+TEST(DisplayStructTraitsTest, DisplaySnapshotExternal) {
   // Prepare sample input from external display.
   const int64_t display_id = 9834293210466051;
   const gfx::Point origin(0, 1760);
   const gfx::Size physical_size(520, 320);
   const gfx::Size maximum_cursor_size(4, 5);
   const DisplayConnectionType type = display::DISPLAY_CONNECTION_TYPE_HDMI;
   const bool is_aspect_preserving_scaling = false;
   const bool has_overscan = false;
   const bool has_color_correction_matrix = false;
   const std::string display_name("HP Z24i");
@@ skipping 14 matching lines @@
   const std::vector<uint8_t> edid = {2, 3, 4, 5};
 
   std::unique_ptr<DisplaySnapshotMojo> input =
       base::MakeUnique<DisplaySnapshotMojo>(
           display_id, origin, physical_size, type, is_aspect_preserving_scaling,
           has_overscan, has_color_correction_matrix, display_name, sys_path,
           product_id, std::move(modes), edid, current_mode, native_mode,
           maximum_cursor_size);
 
   std::unique_ptr<DisplaySnapshotMojo> output;
-  GetTraitsTestProxy()->EchoDisplaySnapshotMojo(
+  SerializeAndDeserialize<mojom::DisplaySnapshotMojo>(
       DisplaySnapshotMojo::CreateFrom(*input), &output);
 
   CheckDisplaySnapShotMojoEqual(*input, *output);
 }
 
-TEST_F(DisplayStructTraitsTest, DisplaySnapshotInternal) {
+TEST(DisplayStructTraitsTest, DisplaySnapshotInternal) {
   // Prepare sample input from Pixel's internal display.
   const int64_t display_id = 13761487533244416;
   const gfx::Point origin(0, 0);
   const gfx::Size physical_size(270, 180);
   const gfx::Size maximum_cursor_size(64, 64);
   const DisplayConnectionType type = display::DISPLAY_CONNECTION_TYPE_INTERNAL;
   const bool is_aspect_preserving_scaling = true;
   const bool has_overscan = false;
   const bool has_color_correction_matrix = false;
   const std::string display_name("");
@@ skipping 10 matching lines @@
   const std::vector<uint8_t> edid = {2, 3};
 
   std::unique_ptr<DisplaySnapshotMojo> input =
       base::MakeUnique<DisplaySnapshotMojo>(
           display_id, origin, physical_size, type, is_aspect_preserving_scaling,
           has_overscan, has_color_correction_matrix, display_name, sys_path,
           product_id, std::move(modes), edid, current_mode, native_mode,
           maximum_cursor_size);
 
   std::unique_ptr<DisplaySnapshotMojo> output;
-  GetTraitsTestProxy()->EchoDisplaySnapshotMojo(
+  SerializeAndDeserialize<mojom::DisplaySnapshotMojo>(
       DisplaySnapshotMojo::CreateFrom(*input), &output);
 
   CheckDisplaySnapShotMojoEqual(*input, *output);
 }
 
-TEST_F(DisplayStructTraitsTest, HDCPStateBasic) {
-  const display::HDCPState input(HDCP_STATE_ENABLED);
-  display::HDCPState output;
-  GetTraitsTestProxy()->EchoHDCPState(input, &output);
-  EXPECT_EQ(input, output);
-}
-
 }  // namespace display