Mojo: Report bindings validation errors via MojoNotifyBadMessage

mojo/public/cpp/bindings/lib/connector.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_
 
 #include <memory>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_checker.h"
 #include "mojo/public/cpp/bindings/callback.h"
+#include "mojo/public/cpp/bindings/error.h"
 #include "mojo/public/cpp/bindings/lib/sync_handle_watcher.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/public/cpp/system/watcher.h"
 
 namespace base {
 class Lock;
 }
 
 namespace mojo {
@@ skipping 67 matching lines @@
   // Enters the error state. The upper layer may do this for unrecoverable
   // issues such as invalid messages are received. If a connection error handler
   // has been set, it will be called asynchronously.
   //
   // It is a no-op if the connector is already in the error state or there isn't
   // a bound message pipe. Otherwise, it closes the message pipe, which notifies
   // the other end and also prevents potential danger (say, the caller raises
   // an error because it believes the other end is malicious). In order to
   // appear to the user that the connector still binds to a message pipe, it
   // creates a new message pipe, closes one end and binds to the other.
-  void RaiseError();
+  void RaiseError(Error error);
 
   // Is the connector bound to a MessagePipe handle?
   bool is_valid() const {
     DCHECK(thread_checker_.CalledOnValidThread());
     return message_pipe_.is_valid();
   }
 
   // Waits for the next message on the pipe, blocking until one arrives,
   // |deadline| elapses, or an error happens. Returns |true| if a message has
   // been delivered, |false| otherwise.
   bool WaitForIncomingMessage(MojoDeadline deadline);
 
   // See Binding for details of pause/resume.
   void PauseIncomingMethodCallProcessing();
   void ResumeIncomingMethodCallProcessing();
 
   // MessageReceiver implementation:
-  bool Accept(Message* message) override;
+  bool Accept(Message* message, Error* error) override;
 
   MessagePipeHandle handle() const {
     DCHECK(thread_checker_.CalledOnValidThread());
     return message_pipe_.get();
   }
 
   // Allows |message_pipe_| to be watched while others perform sync handle
   // watching on the same thread. Please see comments of
   // SyncHandleWatcher::AllowWokenUpBySyncWatchOnSameThread().
   void AllowWokenUpBySyncWatchOnSameThread();
@@ skipping 73 matching lines @@
   base::WeakPtr<Connector> weak_self_;
   base::WeakPtrFactory<Connector> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Connector);
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_