C bindings: Implement _DeepCopy() & some unittests.

mojo/public/c/bindings/tests/struct_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.
 
 // TODO(vardhan): Needs a lot more testing.
 
 #include "mojo/public/c/bindings/struct.h"
 
 #include <string.h>
 
 #include "mojo/public/c/bindings/array.h"
 #include "mojo/public/c/bindings/lib/util.h"
+#include "mojo/public/c/bindings/tests/testing_util.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "mojo/public/interfaces/bindings/tests/rect.mojom-c.h"
 #include "mojo/public/interfaces/bindings/tests/test_structs.mojom-c.h"
 #include "mojo/public/interfaces/bindings/tests/test_unions.mojom-c.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 #define BYTES_LEFT_AFTER_FIELD(type, field) \
   (sizeof(type) - offsetof(type, field))
@@ skipping 17 matching lines @@
                                                      const char* chars,
                                                      size_t num_chars) {
   struct MojomArrayHeader* arr = MojomArray_New(buf, num_chars, 1);
   assert(NULL != arr);
 
   memcpy((char*)arr + sizeof(MojomStringHeader), chars, num_chars);
   return (struct MojomStringHeader*)arr;
 }
 
 TEST(StructSerializedSizeTest, Basic) {
+  struct mojo_test_Rect rect = {{
+                                    sizeof(struct mojo_test_Rect), 0,
+                                },
+                                0u,
+                                0u,
+                                0u,
+                                0u};
+  size_t size = mojo_test_Rect_ComputeSerializedSize(&rect);
+  EXPECT_EQ(8U + 16U, size);
+
   char buffer_bytes[1000];
   struct MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
-  struct mojo_test_Rect* rect = MakeRect(&buf);
-
-  size_t size = mojo_test_Rect_ComputeSerializedSize(rect);
-  EXPECT_EQ(8U + 16U, size);
+  CopyAndCompare(&buf, &rect, sizeof(rect), mojo_test_Rect_DeepCopy,
+                 mojo_test_Rect_EncodePointersAndHandles,
+                 mojo_test_Rect_DecodePointersAndHandles);
 }
 
 TEST(StructSerializationTest, StructOfStructs) {
   char buffer_bytes[1000] = {0};
   struct MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
 
   struct mojo_test_RectPair* pair = static_cast<struct mojo_test_RectPair*>(
       MojomBuffer_Allocate(&buf, sizeof(struct mojo_test_RectPair)));
   *pair = mojo_test_RectPair{
       {sizeof(struct mojo_test_RectPair), 0},
       {MakeRect(&buf)},  // first
       {MakeRect(&buf)},  // second
   };
 
   EXPECT_EQ(8U + 16U + 2 * (8U + 16U),
             mojo_test_RectPair_ComputeSerializedSize(pair));
 
   // We save the underlying (unencoded) buffer. We can compare the two after
   // deserialization to make sure deserialization is correct.
   char buffer_bytes_copy[sizeof(buffer_bytes)];
   memcpy(buffer_bytes_copy, buffer_bytes, sizeof(buffer_bytes_copy));
 
-  struct MojomHandleBuffer handle_buf = {NULL, 0u, 0u};
-  mojo_test_RectPair_EncodePointersAndHandles(pair, buf.num_bytes_used,
-                                              &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+  mojo_test_RectPair_EncodePointersAndHandles(pair, buf.num_bytes_used, NULL);
 
   EXPECT_EQ(BYTES_LEFT_AFTER_FIELD(struct mojo_test_RectPair, first),
             pair->first.offset);
   EXPECT_EQ(BYTES_LEFT_AFTER_FIELD(struct mojo_test_RectPair, second) +
                 sizeof(struct mojo_test_Rect),
             pair->second.offset);
 
   mojo_test_RectPair_DecodePointersAndHandles(
       reinterpret_cast<struct mojo_test_RectPair*>(buf.buf), buf.num_bytes_used,
       NULL, 0);
   EXPECT_EQ(0, memcmp(buf.buf, buffer_bytes_copy, buf.num_bytes_used));
+
+  {
+    char buffer_bytes2[1000] = {0};
+    struct MojomBuffer buf2 = {buffer_bytes2, sizeof(buffer_bytes2), 0};
+    CopyAndCompare(&buf2, pair, buf.num_bytes_used, mojo_test_RectPair_DeepCopy,
+                   mojo_test_RectPair_EncodePointersAndHandles,
+                   mojo_test_RectPair_DecodePointersAndHandles);
+  }
 }
 
 // Tests a struct that has:
 //  - nullable string which isn't null.
 //  - nullable array of rects, which isn't null.
 TEST(StructSerializationTest, StructOfArrays) {
   char buffer_bytes[1000];
   MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
 
   const char* kRegionName = "region";
@@ skipping 31 matching lines @@
                 8U +        // name pointer
                 8U +        // rects pointer
                 8U +        // name header
                 8U +        // name payload (rounded up)
                 8U +        // rects header
                 4 * 8U +    // rects payload (four pointers)
                 4 * (8U +   // rect header
                      16U),  // rect payload (four ints)
             size);
 
-  char buffer_bytes_copy[sizeof(buffer_bytes)];
+  char buffer_bytes_copy[sizeof(buffer_bytes)] = {0};
   memcpy(buffer_bytes_copy, buffer_bytes, sizeof(buffer_bytes_copy));
 
-  struct MojomHandleBuffer handle_buf = {NULL, 0u, 0u};
-  mojo_test_NamedRegion_EncodePointersAndHandles(
-      named_region, buf.num_bytes_used, &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+  mojo_test_NamedRegion_EncodePointersAndHandles(named_region,
+                                                 buf.num_bytes_used, NULL);
 
   EXPECT_EQ(BYTES_LEFT_AFTER_FIELD(struct mojo_test_NamedRegion, name),
             named_region->name.offset);
   EXPECT_EQ(BYTES_LEFT_AFTER_FIELD(struct mojo_test_NamedRegion, rects) +
                 MOJOM_INTERNAL_ROUND_TO_8(sizeof(struct MojomStringHeader) +
                                           strlen(kRegionName)),
             named_region->rects.offset);
 
   // Test the offsets encoded inside the rect array.
   EXPECT_EQ(sizeof(union mojo_test_RectPtr) * 4,
             MOJOM_ARRAY_INDEX(rects, union mojo_test_RectPtr, 0)->offset);
   EXPECT_EQ(sizeof(union mojo_test_RectPtr) * 3 + sizeof(struct mojo_test_Rect),
             MOJOM_ARRAY_INDEX(rects, union mojo_test_RectPtr, 1)->offset);
   EXPECT_EQ(
       sizeof(union mojo_test_RectPtr) * 2 + sizeof(struct mojo_test_Rect) * 2,
       MOJOM_ARRAY_INDEX(rects, union mojo_test_RectPtr, 2)->offset);
   EXPECT_EQ(sizeof(union mojo_test_RectPtr) + sizeof(struct mojo_test_Rect) * 3,
             MOJOM_ARRAY_INDEX(rects, union mojo_test_RectPtr, 3)->offset);
 
   mojo_test_NamedRegion_DecodePointersAndHandles(
       reinterpret_cast<struct mojo_test_NamedRegion*>(buf.buf),
       buf.num_bytes_used, NULL, 0);
   EXPECT_EQ(0, memcmp(buf.buf, buffer_bytes_copy, buf.num_bytes_used));
+
+  {
+    char buffer_bytes2[sizeof(buffer_bytes)] = {0};
+    struct MojomBuffer buf2 = {buffer_bytes2, sizeof(buffer_bytes2), 0};
+    CopyAndCompare(&buf2, named_region, buf.num_bytes_used,
+                   mojo_test_NamedRegion_DeepCopy,
+                   mojo_test_NamedRegion_EncodePointersAndHandles,
+                   mojo_test_NamedRegion_DecodePointersAndHandles);
+  }
 }
 
 // Tests a struct that has:
 //  - nullable string which is null.
 //  - nullable array of rects, which is null.
 TEST(StructSerializationTest, StructOfNullArrays) {
   struct mojo_test_NamedRegion named_region = {
       // header
       {
           sizeof(struct mojo_test_NamedRegion), 0,
       },
       {NULL},
       {NULL},
   };
   struct mojo_test_NamedRegion named_region_copy = named_region;
 
   size_t size = mojo_test_NamedRegion_ComputeSerializedSize(&named_region);
   EXPECT_EQ(8U +      // header
                 8U +  // name pointer
                 8U,   // rects pointer
             size);
 
-  struct MojomHandleBuffer handle_buf = {NULL, 0u, 0u};
   mojo_test_NamedRegion_EncodePointersAndHandles(
-      &named_region, sizeof(struct mojo_test_NamedRegion), &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+      &named_region, sizeof(struct mojo_test_NamedRegion), NULL);
   EXPECT_EQ(0u, named_region.name.offset);
   EXPECT_EQ(0u, named_region.rects.offset);
 
   mojo_test_NamedRegion_DecodePointersAndHandles(
       &named_region, sizeof(struct mojo_test_NamedRegion), NULL, 0);
   EXPECT_EQ(0, memcmp(&named_region, &named_region_copy,
                       sizeof(struct mojo_test_NamedRegion)));
+
+  {
+    char buffer_bytes2[sizeof(named_region)] = {0};
+    struct MojomBuffer buf2 = {buffer_bytes2, sizeof(buffer_bytes2), 0};
+    CopyAndCompare(&buf2, &named_region, sizeof(named_region),
+                   mojo_test_NamedRegion_DeepCopy,
+                   mojo_test_NamedRegion_EncodePointersAndHandles,
+                   mojo_test_NamedRegion_DecodePointersAndHandles);
+  }
 }
 
 TEST(StructSerializationTest, StructOfUnion) {
   struct mojo_test_SmallStructNonNullableUnion u = {
       // header
       {
           sizeof(struct mojo_test_SmallStructNonNullableUnion),
           0,  // version
       },
       // PodUnion
@@ skipping 21 matching lines @@
   EXPECT_EQ(8U +      // header
                 16U,  // union
             mojo_test_SmallStructNonNullableUnion_ComputeSerializedSize(&u));
   EXPECT_EQ(
       8U +      // header
           16U,  // union
       mojo_test_SmallStructNonNullableUnion_ComputeSerializedSize(&u_null));
 
   // Encoding shouldn't have done anything to these structs (they have no
   // pointers or handles):
-  struct MojomHandleBuffer handle_buf = {NULL, 0u, 0u};
   struct mojo_test_SmallStructNonNullableUnion u_copy = u;
   mojo_test_SmallStructNonNullableUnion_EncodePointersAndHandles(
-      &u, sizeof(struct mojo_test_SmallStructNonNullableUnion), &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+      &u, sizeof(struct mojo_test_SmallStructNonNullableUnion), NULL);
   EXPECT_EQ(0, memcmp(&u, &u_copy, sizeof(u)));
 
   // Similarly, decoding shouldn't change the struct at all:
   mojo_test_SmallStructNonNullableUnion_DecodePointersAndHandles(
       &u, sizeof(struct mojo_test_SmallStructNonNullableUnion), NULL, 0);
   EXPECT_EQ(0, memcmp(&u, &u_copy, sizeof(u)));
 
   struct mojo_test_SmallStructNonNullableUnion u_null_copy = u_null;
   mojo_test_SmallStructNonNullableUnion_EncodePointersAndHandles(
-      &u_null, sizeof(struct mojo_test_SmallStructNonNullableUnion),
-      &handle_buf);
-  EXPECT_EQ(0u, handle_buf.num_handles_used);
+      &u_null, sizeof(struct mojo_test_SmallStructNonNullableUnion), NULL);
   EXPECT_EQ(0, memcmp(&u_null, &u_null_copy, sizeof(u_null)));
 
   mojo_test_SmallStructNonNullableUnion_DecodePointersAndHandles(
       &u_null, sizeof(struct mojo_test_SmallStructNonNullableUnion), NULL, 0);
   EXPECT_EQ(0, memcmp(&u_null, &u_null_copy, sizeof(u_null)));
+
+  {
+    char buffer_bytes[sizeof(u)] = {0};
+    struct MojomBuffer buf = {buffer_bytes, sizeof(buffer_bytes), 0};
+    CopyAndCompare(
+        &buf, &u, sizeof(u), mojo_test_SmallStructNonNullableUnion_DeepCopy,
+        mojo_test_SmallStructNonNullableUnion_EncodePointersAndHandles,
+        mojo_test_SmallStructNonNullableUnion_DecodePointersAndHandles);
+  }
 }
 
 TEST(StructSerializationTest, StructWithHandle) {
   struct mojo_test_NullableHandleStruct handle_struct =
       mojo_test_NullableHandleStruct{
           // header
           {
               sizeof(struct mojo_test_NullableHandleStruct), 0,
           },
           MOJO_HANDLE_INVALID,
@@ skipping 23 matching lines @@
       &handle_buf);
   EXPECT_EQ(1u, handle_buf.num_handles_used);
   EXPECT_EQ(static_cast<MojoHandle>(0), handle_struct.h);
   EXPECT_EQ(static_cast<MojoHandle>(123), handles[0]);
 
   mojo_test_NullableHandleStruct_DecodePointersAndHandles(
       &handle_struct, sizeof(struct mojo_test_NullableHandleStruct), handles,
       MOJO_ARRAYSIZE(handles));
   EXPECT_EQ(static_cast<MojoHandle>(123), handle_struct.h);
   EXPECT_EQ(MOJO_HANDLE_INVALID, handles[0]);
+
+  {
+    char buffer_bytes[1000] = {0};
+    struct MojomBuffer buf = {buffer_bytes, 4, 0};
+    auto* copied_struct =
+        mojo_test_NullableHandleStruct_DeepCopy(&buf, &handle_struct);
+    // Not enough space:
+    ASSERT_FALSE(copied_struct);
+    buf.buf_size = sizeof(buffer_bytes);
+    copied_struct =
+        mojo_test_NullableHandleStruct_DeepCopy(&buf, &handle_struct);
+    ASSERT_TRUE(copied_struct);
+    // The old and the new copy should both have the handles.
+    EXPECT_EQ(static_cast<MojoHandle>(123), handle_struct.h);
+    EXPECT_EQ(static_cast<MojoHandle>(123), copied_struct->h);
+  }
 }
 
 }  // namespace