Mojo cpp bindings: report the reason of validation failure.

mojo/public/cpp/bindings/tests/validation_unittest.cc

 // 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.
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "mojo/public/cpp/bindings/lib/message_header_validator.h"
+#include "mojo/public/cpp/bindings/lib/validation_errors.h"
 #include "mojo/public/cpp/test_support/test_support.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
+std::string ValidationErrorToResultString(internal::ValidationError error) {
+  std::string result = internal::ValidationErrorToString(error);
+  result.push_back('\n');
+  return result;
+}
+
 std::vector<std::string> GetMatchingTests(const std::vector<std::string>& names,
                                           const std::string& prefix) {
   const std::string suffix = ".data";
   std::vector<std::string> tests;
   for (size_t i = 0; i < names.size(); ++i) {
     if (names[i].size() >= suffix.size() &&
         names[i].substr(0, prefix.size()) == prefix &&
         names[i].substr(names[i].size() - suffix.size()) == suffix)
       tests.push_back(names[i].substr(0, names[i].size() - suffix.size()));
   }
@@ skipping 62 matching lines @@
 }
 
 class DummyMessageReceiver : public MessageReceiver {
  public:
   virtual bool Accept(Message* message) MOJO_OVERRIDE {
     return true;  // Any message is OK.
   }
 };
 
 std::string DumpMessageHeader(Message* message) {
+  internal::ValidationErrorObserverForTesting observer;
   DummyMessageReceiver not_reached_receiver;
   internal::MessageHeaderValidator validator(&not_reached_receiver);
   bool rv = validator.Accept(message);
-  if (!rv)
-    return "ERROR\n";
+  if (!rv) {
+    EXPECT_NE(internal::VALIDATION_ERROR_NONE, observer.last_error());
+    return ValidationErrorToResultString(observer.last_error());
+  }
 
   std::ostringstream os;
   os << "num_bytes: " << message->header()->num_bytes << "\n"
      << "num_fields: " << message->header()->num_fields << "\n"
      << "name: " << message->header()->name << "\n"
      << "flags: " << message->header()->flags << "\n";
   return os.str();
 }
 
 TEST(ValidationTest, TestAll) {
   std::vector<std::string> names =
       EnumerateSourceRootRelativeDirectory(GetPath("", ""));
 
   std::vector<std::string> header_tests =
       GetMatchingTests(names, "validate_header_");
 
   for (size_t i = 0; i < header_tests.size(); ++i)
     RunValidationTest(header_tests[i], &DumpMessageHeader);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo