Mojo: Report bindings validation errors via MojoNotifyBadMessage

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

Index: mojo/public/cpp/bindings/lib/interface_endpoint_client.cc
diff --git a/mojo/public/cpp/bindings/lib/interface_endpoint_client.cc b/mojo/public/cpp/bindings/lib/interface_endpoint_client.cc
index 9e32c5af239b3ff45f5d22a64d0a70165f20d5b1..a684fbed80fdc8b46e0e002147bbefebc408500c 100644
--- a/mojo/public/cpp/bindings/lib/interface_endpoint_client.cc
+++ b/mojo/public/cpp/bindings/lib/interface_endpoint_client.cc
@@ -50,34 +50,32 @@ class ResponderThunk : public MessageReceiverWithStatus {
       // We raise an error to signal the calling application that an error
       // condition occurred. Without this the calling application would have no
       // way of knowing it should stop waiting for a response.
+      Result error(Result::Type::RESPONSE_DROPPED);
       if (task_runner_->RunsTasksOnCurrentThread()) {
         // Please note that even if this code is run from a different task
         // runner on the same thread as |task_runner_|, it is okay to directly
         // call InterfaceEndpointClient::RaiseError(), because it will raise
         // error from the correct task runner asynchronously.
-        if (endpoint_client_) {
-          endpoint_client_->RaiseError();
-        }
+        if (endpoint_client_)
+          endpoint_client_->RaiseError(std::move(error));
       } else {
         task_runner_->PostTask(
             FROM_HERE,
-            base::Bind(&InterfaceEndpointClient::RaiseError, endpoint_client_));
+            base::Bind(&InterfaceEndpointClient::RaiseError, endpoint_client_,
+                       base::Passed(&error)));
       }
     }
   }
 
   // MessageReceiver implementation:
-  bool Accept(Message* message) override {
+  Result Accept(Message* message) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     accept_was_invoked_ = true;
     DCHECK(message->has_flag(kMessageIsResponse));
 
-    bool result = false;
-
-    if (endpoint_client_)
-      result = endpoint_client_->Accept(message);
-
-    return result;
+    if (!endpoint_client_)
+      return Result(Result::Type::RESPONSE_DROPPED);
+    return endpoint_client_->Accept(message);
   }
 
   // MessageReceiverWithStatus implementation:
@@ -122,8 +120,8 @@ InterfaceEndpointClient::HandleIncomingMessageThunk::HandleIncomingMessageThunk(
 InterfaceEndpointClient::HandleIncomingMessageThunk::
     ~HandleIncomingMessageThunk() {}
 
-bool InterfaceEndpointClient::HandleIncomingMessageThunk::Accept(
-    Message* message) {
+MessageReceiver::Result
+InterfaceEndpointClient::HandleIncomingMessageThunk::Accept(Message* message) {
   return owner_->HandleValidatedMessage(message);
 }
 
@@ -186,31 +184,32 @@ ScopedInterfaceEndpointHandle InterfaceEndpointClient::PassHandle() {
   return std::move(handle_);
 }
 
-void InterfaceEndpointClient::RaiseError() {
+void InterfaceEndpointClient::RaiseError(Result error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  handle_.router()->RaiseError();
+  handle_.router()->RaiseError(std::move(error));
 }
 
-bool InterfaceEndpointClient::Accept(Message* message) {
+MessageReceiver::Result InterfaceEndpointClient::Accept(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(controller_);
   DCHECK(!message->has_flag(kMessageExpectsResponse));
 
-  if (encountered_error_)
-    return false;
+  if (encountered_error_ || !controller_->SendMessage(message))
+    return Result(Result::Type::SEND_FAILED);
 
-  return controller_->SendMessage(message);
+  return Result::ForSuccess();
 }
 
-bool InterfaceEndpointClient::AcceptWithResponder(Message* message,
-                                                  MessageReceiver* responder) {
+MessageReceiver::Result InterfaceEndpointClient::AcceptWithResponder(
+    Message* message,
+    MessageReceiver* responder) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(controller_);
   DCHECK(message->has_flag(kMessageExpectsResponse));
 
   if (encountered_error_)
-    return false;
+    return Result(Result::Type::SEND_FAILED);
 
   // Reserve 0 in case we want it to convey special meaning in the future.
   uint64_t request_id = next_request_id_++;
@@ -221,12 +220,12 @@ bool InterfaceEndpointClient::AcceptWithResponder(Message* message,
 
   bool is_sync = message->has_flag(kMessageIsSync);
   if (!controller_->SendMessage(message))
-    return false;
+    return Result(Result::Type::SEND_FAILED);
 
   if (!is_sync) {
     // We assume ownership of |responder|.
     async_responders_[request_id] = base::WrapUnique(responder);
-    return true;
+    return Result::ForSuccess();
   }
 
   bool response_received = false;
@@ -250,10 +249,11 @@ bool InterfaceEndpointClient::AcceptWithResponder(Message* message,
   }
 
   // Return true means that we take ownership of |responder|.
-  return true;
+  return Result::ForSuccess();
 }
 
-bool InterfaceEndpointClient::HandleIncomingMessage(Message* message) {
+MessageReceiver::Result InterfaceEndpointClient::HandleIncomingMessage(
+    Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return payload_validator_->Accept(message);
@@ -268,42 +268,43 @@ void InterfaceEndpointClient::NotifyError() {
   error_handler_.Run();
 }
 
-bool InterfaceEndpointClient::HandleValidatedMessage(Message* message) {
+MessageReceiver::Result InterfaceEndpointClient::HandleValidatedMessage(
+    Message* message) {
   DCHECK_EQ(handle_.id(), message->interface_id());
 
   if (message->has_flag(kMessageExpectsResponse)) {
     if (!incoming_receiver_)
-      return false;
+      return Result(Result::Type::REQUEST_DROPPED);
 
     MessageReceiverWithStatus* responder =
         new ResponderThunk(weak_ptr_factory_.GetWeakPtr(), task_runner_);
-    bool ok = incoming_receiver_->AcceptWithResponder(message, responder);
-    if (!ok)
+    Result result = incoming_receiver_->AcceptWithResponder(message, responder);
+    if (!result.Succeeded())
       delete responder;
-    return ok;
+    return result;
   } else if (message->has_flag(kMessageIsResponse)) {
     uint64_t request_id = message->request_id();
 
     if (message->has_flag(kMessageIsSync)) {
       auto it = sync_responses_.find(request_id);
       if (it == sync_responses_.end())
-        return false;
+        return Result::ForUnexpectedResponse(interface_name_, message);
       it->second->response.reset(new Message());
       message->MoveTo(it->second->response.get());
       *it->second->response_received = true;
-      return true;
+      return Result::ForSuccess();
     }
 
     auto it = async_responders_.find(request_id);
     if (it == async_responders_.end())
-      return false;
+      return Result::ForUnexpectedResponse(interface_name_, message);
+
     std::unique_ptr<MessageReceiver> responder = std::move(it->second);
     async_responders_.erase(it);
     return responder->Accept(message);
   } else {
     if (!incoming_receiver_)
-      return false;
-
+      return Result(Result::Type::REQUEST_DROPPED);
     return incoming_receiver_->Accept(message);
   }
 }