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/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/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 17 matching lines @@
 
 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);
 }
 
+void CheckDisplaySnapShotMojoEqual(const DisplaySnapshotMojo& input,
+                                   const DisplaySnapshotMojo& output) {
+  // We want to test each component individually to make sure each data member
+  // was correctly serialized and deserialized.
+  EXPECT_NE(&input, &output);  // Make sure they aren't the same object.
+  EXPECT_EQ(input.display_id(), output.display_id());
+  EXPECT_EQ(input.origin(), output.origin());
+  EXPECT_EQ(input.physical_size(), output.physical_size());
+  EXPECT_EQ(input.type(), output.type());
+  EXPECT_EQ(input.is_aspect_preserving_scaling(),
+            output.is_aspect_preserving_scaling());
+  EXPECT_EQ(input.has_overscan(), output.has_overscan());
+  EXPECT_EQ(input.has_color_correction_matrix(),
+            output.has_color_correction_matrix());
+  EXPECT_EQ(input.display_name(), output.display_name());
+  EXPECT_EQ(input.sys_path(), output.sys_path());
+  EXPECT_EQ(input.product_id(), output.product_id());
+  EXPECT_EQ(input.modes().size(), output.modes().size());
+
+  for (size_t i = 0; i < input.modes().size(); i++)
+    EXPECT_EQ(*input.modes()[i], *output.modes()[i]);
+
+  EXPECT_EQ(input.edid(), output.edid());
+
+  EXPECT_EQ(true, (nullptr == output.current_mode()) &&

[kylechar, 2017/02/14 21:35:28]

So in general if you want to expect something is true you do the following:

EXPECT_TRUE(<code>);

Even with that change this would be difficult to read. Maybe something like:

if (!input.current_mode())
  EXPECT_EQ(nullptr, output.current_mode();
else
  EXPECT_EQ(*input.current_mode(), *output.current_mode());

[thanhph1, 2017/02/15 15:37:56]

Done.

+                          (nullptr == input.current_mode()) ||
+                      *input.current_mode() == *output.current_mode());
+  EXPECT_EQ(true, ((nullptr == output.native_mode()) &&
+                   (nullptr == input.native_mode())) ||
+                      (*input.native_mode() == *output.native_mode()));
+
+  EXPECT_EQ(input.maximum_cursor_size(), output.maximum_cursor_size());
+}
+
 }  // namespace
 
 TEST_F(DisplayStructTraitsTest, DefaultDisplayValues) {
   Display input(5);
 
   Display output;
   GetTraitsTestProxy()->EchoDisplay(input, &output);
 
   CheckDisplaysEqual(input, output);
 }
@@ skipping 121 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);
 }
 
+// One display mode, current and native mode nullptr.
+TEST_F(DisplayStructTraitsTest, DisplaySnapshotMojoNullBothIndexPointer) {
+  mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();

[kylechar, 2017/02/14 21:35:28]

You should create this near where you use it. Although, it's easy enough to just
do:

GetTraitsTestProxy()->EchoDisplaySnapshotMojo(...);

[thanhph1, 2017/02/15 15:37:56]

Done.

+
+  // 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;
+  const std::string display_name("whatever display_name");
+  const base::FilePath::StringType string_type_path = FILE_PATH_LITERAL("a/cb");
+  const base::FilePath::StringPieceType string_piece_path(string_type_path);
+  const base::FilePath sys_path(string_piece_path);

[kylechar, 2017/02/14 21:35:28]

Are you just trying to create a FilePath object with these three lines? You can
just do something like:

base::FilePath sys_path = base::FilePath::FromUTF8Unsafe("/a/b/c");

ASCII is valid UTF8 so it should work fine.

[thanhph1, 2017/02/15 15:37:56]

Done.

+  const int64_t product_id = 19;
+
+  const DisplayMode display_mode(gfx::Size(13, 11), true, 1211.0);
+
+  display::DisplaySnapshot::DisplayModeList modes;
+  modes.push_back(display_mode.Clone());
+
+  const DisplayMode* current_mode = nullptr;
+  const DisplayMode* native_mode = nullptr;
+
+  display::DisplaySnapshot::DisplayModeList expected_modes;
+  expected_modes.push_back(display_mode.Clone());
+
+  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);
+
+  const DisplayMode* expected_current_mode = nullptr;
+  const DisplayMode* expected_native_mode = nullptr;
+
+  // Similar object as |input|. |expected_input| is used for later comparison.
+  std::unique_ptr<DisplaySnapshotMojo> expected_input =

[kylechar, 2017/02/14 21:35:28]

I'm not a big fan of this.

[thanhph1, 2017/02/15 15:37:56]

I added a Clone() for DisplaySnapshotMojo and able to cut down some lines here.

+      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(expected_modes), edid, expected_current_mode,
+          expected_native_mode, maximum_cursor_size);
+
+  std::unique_ptr<DisplaySnapshotMojo> output;
+  proxy->EchoDisplaySnapshotMojo(std::move(input), &output);
+
+  CheckDisplaySnapShotMojoEqual(*expected_input, *output);
+}
+
+// One display mode that is the native mode and no current mode.
+TEST_F(DisplayStructTraitsTest, DisplaySnapshotMojoNullOneIndexPointer) {
+  mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
+
+  // 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");
+  const base::FilePath::StringType string_type_path = FILE_PATH_LITERAL("z/b");
+  const base::FilePath::StringPieceType string_piece_path(string_type_path);
+  const base::FilePath sys_path(string_piece_path);
+  const int64_t product_id = 9;
+
+  const DisplayMode display_mode_1(gfx::Size(13, 11), true, 1211.0);
+
+  display::DisplaySnapshot::DisplayModeList modes;
+  modes.push_back(display_mode_1.Clone());
+
+  const DisplayMode* current_mode = modes[0].get();
+  const DisplayMode* native_mode = nullptr;
+
+  display::DisplaySnapshot::DisplayModeList expected_modes;
+  expected_modes.push_back(display_mode_1.Clone());
+
+  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);
+
+  const DisplayMode* expected_current_mode = expected_modes[0].get();
+  const DisplayMode* expected_native_mode = nullptr;
+
+  // Similar object as |input|. |expected_input| is used for later comparison.
+  std::unique_ptr<DisplaySnapshotMojo> expected_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(expected_modes), edid, expected_current_mode,
+          expected_native_mode, maximum_cursor_size);
+
+  std::unique_ptr<DisplaySnapshotMojo> output;
+  proxy->EchoDisplaySnapshotMojo(std::move(input), &output);
+
+  CheckDisplaySnapShotMojoEqual(*expected_input, *output);
+}
+
+// Multiple display modes, both native and current mode set.
+TEST_F(DisplayStructTraitsTest, DisplaySnapshotMojoDefault) {
+  mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
+
+  // prepare sample input with random values
+  const int64_t display_id = 73;
+  const gfx::Point origin(33, 126);
+  const gfx::Size physical_size(152, 294);
+  const gfx::Size maximum_cursor_size(320, 353);
+  const DisplayConnectionType type = display::DISPLAY_CONNECTION_TYPE_HDMI;
+  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");
+  const base::FilePath::StringType string_type_path = FILE_PATH_LITERAL("a/cb");
+  const base::FilePath::StringPieceType string_piece_path(string_type_path);
+  const base::FilePath sys_path(string_piece_path);
+  const int64_t product_id = 139;
+
+  const DisplayMode display_mode_1(gfx::Size(11, 12), true, 111.0);
+  const DisplayMode display_current_mode(gfx::Size(22, 23), true, 222.0);
+  const DisplayMode display_native_mode(gfx::Size(33, 34), true, 333.0);
+  const DisplayMode display_mode_2(gfx::Size(44, 45), true, 444.0);
+
+  display::DisplaySnapshot::DisplayModeList modes;
+  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.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 = {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);
+
+  const DisplayMode* expected_current_mode = expected_modes[1].get();
+  const DisplayMode* expected_native_mode = expected_modes[2].get();
+
+  // Similar object as |input|. |expected_input| is used for later comparison.
+  std::unique_ptr<DisplaySnapshotMojo> expected_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(expected_modes), edid, expected_current_mode,
+          expected_native_mode, maximum_cursor_size);
+
+  std::unique_ptr<DisplaySnapshotMojo> output;
+  proxy->EchoDisplaySnapshotMojo(std::move(input), &output);
+
+  CheckDisplaySnapShotMojoEqual(*expected_input, *output);
+}
+
+// Tests for both internal display and external display.
+TEST_F(DisplayStructTraitsTest, DisplaySnapshotMojoInternalDisplay) {
+  mojom::DisplayStructTraitsTestPtr proxy = GetTraitsTestProxy();
+
+  // prepare sample input with random values
+  const int64_t display_id = 17;
+  const gfx::Point origin(31, 2);
+  const gfx::Size physical_size(215, 219);
+  const gfx::Size maximum_cursor_size(330, 351);
+  const DisplayConnectionType type = display::DISPLAY_CONNECTION_TYPE_INTERNAL;
+  const bool is_aspect_preserving_scaling = true;
+  const bool has_overscan = true;
+  const bool has_color_correction_matrix = true;
+  const std::string display_name("display_name");
+  const base::FilePath::StringType string_type_path = FILE_PATH_LITERAL("c/a");
+  const base::FilePath::StringPieceType string_piece_path(string_type_path);
+  const base::FilePath sys_path(string_piece_path);
+  const int64_t product_id = 139;
+
+  const DisplayMode display_mode(gfx::Size(11, 12), true, 111.0);
+
+  display::DisplaySnapshot::DisplayModeList modes;
+  modes.push_back(display_mode.Clone());
+
+  const DisplayMode* current_mode = modes[0].get();
+  const DisplayMode* native_mode = modes[0].get();
+
+  display::DisplaySnapshot::DisplayModeList expected_modes;
+  expected_modes.push_back(display_mode.Clone());
+
+  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);
+
+  const DisplayMode* expected_current_mode = expected_modes[0].get();
+  const DisplayMode* expected_native_mode = expected_modes[0].get();
+
+  // Similar object as |input|. |expected_input| is used for later comparison.
+  std::unique_ptr<DisplaySnapshotMojo> expected_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(expected_modes), edid, expected_current_mode,
+          expected_native_mode, maximum_cursor_size);
+
+  std::unique_ptr<DisplaySnapshotMojo> output;
+  proxy->EchoDisplaySnapshotMojo(std::move(input), &output);
+
+  CheckDisplaySnapShotMojoEqual(*expected_input, *output);
+}
+
 }  // namespace display