Mojo C++ bindings: Generate InterfaceHandle<> instead of InterfacePtr<>.

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.
 
 // TODO(vardhan):  Currently, the logic for serializing a mojom type exists in
 // two places: the C++ code generator template, and here.  However, most types
 // are serialized the same way within Arrays or outside, with the exception of
 // |bool|.  Consider defining serialization/deserialization traits for each
 // serializable type and call those traits from here.  This should help us
 // remove most of the ArraySerializer<> specializations here.
@@ skipping 222 matching lines @@
   static void DeserializeElements(Array_Data<MessagePipeHandle>* input,
                                   Array<InterfaceRequest<I>>* output) {
     auto result = Array<InterfaceRequest<I>>::New(input->size());
     for (size_t i = 0; i < input->size(); ++i)
       result.at(i) =
           MakeRequest<I>(MakeScopedHandle(FetchAndReset(&input->at(i)))).Pass();
     output->Swap(&result);
   }
 };
 
-// Serializes and deserializes arrays of interfaces (interface pointers).
+// Serializes and deserializes arrays of interfaces (interface handles).
 template <typename Interface>
-struct ArraySerializer<InterfacePtr<Interface>, Interface_Data, false> {
-  static size_t GetSerializedSize(const Array<InterfacePtr<Interface>>& input) {
+struct ArraySerializer<InterfaceHandle<Interface>, Interface_Data, false> {
+  static size_t GetSerializedSize(
+      const Array<InterfaceHandle<Interface>>& input) {
     return sizeof(Array_Data<Interface_Data>) +
            Align(input.size() * sizeof(Interface_Data));
   }
 
   template <typename Iterator>
   static ValidationError SerializeElements(
       Iterator it,
       size_t num_elements,
       Buffer* buf,
       Array_Data<Interface_Data>* output,
       const ArrayValidateParams* validate_params) {
     MOJO_DCHECK(!validate_params->element_validate_params)
         << "Interface type should not have array validate params";
 
     for (size_t i = 0; i < num_elements; ++i, ++it) {
       // Transfer ownership of the handle.
-      internal::InterfacePointerToData(it->Pass(), &output->at(i));
+      internal::InterfaceHandleToData(it->Pass(), &output->at(i));
       if (!validate_params->element_is_nullable &&
           !output->at(i).handle.is_valid()) {
         MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
             ValidationError::UNEXPECTED_INVALID_HANDLE,
             MakeMessageWithArrayIndex(
                 "invalid handle in array expecting valid handles", num_elements,
                 i));
         return ValidationError::UNEXPECTED_INVALID_HANDLE;
       }
     }
 
     return ValidationError::NONE;
   }
 
   static void DeserializeElements(Array_Data<Interface_Data>* input,
-                                  Array<InterfacePtr<Interface>>* output) {
-    auto result = Array<InterfacePtr<Interface>>::New(input->size());
+                                  Array<InterfaceHandle<Interface>>* output) {
+    auto result = Array<InterfaceHandle<Interface>>::New(input->size());
     for (size_t i = 0; i < input->size(); ++i)
-      internal::InterfaceDataToPointer(&input->at(i), &result.at(i));
+      internal::InterfaceDataToHandle(&input->at(i), &result.at(i));
     output->Swap(&result);
   }
 };
 
 // This template must only apply to pointer mojo entity (structs, arrays,
 // strings).  This is done by ensuring that WrapperTraits<S>::DataType is a
 // pointer.
 template <typename S>
 struct ArraySerializer<
     S,
@@ skipping 238 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_