Mojo C++ bindings: switch the remaining callsites of the old serialization interface.

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

 // Copyright 2015 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_NATIVE_STRUCT_SERIALIZATION_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_NATIVE_STRUCT_SERIALIZATION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "ipc/ipc_param_traits.h"
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/native_struct_data.h"
 #include "mojo/public/cpp/bindings/lib/serialization_forward.h"
 #include "mojo/public/cpp/bindings/lib/serialization_util.h"
+#include "mojo/public/cpp/bindings/native_struct.h"
 
 namespace mojo {
 namespace internal {
 
-template <typename MaybeConstUserType,
-          bool unmapped = std::is_same<
-              NativeStructPtr,
-              typename std::remove_const<MaybeConstUserType>::type>::value>
-struct NativeStructSerializerImpl;
-
 template <typename MaybeConstUserType>
-struct NativeStructSerializerImpl<MaybeConstUserType, true> {
-  static size_t PrepareToSerialize(const NativeStructPtr& input,
-                                   SerializationContext* context) {
-    if (!input)
-      return 0;
-    return internal::PrepareToSerialize<Array<uint8_t>>(input->data, context);
-  }
-
-  static void Serialize(NativeStructPtr& input,
-                        Buffer* buffer,
-                        NativeStruct_Data** output,
-                        SerializationContext* context) {
-    if (!input) {
-      *output = nullptr;
-      return;
-    }
-
-    Array_Data<uint8_t>* data = nullptr;
-    const ArrayValidateParams params(0, false, nullptr);
-    internal::Serialize<Array<uint8_t>>(input->data, buffer, &data, &params,
-                                        context);
-    *output = reinterpret_cast<NativeStruct_Data*>(data);
-  }
-
-  static bool Deserialize(NativeStruct_Data* input,
-                          NativeStructPtr* output,
-                          SerializationContext* context) {
-    Array_Data<uint8_t>* data = reinterpret_cast<Array_Data<uint8_t>*>(input);
-
-    NativeStructPtr result(NativeStruct::New());
-    if (!internal::Deserialize<Array<uint8_t>>(data, &result->data, context)) {
-      output = nullptr;
-      return false;
-    }
-    if (!result->data)
-      *output = nullptr;
-    else
-      result.Swap(output);
-    return true;
-  }
-};
-
-template <typename MaybeConstUserType>
-struct NativeStructSerializerImpl<MaybeConstUserType, false> {
+struct NativeStructSerializerImpl {
   using UserType = typename std::remove_const<MaybeConstUserType>::type;
   using Traits = IPC::ParamTraits<UserType>;
 
   static size_t PrepareToSerialize(MaybeConstUserType& value,
                                    SerializationContext* context) {
     base::PickleSizer sizer;
     Traits::GetSize(&sizer, value);
     return Align(sizer.payload_size() + sizeof(ArrayHeader));
   }
 
@@ skipping 51 matching lines @@
         return false;
     }
 
     // Return the header to its original state.
     header->num_bytes += sizeof(ArrayHeader);
 
     return true;
   }
 };
 
+struct UnmappedNativeStructSerializerImpl {
+  static size_t PrepareToSerialize(const NativeStructPtr& input,
+                                   SerializationContext* context);
+  static void Serialize(const NativeStructPtr& input,
+                        Buffer* buffer,
+                        NativeStruct_Data** output,
+                        SerializationContext* context);
+  static bool Deserialize(NativeStruct_Data* input,
+                          NativeStructPtr* output,
+                          SerializationContext* context);
+};
+
+template <>
+struct NativeStructSerializerImpl<NativeStructPtr>
+    : public UnmappedNativeStructSerializerImpl {};
+
+template <>
+struct NativeStructSerializerImpl<const NativeStructPtr>
+    : public UnmappedNativeStructSerializerImpl {};
+
 template <typename MaybeConstUserType>
 struct Serializer<NativeStructPtr, MaybeConstUserType>
     : public NativeStructSerializerImpl<MaybeConstUserType> {};
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_NATIVE_STRUCT_SERIALIZATION_H_