Mojo: Add NotifyBadMessage API

mojo/edk/test/mojo_test_base.h

 // Copyright 2016 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_EDK_TEST_MOJO_TEST_BASE_H_
 #define MOJO_EDK_TEST_MOJO_TEST_BASE_H_
 
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 16 matching lines @@
 class MojoTestBase : public testing::Test {
  public:
   MojoTestBase();
   ~MojoTestBase() override;
 
  protected:
   using HandlerCallback = base::Callback<void(ScopedMessagePipeHandle)>;
 
   class ClientController {
    public:
-    ClientController(const std::string& client_name, MojoTestBase* test);
+    ClientController(const std::string& client_name,
+                     MojoTestBase* test,
+                     const ProcessErrorCallback& process_error_callback_);
     ~ClientController();
 
     MojoHandle pipe() const { return pipe_.get().value(); }
 
     int WaitForShutdown();
 
    private:
     friend class MojoTestBase;
 
 #if !defined(OS_IOS)
     MultiprocessTestHelper helper_;
 #endif
     ScopedMessagePipeHandle pipe_;
     bool was_shutdown_ = false;
 
     DISALLOW_COPY_AND_ASSIGN(ClientController);
   };
 
+  // Set the callback to handle bad messages received from test client
+  // processes. This can be set to a different callback before starting each
+  // client.
+  void set_process_error_callback(const ProcessErrorCallback& callback) {
+    process_error_callback_ = callback;
+  }
+
   ClientController& StartClient(const std::string& client_name);
 
   template <typename HandlerFunc>
   void StartClientWithHandler(const std::string& client_name,
                               HandlerFunc handler) {
     int expected_exit_code = 0;
     ClientController& c = StartClient(client_name);
     handler(c.pipe(), &expected_exit_code);
     EXPECT_EQ(expected_exit_code, c.WaitForShutdown());
   }
@@ skipping 71 matching lines @@
   static void WriteData(MojoHandle producer, const std::string& data);
 
   // Reads data from a data pipe.
   static std::string ReadData(MojoHandle consumer, size_t size);
 
  private:
   friend class ClientController;
 
   std::vector<std::unique_ptr<ClientController>> clients_;
 
+  ProcessErrorCallback process_error_callback_;
+
   DISALLOW_COPY_AND_ASSIGN(MojoTestBase);
 };
 
 // Launches a new child process running the test client |client_name| connected
 // to a new message pipe bound to |pipe_name|. |pipe_name| is automatically
 // closed on test teardown.
 #define RUN_CHILD_ON_PIPE(client_name, pipe_name)                   \
     StartClientWithHandler(                                         \
         #client_name,                                               \
         [&](MojoHandle pipe_name, int *expected_exit_code) { {
@@ skipping 58 matching lines @@
 #else  // !defined(OS_IOS)
 #define DEFINE_TEST_CLIENT_WITH_PIPE(client_name, test_base, pipe_name)
 #define DEFINE_TEST_CLIENT_TEST_WITH_PIPE(client_name, test_base, pipe_name)
 #endif  // !defined(OS_IOS)
 
 }  // namespace test
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_TEST_MOJO_TEST_BASE_H_