Mojo: Report bindings validation errors via MojoNotifyBadMessage

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

Index: mojo/public/cpp/bindings/lib/router.cc
diff --git a/mojo/public/cpp/bindings/lib/router.cc b/mojo/public/cpp/bindings/lib/router.cc
index da5f34b1df57ce4bbfaf8668061d2bbde6bc3e49..648fcfe7355766a903c150f5dbaba7190893bd4a 100644
--- a/mojo/public/cpp/bindings/lib/router.cc
+++ b/mojo/public/cpp/bindings/lib/router.cc
@@ -41,32 +41,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 Router::RaiseError(), because it will raise error from the
         // correct task runner asynchronously.
         if (router_)
-          router_->RaiseError();
+          router_->RaiseError(std::move(error));
       } else {
         task_runner_->PostTask(FROM_HERE,
-                               base::Bind(&Router::RaiseError, router_));
+                               base::Bind(&Router::RaiseError, router_,
+                                          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 (!router_)
+      return Result(Result::Type::RESPONSE_DROPPED);
 
-    if (router_)
-      result = router_->Accept(message);
-
-    return result;
+    return router_->Accept(message);
   }
 
   // MessageReceiverWithStatus implementation:
@@ -108,7 +108,8 @@ Router::HandleIncomingMessageThunk::HandleIncomingMessageThunk(Router* router)
 Router::HandleIncomingMessageThunk::~HandleIncomingMessageThunk() {
 }
 
-bool Router::HandleIncomingMessageThunk::Accept(Message* message) {
+MessageReceiver::Result Router::HandleIncomingMessageThunk::Accept(
+    Message* message) {
   return router_->HandleIncomingMessage(message);
 }
 
@@ -138,13 +139,15 @@ Router::Router(ScopedMessagePipeHandle message_pipe,
 
 Router::~Router() {}
 
-bool Router::Accept(Message* message) {
+MessageReceiver::Result Router::Accept(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!message->has_flag(kMessageExpectsResponse));
   return connector_.Accept(message);
 }
 
-bool Router::AcceptWithResponder(Message* message, MessageReceiver* responder) {
+MessageReceiver::Result Router::AcceptWithResponder(
+    Message* message,
+    MessageReceiver* responder) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(message->has_flag(kMessageExpectsResponse));
 
@@ -155,13 +158,13 @@ bool Router::AcceptWithResponder(Message* message, MessageReceiver* responder) {
 
   bool is_sync = message->has_flag(kMessageIsSync);
   message->set_request_id(request_id);
-  if (!connector_.Accept(message))
-    return false;
+  if (!connector_.Accept(message).Succeeded())
+    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;
@@ -183,8 +186,8 @@ bool Router::AcceptWithResponder(Message* message, MessageReceiver* responder) {
     sync_responses_.erase(iter);
   }
 
-  // Return true means that we take ownership of |responder|.
-  return true;
+  // Success means that we take ownership of |responder|.
+  return Result::ForSuccess();
 }
 
 void Router::EnableTestingMode() {
@@ -193,7 +196,7 @@ void Router::EnableTestingMode() {
   connector_.set_enforce_errors_from_incoming_receiver(false);
 }
 
-bool Router::HandleIncomingMessage(Message* message) {
+MessageReceiver::Result Router::HandleIncomingMessage(Message* message) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const bool during_sync_call =
@@ -211,7 +214,7 @@ bool Router::HandleIncomingMessage(Message* message) {
                                 weak_factory_.GetWeakPtr()));
     }
 
-    return true;
+    return Result::ForSuccess();
   }
 
   return HandleMessageInternal(message);
@@ -226,12 +229,12 @@ void Router::HandleQueuedMessages() {
     std::unique_ptr<Message> message(std::move(pending_messages_.front()));
     pending_messages_.pop();
 
-    bool result = HandleMessageInternal(message.get());
+    Result result = HandleMessageInternal(message.get());
     if (!weak_self)
       return;
 
-    if (!result && !testing_mode_) {
-      connector_.RaiseError();
+    if (!result.Succeeded() && !testing_mode_) {
+      connector_.RaiseError(std::move(result));
       break;
     }
   }
@@ -245,17 +248,17 @@ void Router::HandleQueuedMessages() {
     OnConnectionError();
 }
 
-bool Router::HandleMessageInternal(Message* message) {
+MessageReceiver::Result Router::HandleMessageInternal(Message* message) {
   if (message->has_flag(kMessageExpectsResponse)) {
     if (!incoming_receiver_)
-      return false;
+      return Result(Result::Type::REQUEST_DROPPED);
 
     MessageReceiverWithStatus* responder = new ResponderThunk(
         weak_factory_.GetWeakPtr(), connector_.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();
@@ -264,25 +267,25 @@ bool Router::HandleMessageInternal(Message* message) {
       auto it = sync_responses_.find(request_id);
       if (it == sync_responses_.end()) {
         DCHECK(testing_mode_);
-        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()) {
       DCHECK(testing_mode_);
-      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);
   }