mojo: Allow circular dependencies between structs

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

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
 
 #include <string.h>  // For |memcpy()|.
 
 #include <vector>
@@ skipping 100 matching lines @@
   }
   static void DeserializeElements(
       Array_Data<H>* input, Array<ScopedHandleBase<H> >* output) {
     Array<ScopedHandleBase<H> > result(input->size());
     for (size_t i = 0; i < input->size(); ++i)
       result.at(i) = MakeScopedHandle(FetchAndReset(&input->at(i)));
     output->Swap(&result);
   }
 };
 
-template <typename S> struct ArraySerializer<S, typename S::Data_*, true> {
+template <typename S>
+struct ArraySerializer<S,
+                       typename internal::EnableIf<
+                           internal::IsPointer<
+                               typename internal::WrapperTraits<
+                                   S>::DataType>::value,
+                           typename internal::WrapperTraits<
+                               S>::DataType>::type,
+                       true> {
+  typedef typename internal::RemovePointer<
+      typename internal::WrapperTraits<S>::DataType>::type S_Data;
   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<S_Data*>) +
+        input.size() * sizeof(internal::StructPointer<S_Data>);
     for (size_t i = 0; i < input.size(); ++i)
       size += GetSerializedSize_(input[i]);
     return size;
   }
   template <bool element_is_nullable, typename ElementValidateParams>
   static void SerializeElements(Array<S> input,
                                 Buffer* buf,
-                                Array_Data<typename S::Data_*>* output) {
+                                Array_Data<S_Data*>* output) {
     for (size_t i = 0; i < input.size(); ++i) {
-      typename S::Data_* element;
+      S_Data* element;
       SerializeCaller<S, ElementValidateParams>::Run(
           input[i].Pass(), buf, &element);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !element_is_nullable && !element,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex(
               "null in array expecting valid pointers", input.size(), i));
     }
   }
   static void DeserializeElements(
-      Array_Data<typename S::Data_*>* input, Array<S>* output) {
+      Array_Data<S_Data*>* input, Array<S>* output) {
     Array<S> result(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
       S element;
       Deserialize_(input->at(i), &element);
       result[i] = element.Pass();
     }
     output->Swap(&result);
   }
 
  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>::DataType* output) {
       MOJO_COMPILE_ASSERT((IsSame<Params, NoValidateParams>::value),
                           Struct_type_should_not_have_array_validate_params);
 
       Serialize_(input.Pass(), buf, output);
     }
   };
 
   template <typename T, typename Params>
   struct SerializeCaller<Array<T>, Params> {
     static void Run(Array<T> input,
@@ skipping 83 matching lines @@
   if (input) {
     internal::ArraySerializer<E, F>::DeserializeElements(input, output);
   } else {
     output->reset();
   }
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_