mojo: Allow circular dependencies between structs

mojo/public/cpp/bindings/lib/array_serialization.h

Index: mojo/public/cpp/bindings/lib/array_serialization.h
diff --git a/mojo/public/cpp/bindings/lib/array_serialization.h b/mojo/public/cpp/bindings/lib/array_serialization.h
index 4407de850d676ec73d9d76286846141968a71750..a50b3ac54a5b1df436a071eb657b4695b8bf67e4 100644
--- a/mojo/public/cpp/bindings/lib/array_serialization.h
+++ b/mojo/public/cpp/bindings/lib/array_serialization.h
@@ -118,10 +118,14 @@ template <typename H> struct ArraySerializer<ScopedHandleBase<H>, H, true> {
   }
 };
 
-template <typename S> struct ArraySerializer<S, typename S::Data_*, true> {
+template <typename S>
+struct ArraySerializer<S,
+                       typename internal::WrapperTraits<S>::PlainDataType*,

[viettrungluu, 2014/10/01 17:18:23]

internal::WrapperTraits<S>::PlainDataType* is just
internal::WrapperTraits<S>::DataType.

I'm guessing that you use this to ensure that this template is only applied to
structs?

I wonder if using a suitable enable_if wouldn't be cleaner.

(Note also that you can get a T from a typename which is a T*, via suitable
template magic; the C++11 <type_traits> has remove_pointer which we can't use
yet, but it's easy enough to implement yourself. Similarly, you can also tell if
a given typename is a pointer type, if you need to do so to use with some
enable_if or similar.)

[qsr, 2014/10/06 08:20:26]

 enable_if, as well as remove_pointer are in type_traits
 Yes, I need this to prevent this one to be possible for handles. Uploaded a
change using EnableIf and RemovePointer instead.

+                       true> {
+  typedef typename internal::WrapperTraits<S>::PlainDataType F;

[viettrungluu, 2014/10/01 17:18:23]

nit: A more descriptive name (even "S_Data") than "F" would be nice.

[qsr, 2014/10/06 08:20:26]

Done.

   static size_t GetSerializedSize(const Array<S>& input) {
-    size_t size = sizeof(Array_Data<typename S::Data_*>) +
-        input.size() * sizeof(internal::StructPointer<typename S::Data_>);
+    size_t size = sizeof(Array_Data<F*>) +
+        input.size() * sizeof(internal::StructPointer<F>);
     for (size_t i = 0; i < input.size(); ++i)
       size += GetSerializedSize_(input[i]);
     return size;
@@ -129,9 +133,9 @@ template <typename S> struct ArraySerializer<S, typename S::Data_*, true> {
   template <bool element_is_nullable, typename ElementValidateParams>
   static void SerializeElements(Array<S> input,
                                 Buffer* buf,
-                                Array_Data<typename S::Data_*>* output) {
+                                Array_Data<F*>* output) {
     for (size_t i = 0; i < input.size(); ++i) {
-      typename S::Data_* element;
+      F* element;
       SerializeCaller<S, ElementValidateParams>::Run(
           input[i].Pass(), buf, &element);
       output->at(i) = element;
@@ -143,7 +147,7 @@ template <typename S> struct ArraySerializer<S, typename S::Data_*, true> {
     }
   }
   static void DeserializeElements(
-      Array_Data<typename S::Data_*>* input, Array<S>* output) {
+      Array_Data<F*>* input, Array<S>* output) {
     Array<S> result(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
       S element;
@@ -156,7 +160,10 @@ template <typename S> struct ArraySerializer<S, typename S::Data_*, true> {
  private:
   template <typename T, typename Params>
   struct SerializeCaller {
-    static void Run(T input, Buffer* buf, typename T::Data_** output) {
+    static void Run(
+        T input,
+        Buffer* buf,
+        typename internal::WrapperTraits<T>::PlainDataType** output) {
       MOJO_COMPILE_ASSERT((IsSame<Params, NoValidateParams>::value),
                           Struct_type_should_not_have_array_validate_params);