Mojo: Report bindings validation errors via MojoNotifyBadMessage

mojo/public/cpp/bindings/lib/connector.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/lib/connector.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 69 matching lines @@
 }
 
 ScopedMessagePipeHandle Connector::PassMessagePipe() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CancelWait();
   MayAutoLock locker(lock_.get());
   return std::move(message_pipe_);
 }
 
-void Connector::RaiseError() {
+void Connector::RaiseError(Error error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  // If this was a message validation error, notify the system of a bad message.
+  if (error.type() == Error::Type::BAD_MESSAGE)
+    error.message().NotifyBadMessage(error.details());
+
   HandleError(true, true);
 }
 
 bool Connector::WaitForIncomingMessage(MojoDeadline deadline) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (error_)
     return false;
 
   ResumeIncomingMethodCallProcessing();
@@ skipping 25 matching lines @@
 void Connector::ResumeIncomingMethodCallProcessing() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!paused_)
     return;
 
   paused_ = false;
   WaitToReadMore();
 }
 
-bool Connector::Accept(Message* message) {
+bool Connector::Accept(Message* message, Error* error) {
   DCHECK(lock_ || thread_checker_.CalledOnValidThread());
 
   // It shouldn't hurt even if |error_| may be changed by a different thread at
   // the same time. The outcome is that we may write into |message_pipe_| after
   // encountering an error, which should be fine.
-  if (error_)
+  if (error_) {
+    *error = Error(Error::Type::SEND_FAILED);
     return false;
+  }
 
   MayAutoLock locker(lock_.get());
 
   if (!message_pipe_.is_valid() || drop_writes_)
     return true;
 
   MojoResult rv =
       WriteMessageNew(message_pipe_.get(), message->TakeMojoMessage(),
                       MOJO_WRITE_MESSAGE_FLAG_NONE);
 
@@ skipping 16 matching lines @@
       //     regardless of which thread that two-phase read/write is happening
       //     on).
       // TODO(vtl): I wonder if this should be a |DCHECK()|. (But, until
       // crbug.com/389666, etc. are resolved, this will make tests fail quickly
       // rather than hanging.)
       CHECK(false) << "Race condition or other bug detected";
       return false;
     default:
       // This particular write was rejected, presumably because of bad input.
       // The pipe is not necessarily in a bad state.
+      *error = Error(Error::Type::SEND_FAILED);
       return false;
   }
   return true;
 }
 
 void Connector::AllowWokenUpBySyncWatchOnSameThread() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   allow_woken_up_by_others_ = true;
 
@@ skipping 67 matching lines @@
   bool receiver_result = false;
 
   // Detect if |this| was destroyed during message dispatch. Allow for the
   // possibility of re-entering ReadMore() through message dispatch.
   base::WeakPtr<Connector> weak_self = weak_self_;
 
   Message message;
   const MojoResult rv = ReadMessage(message_pipe_.get(), &message);
   *read_result = rv;
 
-  if (rv == MOJO_RESULT_OK) {
-    receiver_result =
-        incoming_receiver_ && incoming_receiver_->Accept(&message);
+  if (rv == MOJO_RESULT_OK && incoming_receiver_) {
+    Error error(Error::Type::NONE);
+    receiver_result = incoming_receiver_->Accept(&message, &error);
+    if (!receiver_result && error.type() == Error::Type::BAD_MESSAGE)
+      error.message().NotifyBadMessage(error.details());
   }
 
   if (!weak_self)
     return false;
 
   if (rv == MOJO_RESULT_SHOULD_WAIT)
     return true;
 
   if (rv != MOJO_RESULT_OK) {
     HandleError(rv != MOJO_RESULT_FAILED_PRECONDITION, false);
@@ skipping 65 matching lines @@
   if (sync_watcher_)
     return;
   sync_watcher_.reset(new SyncHandleWatcher(
       message_pipe_.get(), MOJO_HANDLE_SIGNAL_READABLE,
       base::Bind(&Connector::OnSyncHandleWatcherHandleReady,
                  base::Unretained(this))));
 }
 
 }  // namespace internal
 }  // namespace mojo