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

mojo/public/cpp/bindings/tests/serialization_warning_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.
 
 // Serialization warnings are only recorded when DLOG is enabled.
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
 
 #include <stddef.h>
 #include <utility>
 
@@ skipping 29 matching lines @@
   return array;
 }
 
 class SerializationWarningTest : public testing::Test {
  public:
   ~SerializationWarningTest() override {}
 
  protected:
   template <typename T>
   void TestWarning(T obj, mojo::internal::ValidationError expected_warning) {
+    using MojomType = typename T::Struct::DataView;
+
     warning_observer_.set_last_warning(mojo::internal::VALIDATION_ERROR_NONE);
 
     mojo::internal::SerializationContext context;
     mojo::internal::FixedBufferForTesting buf(
-        mojo::internal::PrepareToSerialize<T>(obj, &context));
-    typename mojo::internal::MojomTypeTraits<T>::Data* data;
-    mojo::internal::Serialize<T>(obj, &buf, &data, &context);
+        mojo::internal::PrepareToSerialize<MojomType>(obj, &context));
+    typename mojo::internal::MojomTypeTraits<MojomType>::Data* data;
+    mojo::internal::Serialize<MojomType>(obj, &buf, &data, &context);
 
     EXPECT_EQ(expected_warning, warning_observer_.last_warning());
   }
 
-  template <typename T>
+  template <typename MojomType, typename T>
   void TestArrayWarning(T obj,
                         mojo::internal::ValidationError expected_warning,
                         const ContainerValidateParams* validate_params) {
     warning_observer_.set_last_warning(mojo::internal::VALIDATION_ERROR_NONE);
 
     mojo::internal::SerializationContext context;
     mojo::internal::FixedBufferForTesting buf(
-        mojo::internal::PrepareToSerialize<T>(obj, &context));
-    typename mojo::internal::MojomTypeTraits<T>::Data* data;
-    mojo::internal::Serialize<T>(obj, &buf, &data, validate_params, &context);
+        mojo::internal::PrepareToSerialize<MojomType>(obj, &context));
+    typename mojo::internal::MojomTypeTraits<MojomType>::Data* data;
+    mojo::internal::Serialize<MojomType>(obj, &buf, &data, validate_params,
+                                         &context);
 
     EXPECT_EQ(expected_warning, warning_observer_.last_warning());
   }
 
   template <typename T>
   void TestUnionWarning(T obj,
                         mojo::internal::ValidationError expected_warning) {
+    using MojomType = typename T::Struct::DataView;
+
     warning_observer_.set_last_warning(mojo::internal::VALIDATION_ERROR_NONE);
 
     mojo::internal::SerializationContext context;
     mojo::internal::FixedBufferForTesting buf(
-        mojo::internal::PrepareToSerialize<T>(obj, false, &context));
-    typename mojo::internal::MojomTypeTraits<T>::Data* data;
-    mojo::internal::Serialize<T>(obj, &buf, &data, false, &context);
+        mojo::internal::PrepareToSerialize<MojomType>(obj, false, &context));
+    typename mojo::internal::MojomTypeTraits<MojomType>::Data* data;
+    mojo::internal::Serialize<MojomType>(obj, &buf, &data, false, &context);
 
     EXPECT_EQ(expected_warning, warning_observer_.last_warning());
   }
 
   mojo::internal::SerializationWarningObserverForTesting warning_observer_;
 };
 
 TEST_F(SerializationWarningTest, HandleInStruct) {
   Struct2Ptr test_struct(Struct2::New());
   EXPECT_FALSE(test_struct->hdl.is_valid());
@@ skipping 50 matching lines @@
 
   test_struct = Struct5::New();
   test_struct->pair.resize(2);
   test_struct->pair[0] = Struct1::New();
   test_struct->pair[1] = Struct1::New();
 
   TestWarning(std::move(test_struct), mojo::internal::VALIDATION_ERROR_NONE);
 }
 
 TEST_F(SerializationWarningTest, ArrayOfArraysOfHandles) {
+  using MojomType = ArrayDataView<ArrayDataView<ScopedHandle>>;
   Array<Array<ScopedHandle>> test_array = CreateTestNestedHandleArray();
   test_array[0] = nullptr;
   test_array[1][0] = ScopedHandle();
 
   ContainerValidateParams validate_params_0(
       0, true, new ContainerValidateParams(0, true, nullptr));
-  TestArrayWarning(std::move(test_array), mojo::internal::VALIDATION_ERROR_NONE,
-                   &validate_params_0);
+  TestArrayWarning<MojomType>(std::move(test_array),
+                              mojo::internal::VALIDATION_ERROR_NONE,
+                              &validate_params_0);
 
   test_array = CreateTestNestedHandleArray();
   test_array[0] = nullptr;
   ContainerValidateParams validate_params_1(
       0, false, new ContainerValidateParams(0, true, nullptr));
-  TestArrayWarning(std::move(test_array),
-                   mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
-                   &validate_params_1);
+  TestArrayWarning<MojomType>(
+      std::move(test_array),
+      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+      &validate_params_1);
 
   test_array = CreateTestNestedHandleArray();
   test_array[1][0] = ScopedHandle();
   ContainerValidateParams validate_params_2(
       0, true, new ContainerValidateParams(0, false, nullptr));
-  TestArrayWarning(std::move(test_array),
-                   mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
-                   &validate_params_2);
+  TestArrayWarning<MojomType>(
+      std::move(test_array),
+      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
+      &validate_params_2);
 }
 
 TEST_F(SerializationWarningTest, ArrayOfStrings) {
+  using MojomType = ArrayDataView<StringDataView>;
+
   Array<String> test_array(3);
   for (size_t i = 0; i < test_array.size(); ++i)
     test_array[i] = "hello";
 
   ContainerValidateParams validate_params_0(
       0, true, new ContainerValidateParams(0, false, nullptr));
-  TestArrayWarning(std::move(test_array), mojo::internal::VALIDATION_ERROR_NONE,
-                   &validate_params_0);
+  TestArrayWarning<MojomType>(std::move(test_array),
+                              mojo::internal::VALIDATION_ERROR_NONE,
+                              &validate_params_0);
 
   test_array = Array<String>(3);
   for (size_t i = 0; i < test_array.size(); ++i)
     test_array[i] = nullptr;
   ContainerValidateParams validate_params_1(
       0, false, new ContainerValidateParams(0, false, nullptr));
-  TestArrayWarning(std::move(test_array),
-                   mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
-                   &validate_params_1);
+  TestArrayWarning<MojomType>(
+      std::move(test_array),
+      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+      &validate_params_1);
 
   test_array = Array<String>(2);
   ContainerValidateParams validate_params_2(
       3, true, new ContainerValidateParams(0, false, nullptr));
-  TestArrayWarning(std::move(test_array),
-                   mojo::internal::VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER,
-                   &validate_params_2);
+  TestArrayWarning<MojomType>(
+      std::move(test_array),
+      mojo::internal::VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER,
+      &validate_params_2);
 }
 
 TEST_F(SerializationWarningTest, StructInUnion) {
   DummyStructPtr dummy(nullptr);
   ObjectUnionPtr obj(ObjectUnion::New());
   obj->set_f_dummy(std::move(dummy));
 
   TestUnionWarning(std::move(obj),
                    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER);
 }
@@ skipping 14 matching lines @@
 
   TestUnionWarning(std::move(handle),
                    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo
 
 #endif