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 85 matching lines @@
                                 Buffer* buf,
                                 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(
           !element_is_nullable && !output->at(i).is_valid(),
-          VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE);
+          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> > 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(
           !element_is_nullable && !element,
-          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER);
+          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+          MakeMessageWithArrayIndex(
+              "null in array expecting valid pointers", input.size(), i));
     }
   }
   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(
           !element_is_nullable && !element,
-          VALIDATION_ERROR_UNEXPECTED_NULL_POINTER);
+          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> 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,
+        internal::MakeMessageWithExpectedArraySize(
+            "fixed-size array has wrong number of elements",
+            input.size(), ValidateParams::expected_num_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_