Mojo: Report bindings validation errors via MojoNotifyBadMessage

mojo/public/cpp/bindings/lib/message.cc

 // Copyright 2013 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 "mojo/public/cpp/bindings/message.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
+#include "base/strings/stringprintf.h"
 
 namespace mojo {
 
 Message::Message() {
 }
 
 Message::~Message() {
   CloseHandles();
 }
 
@@ skipping 46 matching lines @@
   void* new_buffer = nullptr;
   rv = GetMessageBuffer(new_message.get(), &new_buffer);
   CHECK_EQ(rv, MOJO_RESULT_OK);
 
   memcpy(new_buffer, data(), data_num_bytes());
   buffer_.reset();
 
   return new_message;
 }
 
+void Message::NotifyBadMessage(const std::string& error) {
+  buffer_->NotifyBadMessage(error);
+}
+
 void Message::CloseHandles() {
   for (std::vector<Handle>::iterator it = handles_.begin();
        it != handles_.end(); ++it) {
     if (it->is_valid())
       CloseRaw(*it);
   }
 }
 
+
+MessageReceiver::Result::Result(Type type) : Result(type, "") {}

[yzshen1, 2016/06/15 16:22:33]

nit: it is preferred to use a default constructed std::string than "".

+
+MessageReceiver::Result::Result(Type type, const std::string& details)
+    : type_(type), details_(details) {}
+
+MessageReceiver::Result::Result(Result&& other) { *this = std::move(other); }
+
+MessageReceiver::Result::~Result() {}
+
+MessageReceiver::Result& MessageReceiver::Result::operator=(Result&& other) {
+  type_ = other.type_;
+  details_ = std::move(other.details_);
+  other.message_.MoveTo(&message_);
+  return *this;
+}
+
+// static
+MessageReceiver::Result MessageReceiver::Result::ForBadMessage(
+    const std::string& details,
+    Message* message) {
+  Result error(Type::BAD_MESSAGE, details);
+  error.set_message(message);
+  return error;
+}
+
+// static
+MessageReceiver::Result MessageReceiver::Result::ForBadRequest(
+    const std::string& interface_name,
+    const std::string& method_name,
+    Message* message) {
+  Result error(Type::BAD_MESSAGE,
+               base::StringPrintf("%s::%s", interface_name.c_str(),
+                                  method_name.c_str()));
+  error.set_message(message);
+  return error;
+}
+
+// static
+MessageReceiver::Result MessageReceiver::Result::ForBadResponse(
+    const std::string& interface_name,
+    const std::string& method_name,
+    Message* message) {
+  Result error(Type::BAD_MESSAGE,
+               base::StringPrintf("%s::%s",
+                                  interface_name.c_str(), method_name.c_str()));
+  error.set_message(message);
+  return error;
+}
+
+// static
+MessageReceiver::Result MessageReceiver::Result::ForUnexpectedRequest(
+    const std::string& interface_name,
+    Message* message) {
+  Result error(Type::BAD_MESSAGE,

[yzshen1, 2016/06/15 16:22:33]

It seems the difference between unexpected request/ request dropped is not very
obvious. (And also unexpected response / response dropped.)

+               base::StringPrintf("%s (unexpected request %u)",
+                                  interface_name.c_str(), message->name()));
+  error.set_message(message);
+  return error;
+}
+
+// static
+MessageReceiver::Result MessageReceiver::Result::ForUnexpectedResponse(
+    const std::string& interface_name,
+    Message* message) {
+  Result error(Type::BAD_MESSAGE,
+               base::StringPrintf("%s (unexpected response %u)",
+                                  interface_name.c_str(), message->name()));
+  error.set_message(message);
+  return error;
+}
+
+// static
+MessageReceiver::Result MessageReceiver::Result::ForBadControlMessage(

[yzshen1, 2016/06/15 16:22:33]

Does this also apply to "pipe-level" control message? In that case I guess the
interface name is the master interface?

+    const std::string& interface_name,
+    Message* message) {
+  Result error(Type::BAD_MESSAGE,
+               base::StringPrintf("%s (control message ID %u)",
+                                  interface_name.c_str(), message->name()));
+  error.set_message(message);
+  return error;
+}
+
 MojoResult ReadMessage(MessagePipeHandle handle, Message* message) {
   MojoResult rv;
 
   std::vector<Handle> handles;
   ScopedMessageHandle mojo_message;
   uint32_t num_bytes = 0, num_handles = 0;
   rv = ReadMessageNew(handle,
                       &mojo_message,
                       &num_bytes,
                       nullptr,
@@ skipping 12 matching lines @@
 
   if (rv != MOJO_RESULT_OK)
     return rv;
 
   message->InitializeFromMojoMessage(
       std::move(mojo_message), num_bytes, &handles);
   return MOJO_RESULT_OK;
 }
 
 }  // namespace mojo