Support generic synchronization against an IPC::Channel

ipc/ipc_channel_proxy.h

 // Copyright (c) 2012 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 IPC_IPC_CHANNEL_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_endpoint.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
+#include "mojo/common/event.mojom.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace IPC {
 
@@ skipping 118 matching lines @@
   // Ordinarily, messages sent to the ChannelProxy are routed to the matching
   // listener on the worker thread.  This API allows code to intercept messages
   // before they are sent to the worker thread.
   // If you call this before the target process is launched, then you're
   // guaranteed to not miss any messages.  But if you call this anytime after,
   // then some messages might be missed since the filter is added internally on
   // the IO thread.
   void AddFilter(MessageFilter* filter);
   void RemoveFilter(MessageFilter* filter);
 
+  // Sends a message to the remote endpoint and returns an Event pipe which will
+  // Signal() once as soon as the remote endpoint receives the message. This
+  // can be used to synchronize against the Channel's message FIFO.
+  mojo::common::mojom::EventRequest CreateSynchronizationEvent();
+
   using GenericAssociatedInterfaceFactory =
       base::Callback<void(mojo::ScopedInterfaceEndpointHandle)>;
 
   // Adds a generic associated interface factory to bind incoming interface
   // requests directly on the IO thread. MUST be called either before Init() or
   // before the remote end of the Channel is able to send messages (e.g. before
   // its process is launched.)
   void AddGenericAssociatedInterfaceForIOThread(
       const std::string& name,
       const GenericAssociatedInterfaceFactory& factory);
@@ skipping 94 matching lines @@
     void OnDispatchMessage(const Message& message);
 
     // Sends |message| from appropriate thread.
     void Send(Message* message);
 
     // Requests a remote associated interface on the IPC thread.
     void GetRemoteAssociatedInterface(
         const std::string& name,
         mojo::ScopedInterfaceEndpointHandle handle);
 
+    // Sends an Event to be signaled by the remote end.
+    void SendEventToSignal(mojo::common::mojom::EventPtr event);
+
    protected:
     friend class base::RefCountedThreadSafe<Context>;
     ~Context() override;
 
     // IPC::Listener methods:
     bool OnMessageReceived(const Message& message) override;
     void OnChannelConnected(int32_t peer_pid) override;
     void OnChannelError() override;
     void OnAssociatedInterfaceRequest(
         const std::string& interface_name,
@@ skipping 140 matching lines @@
   bool did_init_;
 
 #if defined(ENABLE_IPC_FUZZER)
   OutgoingMessageFilter* outgoing_message_filter_;
 #endif
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_