Mojo C++ bindings: better log message for serialization warnings.

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 86 matching lines @@
                                 Array_Data<H>* output) {
     MOJO_COMPILE_ASSERT(
         (IsSame<ElementValidateParams, NoValidateParams>::value),
         Handle_type_should_not_have_array_validate_params);
 
     for (size_t i = 0; i < input.size(); ++i) {
       output->at(i) = input[i].release();  // Transfer ownership of the handle.
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           IsNonNullableValidationEnabled() && !element_is_nullable &&
               !output->at(i).is_valid(),
-          VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE);
+          VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
+          "invalid handle in array of non-nullable handles");
     }
   }
   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);
   }
 };
@@ skipping 10 matching lines @@
   static void SerializeElements(Array<S> input,
                                 Buffer* buf,
                                 Array_Data<typename S::Data_*>* output) {
     for (size_t i = 0; i < input.size(); ++i) {
       typename S::Data_* element;
       SerializeCaller<S, ElementValidateParams>::Run(
           input[i].Pass(), buf, &element);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           IsNonNullableValidationEnabled() && !element_is_nullable && !element,
-          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER);
+          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+          "null pointer in array of non-nullable pointers");

[hansmuller, 2014/08/21 00:26:40]

You could specify the element index in the error message. It would help the
reader if it were possible to name the field or parameter that the array came
from, but that's going to be relatively difficult.

[yzshen1, 2014/08/21 05:57:49]

Done.

     }
   }
   static void DeserializeElements(
       Array_Data<typename 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();
     }
@@ skipping 38 matching lines @@
         (IsSame<ElementValidateParams,
                 ArrayValidateParams<0, false, NoValidateParams> >::value),
         String_type_has_unexpected_array_validate_params);
 
     for (size_t i = 0; i < input.size(); ++i) {
       String_Data* element;
       Serialize_(input[i], buf, &element);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           IsNonNullableValidationEnabled() && !element_is_nullable && !element,
-          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER);
+          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+          "null string in array of non-nullable strings");
     }
   }
   static void DeserializeElements(
       Array_Data<String_Data*>* input, Array<String>* output) {
     Array<String> result(input->size());
     for (size_t i = 0; i < input->size(); ++i)
       Deserialize_(input->at(i), &result[i]);
     output->Swap(&result);
   }
 };
 
 }  // namespace internal
 
 template <typename E>
 inline size_t GetSerializedSize_(const Array<E>& input) {
   if (!input)
     return 0;
   typedef typename internal::WrapperTraits<E>::DataType F;
   return internal::ArraySerializer<E, F>::GetSerializedSize(input);
 }
 
 template <typename ValidateParams, typename E, typename F>
 inline void SerializeArray_(Array<E> input, internal::Buffer* buf,
                             internal::Array_Data<F>** output) {
   if (input) {
     MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
         ValidateParams::expected_num_elements != 0 &&
             input.size() != ValidateParams::expected_num_elements,
-        internal::VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER);
+        internal::VALIDATION_ERROR_UNEXPECTED_ARRAY_HEADER,
+        "fixed-size array has wrong number of elements");
 
     internal::Array_Data<F>* result =
         internal::Array_Data<F>::New(input.size(), buf);
     if (result) {
       internal::ArraySerializer<E, F>::template SerializeElements<
           ValidateParams::element_is_nullable,
           typename ValidateParams::ElementValidateParams>(
               internal::Forward(input), buf, result);
     }
     *output = result;
   } else {
     *output = NULL;
   }
 }
 
 template <typename E, typename F>
 inline void Deserialize_(internal::Array_Data<F>* input, Array<E>* output) {
   if (input) {
     internal::ArraySerializer<E, F>::DeserializeElements(input, output);
   } else {
     output->reset();
   }
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_