Support generic synchronization against an IPC::Channel

ipc/ipc_channel_proxy.cc

 // 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.
 
 #include "ipc/ipc_channel_proxy.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 411 matching lines @@
     mojo::ScopedInterfaceEndpointHandle handle) {
   if (!channel_)
     return;
   Channel::AssociatedInterfaceSupport* associated_interface_support =
       channel_->GetAssociatedInterfaceSupport();
   DCHECK(associated_interface_support);
   associated_interface_support->GetGenericRemoteAssociatedInterface(
       name, std::move(handle));
 }
 
+// Called on the IPC::Channel thread
+void ChannelProxy::Context::SendEventToSignal(
+    mojo::common::mojom::EventPtr event) {
+  if (channel_)
+    channel_->SendEventToSignal(std::move(event));
+}
+
 //-----------------------------------------------------------------------------
 
 // static
 std::unique_ptr<ChannelProxy> ChannelProxy::Create(
     const IPC::ChannelHandle& channel_handle,
     Channel::Mode mode,
     Listener* listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   std::unique_ptr<ChannelProxy> channel(
       new ChannelProxy(listener, ipc_task_runner));
@@ skipping 135 matching lines @@
 }
 
 void ChannelProxy::RemoveFilter(MessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   context_->ipc_task_runner()->PostTask(
       FROM_HERE, base::Bind(&Context::OnRemoveFilter, context_,
                             base::RetainedRef(filter)));
 }
 
+mojo::common::mojom::EventRequest ChannelProxy::CreateSynchronizationEvent() {
+  mojo::common::mojom::EventPtr event;
+  mojo::common::mojom::EventRequest request = mojo::GetProxy(&event);
+  context_->ipc_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&Context::SendEventToSignal, context_, base::Passed(&event)));
+  return request;
+}
+
 void ChannelProxy::AddGenericAssociatedInterface(
     const std::string& name,
     const GenericAssociatedInterfaceFactory& factory) {
   context()->AddGenericAssociatedInterface(name, factory);
 }
 
 void ChannelProxy::AddGenericAssociatedInterfaceForIOThread(
     const std::string& name,
     const GenericAssociatedInterfaceFactory& factory) {
   context()->AddGenericAssociatedInterfaceForIOThread(name, factory);
@@ skipping 49 matching lines @@
   return channel->TakeClientFileDescriptor();
 }
 #endif
 
 void ChannelProxy::OnChannelInit() {
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC