Mojo C++ bindings: support passing associated interface pointers/requests in method parameter lists…

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 11 matching lines @@
 inline size_t GetSerializedSize_(const Array<E>& input);
 
 template <typename E, typename F>
 inline void SerializeArray_(
     Array<E> input,
     internal::Buffer* buf,
     internal::Array_Data<F>** output,
     const internal::ArrayValidateParams* validate_params);
 
 template <typename E, typename F>
-inline void Deserialize_(internal::Array_Data<F>* data, Array<E>* output);
+inline void Deserialize_(internal::Array_Data<F>* data,
+                         Array<E>* output,
+                         internal::SerializationContext* context);
 
 namespace internal {
 
 template <typename E,
           typename F,
           bool is_union =
               IsUnionDataType<typename RemovePointer<F>::type>::value>
 struct ArraySerializer;
 
 // Handles serialization and deserialization of arrays of pod types.
 template <typename E, typename F>
 struct ArraySerializer<E, F, false> {
   static_assert(sizeof(E) == sizeof(F), "Incorrect array serializer");
   static size_t GetSerializedSize(const Array<E>& input) {
     return sizeof(Array_Data<F>) + Align(input.size() * sizeof(E));
   }
 
   static void SerializeElements(Array<E> input,
                                 Buffer* buf,
                                 Array_Data<F>* output,
                                 const ArrayValidateParams* validate_params) {
     MOJO_DCHECK(!validate_params->element_is_nullable)
         << "Primitive type should be non-nullable";
     MOJO_DCHECK(!validate_params->element_validate_params)
         << "Primitive type should not have array validate params";
 
     if (input.size())
       memcpy(output->storage(), &input.storage()[0], input.size() * sizeof(E));
   }
-  static void DeserializeElements(Array_Data<F>* input, Array<E>* output) {
+  static void DeserializeElements(Array_Data<F>* input,
+                                  Array<E>* output,
+                                  SerializationContext* context) {
     std::vector<E> result(input->size());
     if (input->size())
       memcpy(&result[0], input->storage(), input->size() * sizeof(E));
     output->Swap(&result);
   }
 };
 
 // Serializes and deserializes arrays of bools.
 template <>
 struct ArraySerializer<bool, bool, false> {
   static size_t GetSerializedSize(const Array<bool>& input) {
     return sizeof(Array_Data<bool>) + Align((input.size() + 7) / 8);
   }
 
   static void SerializeElements(Array<bool> input,
                                 Buffer* buf,
                                 Array_Data<bool>* output,
                                 const ArrayValidateParams* validate_params) {
     MOJO_DCHECK(!validate_params->element_is_nullable)
         << "Primitive type should be non-nullable";
     MOJO_DCHECK(!validate_params->element_validate_params)
         << "Primitive type should not have array validate params";
 
     // TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
     for (size_t i = 0; i < input.size(); ++i)
       output->at(i) = input[i];
   }
   static void DeserializeElements(Array_Data<bool>* input,
-                                  Array<bool>* output) {
+                                  Array<bool>* output,
+                                  SerializationContext* context) {
     Array<bool> result(input->size());
     // TODO(darin): Can this be a memcpy somehow instead of a bit-by-bit copy?
     for (size_t i = 0; i < input->size(); ++i)
       result.at(i) = input->at(i);
     output->Swap(&result);
   }
 };
 
 // Serializes and deserializes arrays of handles.
 template <typename H>
@@ skipping 13 matching lines @@
       output->at(i) = input[i].release();  // Transfer ownership of the handle.
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !output->at(i).is_valid(),
           VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
           MakeMessageWithArrayIndex(
               "invalid handle in array expecting valid handles", input.size(),
               i));
     }
   }
   static void DeserializeElements(Array_Data<H>* input,
-                                  Array<ScopedHandleBase<H>>* output) {
+                                  Array<ScopedHandleBase<H>>* output,
+                                  SerializationContext* context) {
     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);
   }
 };
 
 // This template must only apply to pointer mojo entity (structs and arrays).
 // This is done by ensuring that WrapperTraits<S>::DataType is a pointer.
 template <typename S>
@@ skipping 22 matching lines @@
                               validate_params->element_validate_params);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !element,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                     input.size(), i));
     }
   }
   static void DeserializeElements(Array_Data<S_Data*>* input,
-                                  Array<S>* output) {
+                                  Array<S>* output,
+                                  SerializationContext* context) {
     Array<S> result(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
-      Deserialize_(input->at(i), &result[i]);
+      Deserialize_(input->at(i), &result[i], context);
     }
     output->Swap(&result);
   }
 
  private:
   template <typename T>
   struct SerializeCaller {
     static void Run(T input,
                     Buffer* buf,
                     typename WrapperTraits<T>::DataType* output,
@@ skipping 47 matching lines @@
       U_Data* result = output->storage() + i;
       SerializeUnion_(input[i].Pass(), buf, &result, true);
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && output->at(i).is_null(),
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid unions",
                                     input.size(), i));
     }
   }
 
-  static void DeserializeElements(Array_Data<U_Data>* input, Array<U>* output) {
+  static void DeserializeElements(Array_Data<U_Data>* input,
+                                  Array<U>* output,
+                                  SerializationContext* context) {
     Array<U> result(input->size());
     for (size_t i = 0; i < input->size(); ++i) {
-      Deserialize_(&input->at(i), &result[i]);
+      Deserialize_(&input->at(i), &result[i], context);
     }
     output->Swap(&result);
   }
 };
 
 // Handles serialization and deserialization of arrays of strings.
 template <>
 struct ArraySerializer<String, String_Data*> {
   static size_t GetSerializedSize(const Array<String>& input) {
     size_t size =
@@ skipping 19 matching lines @@
       Serialize_(input[i], buf, &element);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !element,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid strings",
                                     input.size(), i));
     }
   }
   static void DeserializeElements(Array_Data<String_Data*>* input,
-                                  Array<String>* output) {
+                                  Array<String>* output,
+                                  SerializationContext* context) {
     Array<String> result(input->size());
     for (size_t i = 0; i < input->size(); ++i)
-      Deserialize_(input->at(i), &result[i]);
+      Deserialize_(input->at(i), &result[i], context);
     output->Swap(&result);
   }
 };
 
 }  // namespace internal
 
 template <typename E>
 inline size_t GetSerializedSize_(const Array<E>& input) {
   if (!input)
     return 0;
@@ skipping 22 matching lines @@
       internal::ArraySerializer<E, F>::SerializeElements(
           internal::Forward(input), buf, result, validate_params);
     }
     *output = result;
   } else {
     *output = nullptr;
   }
 }
 
 template <typename E, typename F>
-inline void Deserialize_(internal::Array_Data<F>* input, Array<E>* output) {
+inline void Deserialize_(internal::Array_Data<F>* input,
+                         Array<E>* output,
+                         internal::SerializationContext* context) {
   if (input) {
-    internal::ArraySerializer<E, F>::DeserializeElements(input, output);
+    internal::ArraySerializer<E, F>::DeserializeElements(input, output,
+                                                         context);
   } else {
     output->reset();
   }
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_