Mojo C++ bindings: Merge EncodePointers/DecodePointers into Serialize/Deserialize, respectively.

mojo/public/cpp/bindings/lib/map_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_MAP_SERIALIZATION_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_SERIALIZATION_H_
 
 #include <type_traits>
 #include <vector>
 
@@ skipping 104 matching lines @@
                         SerializationContext* context) {
     DCHECK(validate_params->key_validate_params);
     DCHECK(validate_params->element_validate_params);
     if (CallIsNullIfExists<Traits>(input)) {
       *output = nullptr;
       return;
     }
 
     auto result = Data::New(buf);
     if (result) {
-      result->keys.ptr =
+      auto keys_ptr =
           MojomTypeTraits<Array<Key>>::Data::New(Traits::GetSize(input), buf);
-      if (result->keys.ptr) {
+      if (keys_ptr) {
         MapKeyReader<MaybeConstUserType> key_reader(input);
         KeyArraySerializer::SerializeElements(
-            &key_reader, buf, result->keys.ptr,
-            validate_params->key_validate_params, context);
+            &key_reader, buf, keys_ptr, validate_params->key_validate_params,
+            context);
+        result->keys.Set(keys_ptr);
       }
 
-      result->values.ptr =
+      auto values_ptr =
           MojomTypeTraits<Array<Value>>::Data::New(Traits::GetSize(input), buf);
-      if (result->values.ptr) {
+      if (values_ptr) {
         MapValueReader<MaybeConstUserType> value_reader(input);
         ValueArraySerializer::SerializeElements(
-            &value_reader, buf, result->values.ptr,
+            &value_reader, buf, values_ptr,
             validate_params->element_validate_params, context);
+        result->values.Set(values_ptr);
       }
     }
     *output = result;
   }
 
   static bool Deserialize(Data* input,
                           UserType* output,
                           SerializationContext* context) {
     if (!input)
       return CallSetToNullIfExists<Traits>(output);
 
     std::vector<UserKey> keys;
     std::vector<UserValue> values;
 
-    if (!KeyArraySerializer::DeserializeElements(input->keys.ptr, &keys,
+    if (!KeyArraySerializer::DeserializeElements(input->keys.Get(), &keys,
                                                  context) ||
-        !ValueArraySerializer::DeserializeElements(input->values.ptr, &values,
+        !ValueArraySerializer::DeserializeElements(input->values.Get(), &values,
                                                    context)) {
       return false;
     }
 
     DCHECK_EQ(keys.size(), values.size());
     size_t size = keys.size();
     Traits::SetToEmpty(output);
 
     for (size_t i = 0; i < size; ++i) {
       if (!Traits::Insert(*output, std::move(keys[i]), std::move(values[i])))
         return false;
     }
     return true;
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_SERIALIZATION_H_