Mojo C++ bindings: share DataView class between chromium and blink variants.

mojo/public/cpp/bindings/tests/struct_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
 
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
@@ skipping 32 matching lines @@
   (*output->f_array)[2] = 8;
   MessagePipe pipe;
   output->f_message_pipe = std::move(pipe.handle0);
   output->f_int16 = 42;
 
   return output;
 }
 
 template <typename U, typename T>
 U SerializeAndDeserialize(T input) {
-  using InputDataType = typename mojo::internal::MojomTypeTraits<T>::Data*;
-  using OutputDataType = typename mojo::internal::MojomTypeTraits<U>::Data*;
+  using InputMojomType = typename T::Struct::DataView;
+  using OutputMojomType = typename U::Struct::DataView;
+
+  using InputDataType =
+      typename mojo::internal::MojomTypeTraits<InputMojomType>::Data*;
+  using OutputDataType =
+      typename mojo::internal::MojomTypeTraits<OutputMojomType>::Data*;
 
   mojo::internal::SerializationContext context;
-  size_t size = mojo::internal::PrepareToSerialize<T>(input, &context);
+  size_t size =
+      mojo::internal::PrepareToSerialize<InputMojomType>(input, &context);
   mojo::internal::FixedBufferForTesting buf(size + 32);
   InputDataType data;
-  mojo::internal::Serialize<T>(input, &buf, &data, &context);
+  mojo::internal::Serialize<InputMojomType>(input, &buf, &data, &context);
 
   // Set the subsequent area to a special value, so that we can find out if we
   // mistakenly access the area.
   void* subsequent_area = buf.Allocate(32);
   memset(subsequent_area, 0xAA, 32);
 
   OutputDataType output_data = reinterpret_cast<OutputDataType>(data);
 
   U output;
-  mojo::internal::Deserialize<U>(output_data, &output, &context);
+  mojo::internal::Deserialize<OutputMojomType>(output_data, &output, &context);
   return std::move(output);
 }
 
 using StructTest = testing::Test;
 
 }  // namespace
 
 TEST_F(StructTest, Rect) {
   RectPtr rect;
   EXPECT_TRUE(rect.is_null());
@@ skipping 43 matching lines @@
   // NoDefaultFieldValues contains handles, so Clone() is not available, but
   // NoDefaultFieldValuesPtr should still compile.
   NoDefaultFieldValuesPtr no_default_field_values(NoDefaultFieldValues::New());
   EXPECT_FALSE(no_default_field_values->f13.is_valid());
 }
 
 // Serialization test of a struct with no pointer or handle members.
 TEST_F(StructTest, Serialization_Basic) {
   RectPtr rect(MakeRect());
 
-  size_t size = mojo::internal::PrepareToSerialize<RectPtr>(rect, nullptr);
+  size_t size = mojo::internal::PrepareToSerialize<RectDataView>(rect, nullptr);
   EXPECT_EQ(8U + 16U, size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::Rect_Data* data;
-  mojo::internal::Serialize<RectPtr>(rect, &buf, &data, nullptr);
+  mojo::internal::Serialize<RectDataView>(rect, &buf, &data, nullptr);
 
   RectPtr rect2;
-  mojo::internal::Deserialize<RectPtr>(data, &rect2, nullptr);
+  mojo::internal::Deserialize<RectDataView>(data, &rect2, nullptr);
 
   CheckRect(*rect2);
 }
 
 // Construction of a struct with struct pointers from null.
 TEST_F(StructTest, Construction_StructPointers) {
   RectPairPtr pair;
   EXPECT_TRUE(pair.is_null());
 
   pair = RectPair::New();
   EXPECT_FALSE(pair.is_null());
   EXPECT_TRUE(pair->first.is_null());
   EXPECT_TRUE(pair->first.is_null());
 
   pair = nullptr;
   EXPECT_TRUE(pair.is_null());
 }
 
 // Serialization test of a struct with struct pointers.
 TEST_F(StructTest, Serialization_StructPointers) {
   RectPairPtr pair(RectPair::New());
   pair->first = MakeRect();
   pair->second = MakeRect();
 
-  size_t size = mojo::internal::PrepareToSerialize<RectPairPtr>(pair, nullptr);
+  size_t size =
+      mojo::internal::PrepareToSerialize<RectPairDataView>(pair, nullptr);
   EXPECT_EQ(8U + 16U + 2 * (8U + 16U), size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::RectPair_Data* data;
-  mojo::internal::Serialize<RectPairPtr>(pair, &buf, &data, nullptr);
+  mojo::internal::Serialize<RectPairDataView>(pair, &buf, &data, nullptr);
 
   RectPairPtr pair2;
-  mojo::internal::Deserialize<RectPairPtr>(data, &pair2, nullptr);
+  mojo::internal::Deserialize<RectPairDataView>(data, &pair2, nullptr);
 
   CheckRect(*pair2->first);
   CheckRect(*pair2->second);
 }
 
 // Serialization test of a struct with an array member.
 TEST_F(StructTest, Serialization_ArrayPointers) {
   NamedRegionPtr region(NamedRegion::New());
   region->name.emplace("region");
   region->rects.emplace(4);
   for (size_t i = 0; i < region->rects->size(); ++i)
     (*region->rects)[i] = MakeRect(static_cast<int32_t>(i) + 1);
 
   size_t size =
-      mojo::internal::PrepareToSerialize<NamedRegionPtr>(region, nullptr);
+      mojo::internal::PrepareToSerialize<NamedRegionDataView>(region, nullptr);
   EXPECT_EQ(8U +            // header
                 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);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::NamedRegion_Data* data;
-  mojo::internal::Serialize<NamedRegionPtr>(region, &buf, &data, nullptr);
+  mojo::internal::Serialize<NamedRegionDataView>(region, &buf, &data, nullptr);
 
   NamedRegionPtr region2;
-  mojo::internal::Deserialize<NamedRegionPtr>(data, &region2, nullptr);
+  mojo::internal::Deserialize<NamedRegionDataView>(data, &region2, nullptr);
 
   EXPECT_EQ("region", *region2->name);
 
   EXPECT_EQ(4U, region2->rects->size());
   for (size_t i = 0; i < region2->rects->size(); ++i)
     CheckRect(*(*region2->rects)[i], static_cast<int32_t>(i) + 1);
 }
 
 // Serialization test of a struct with null array pointers.
 TEST_F(StructTest, Serialization_NullArrayPointers) {
   NamedRegionPtr region(NamedRegion::New());
   EXPECT_FALSE(region->name);
   EXPECT_FALSE(region->rects);
 
   size_t size =
-      mojo::internal::PrepareToSerialize<NamedRegionPtr>(region, nullptr);
+      mojo::internal::PrepareToSerialize<NamedRegionDataView>(region, nullptr);
   EXPECT_EQ(8U +      // header
                 8U +  // name pointer
                 8U,   // rects pointer
             size);
 
   mojo::internal::FixedBufferForTesting buf(size);
   internal::NamedRegion_Data* data;
-  mojo::internal::Serialize<NamedRegionPtr>(region, &buf, &data, nullptr);
+  mojo::internal::Serialize<NamedRegionDataView>(region, &buf, &data, nullptr);
 
   NamedRegionPtr region2;
-  mojo::internal::Deserialize<NamedRegionPtr>(data, &region2, nullptr);
+  mojo::internal::Deserialize<NamedRegionDataView>(data, &region2, nullptr);
 
   EXPECT_FALSE(region2->name);
   EXPECT_FALSE(region2->rects);
 }
 
 // Tests deserializing structs as a newer version.
 TEST_F(StructTest, Versioning_OldToNew) {
   {
     MultiVersionStructV0Ptr input(MultiVersionStructV0::New());
     input->f_int32 = 123;
@@ skipping 168 matching lines @@
     EXPECT_TRUE(output->Equals(*expected_output));
   }
 }
 
 // Serialization test for native struct.
 TEST_F(StructTest, Serialization_NativeStruct) {
   using Data = mojo::internal::NativeStruct_Data;
   {
     // Serialization of a null native struct.
     NativeStructPtr native;
-    size_t size =
-        mojo::internal::PrepareToSerialize<NativeStructPtr>(native, nullptr);
+    size_t size = mojo::internal::PrepareToSerialize<NativeStructDataView>(
+        native, nullptr);
     EXPECT_EQ(0u, size);
     mojo::internal::FixedBufferForTesting buf(size);
 
     Data* data = nullptr;
-    mojo::internal::Serialize<NativeStructPtr>(std::move(native), &buf, &data,
-                                               nullptr);
+    mojo::internal::Serialize<NativeStructDataView>(std::move(native), &buf,
+                                                    &data, nullptr);
 
     EXPECT_EQ(nullptr, data);
 
     NativeStructPtr output_native;
-    mojo::internal::Deserialize<NativeStructPtr>(data, &output_native, nullptr);
+    mojo::internal::Deserialize<NativeStructDataView>(data, &output_native,
+                                                      nullptr);
     EXPECT_TRUE(output_native.is_null());
   }
 
   {
     // Serialization of a native struct with null data.
     NativeStructPtr native(NativeStruct::New());
-    size_t size =
-        mojo::internal::PrepareToSerialize<NativeStructPtr>(native, nullptr);
+    size_t size = mojo::internal::PrepareToSerialize<NativeStructDataView>(
+        native, nullptr);
     EXPECT_EQ(0u, size);
     mojo::internal::FixedBufferForTesting buf(size);
 
     Data* data = nullptr;
-    mojo::internal::Serialize<NativeStructPtr>(std::move(native), &buf, &data,
-                                               nullptr);
+    mojo::internal::Serialize<NativeStructDataView>(std::move(native), &buf,
+                                                    &data, nullptr);
 
     EXPECT_EQ(nullptr, data);
 
     NativeStructPtr output_native;
-    mojo::internal::Deserialize<NativeStructPtr>(data, &output_native, nullptr);
+    mojo::internal::Deserialize<NativeStructDataView>(data, &output_native,
+                                                      nullptr);
     EXPECT_TRUE(output_native.is_null());
   }
 
   {
     NativeStructPtr native(NativeStruct::New());
     native->data = Array<uint8_t>(2);
     native->data[0] = 'X';
     native->data[1] = 'Y';
 
-    size_t size =
-        mojo::internal::PrepareToSerialize<NativeStructPtr>(native, nullptr);
+    size_t size = mojo::internal::PrepareToSerialize<NativeStructDataView>(
+        native, nullptr);
     EXPECT_EQ(16u, size);
     mojo::internal::FixedBufferForTesting buf(size);
 
     Data* data = nullptr;
-    mojo::internal::Serialize<NativeStructPtr>(std::move(native), &buf, &data,
-                                               nullptr);
+    mojo::internal::Serialize<NativeStructDataView>(std::move(native), &buf,
+                                                    &data, nullptr);
 
     EXPECT_NE(nullptr, data);
 
     NativeStructPtr output_native;
-    mojo::internal::Deserialize<NativeStructPtr>(data, &output_native, nullptr);
+    mojo::internal::Deserialize<NativeStructDataView>(data, &output_native,
+                                                      nullptr);
     EXPECT_FALSE(output_native.is_null());
     EXPECT_FALSE(output_native->data.is_null());
     EXPECT_EQ(2u, output_native->data.size());
     EXPECT_EQ('X', output_native->data[0]);
     EXPECT_EQ('Y', output_native->data[1]);
   }
 }
 
 TEST_F(StructTest, Serialization_PublicAPI) {
   {
@@ skipping 53 matching lines @@
     RectPtr rect = MakeRect();
     mojo::Array<uint8_t> data = Rect::Serialize(&rect);
 
     NamedRegionPtr output;
     EXPECT_FALSE(NamedRegion::Deserialize(std::move(data), &output));
   }
 }
 
 }  // namespace test
 }  // namespace mojo