Write mojom and StructTraits for DisplaySnapshot.

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/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_mode_struct_traits.h"
+#include "ui/display/mojo/display_snapshot_mojo.h"
 #include "ui/display/mojo/display_struct_traits_test.mojom.h"
+#include "ui/display/types/display_constants.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;
@@ skipping 13 matching lines @@
   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));
   }
@@ skipping 47 matching lines @@
   input.set_touch_support(Display::TOUCH_SUPPORT_AVAILABLE);
   input.set_maximum_cursor_size(maximum_cursor_size);
 
   Display 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(1024, 768), true, 61.0);
 
   mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
   std::unique_ptr<DisplayMode> output;
-
   proxy->EchoDisplayMode(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) {
@@ skipping 85 matching lines @@
   input->primary_id = kDisplayId2;
   input->mirrored = true;
   input->default_unified = true;
 
   std::unique_ptr<DisplayLayout> output;
   GetTraitsTestProxy()->EchoDisplayLayout(input->Copy(), &output);
 
   CheckDisplayLayoutsEqual(*input, *output);
 }
 
+static bool compareDisplayMode(const DisplayMode& display_mode_a,
+                               const DisplayMode& display_mode_b) {
+  if ((display_mode_a.size() != display_mode_b.size()) ||
+      (display_mode_a.is_interlaced() != display_mode_b.is_interlaced()) ||
+      (display_mode_a.refresh_rate() != display_mode_b.refresh_rate()))
+    return false;
+  return true;
+}
+
+TEST_F(DisplayStructTraitsTest, DefaultDisplaySnapshotMojo) {
+  mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
+
+  // prepare sample input with random values
+  int64_t display_id = 7;
+  const gfx::Point origin(3, 12);
+  const gfx::Size physical_size(15, 29);
+  DisplayConnectionType type = display::DISPLAY_CONNECTION_TYPE_HDMI;
+  bool is_aspect_preserving_scaling = true;
+  bool has_overscan = true;
+  bool has_color_correction_matrix = true;
+  std::string display_name("whatever display_name");
+
+  base::FilePath::StringType string_type_path = FILE_PATH_LITERAL("a/b/c");
+  const base::FilePath::StringPieceType string_piece_path(string_type_path);
+  const base::FilePath sys_path(string_piece_path);
+
+  int64_t product_id = 19;
+
+  DisplayMode display_mode_1(gfx::Size(11, 12), true, 111.0);
+  DisplayMode display_current_mode(gfx::Size(22, 23), true, 222.0);
+  DisplayMode display_native_mode(gfx::Size(33, 34), true, 333.0);
+  DisplayMode display_mode_2(gfx::Size(44, 45), true, 444.0);
+
+  display::DisplaySnapshot::DisplayModeList modes;
+  modes.reserve(4);
+  modes.push_back(display_mode_1.Clone());
+  modes.push_back(display_current_mode.Clone());
+  modes.push_back(display_native_mode.Clone());
+  modes.push_back(display_mode_2.Clone());
+
+  const DisplayMode* current_mode = modes[1].get();
+  const DisplayMode* native_mode = modes[2].get();
+
+  display::DisplaySnapshot::DisplayModeList expected_modes;
+  expected_modes.reserve(4);
+  expected_modes.push_back(display_mode_1.Clone());
+  expected_modes.push_back(display_current_mode.Clone());
+  expected_modes.push_back(display_native_mode.Clone());
+  expected_modes.push_back(display_mode_2.Clone());
+
+  const std::vector<uint8_t> edid{1, 2, 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);
+  std::unique_ptr<DisplaySnapshotMojo> output;
+  proxy->EchoDisplaySnapshotMojo(std::move(input), &output);
+
+  // We want to test each component individually to make sure each data member
+  // was correctly serialized and deserialized.
+  EXPECT_EQ(display_id, output->display_id());
+  EXPECT_EQ(origin, output->origin());
+  EXPECT_EQ(physical_size, output->physical_size());
+  EXPECT_EQ(type, output->type());
+  EXPECT_EQ(is_aspect_preserving_scaling,
+            output->is_aspect_preserving_scaling());
+  EXPECT_EQ(has_overscan, output->has_overscan());
+  EXPECT_EQ(has_color_correction_matrix, output->has_color_correction_matrix());
+  EXPECT_EQ(display_name, output->display_name());
+  EXPECT_EQ(sys_path, output->sys_path());
+  EXPECT_EQ(product_id, output->product_id());
+
+  EXPECT_EQ(4, (int)output->modes().size());
+  for (int i = 0; i < (int)expected_modes.size(); i++) {
+    EXPECT_EQ(true, compareDisplayMode(*expected_modes[i].get(),
+                                       *output->modes()[i].get()));
+  }
+  EXPECT_EQ(edid, output->edid());
+  EXPECT_EQ(true,
+            compareDisplayMode(display_current_mode, *output->current_mode()));
+  EXPECT_EQ(true,
+            compareDisplayMode(display_native_mode, *output->native_mode()));
+}
+
 }  // namespace display