Adds associated interface support to IPC::Channel

ipc/ipc_channel.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_H_
 #define IPC_IPC_CHANNEL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/files/scoped_file.h"
 #include "base/process/process.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_endpoint.h"
 #include "ipc/ipc_message.h"
+#include "mojo/public/cpp/bindings/associated_group.h"
+#include "mojo/public/cpp/bindings/associated_interface_ptr.h"
+#include "mojo/public/cpp/bindings/associated_interface_request.h"
+#include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 
 #if defined(OS_POSIX)
 #include <sys/types.h>
 #endif
 
 namespace IPC {
 
 class Listener;
 
 //------------------------------------------------------------------------------
@@ skipping 55 matching lines @@
     HELLO_MESSAGE_TYPE = UINT16_MAX,
     // The CLOSE_FD_MESSAGE_TYPE is used in the IPC class to
     // work around a bug in sendmsg() on Mac. When an FD is sent
     // over the socket, a CLOSE_FD_MESSAGE is sent with hops = 2.
     // The client will return the message with hops = 1, *after* it
     // has received the message that contains the FD. When we
     // receive it again on the sender side, we close the FD.
     CLOSE_FD_MESSAGE_TYPE = HELLO_MESSAGE_TYPE - 1
   };
 
+  // Helper interface a Channel may implement to expose support for associated
+  // Mojo interfaces.
+  class IPC_EXPORT AssociatedInterfaceSupport {
+   public:
+    using GenericAssociatedInterfaceFactory =
+        base::Callback<void(mojo::ScopedInterfaceEndpointHandle)>;
+
+    virtual ~AssociatedInterfaceSupport() {}
+
+    // Accesses the AssociatedGroup used to associate new interface endpoints
+    // with this Channel.
+    virtual mojo::AssociatedGroup* GetAssociatedGroup() = 0;
+
+    // Adds an interface factory to this channel for interface |name|.
+    virtual void AddGenericAssociatedInterface(
+        const std::string& name,
+        const GenericAssociatedInterfaceFactory& factory) = 0;
+
+    // Requests an associated interface from the remote endpoint.
+    virtual void GetGenericRemoteAssociatedInterface(
+        const std::string& name,
+        mojo::ScopedInterfaceEndpointHandle handle) = 0;
+
+    // Template helper to add an interface factory to this channel.
+    template <typename Interface>
+    using AssociatedInterfaceFactory =
+        base::Callback<void(mojo::AssociatedInterfaceRequest<Interface>)>;
+    template <typename Interface>
+    void AddAssociatedInterface(
+        const AssociatedInterfaceFactory<Interface>& factory) {
+      AddGenericAssociatedInterface(
+          Interface::Name_,
+          base::Bind(&BindAssociatedInterfaceRequest<Interface>, factory));
+    }
+
+    // Template helper to request a remote associated interface.
+    template <typename Interface>
+    void GetRemoteAssociatedInterface(
+        mojo::AssociatedInterfacePtr<Interface>* proxy) {
+      mojo::AssociatedInterfaceRequest<Interface> request =
+          mojo::GetProxy(proxy, GetAssociatedGroup());
+      GetGenericRemoteAssociatedInterface(
+          Interface::Name_, request.PassHandle());
+    }
+
+   private:
+    template <typename Interface>
+    static void BindAssociatedInterfaceRequest(
+        const AssociatedInterfaceFactory<Interface>& factory,
+        mojo::ScopedInterfaceEndpointHandle handle) {
+      mojo::AssociatedInterfaceRequest<Interface> request;
+      request.Bind(std::move(handle));
+      factory.Run(std::move(request));
+    }
+  };
+
   // The maximum message size in bytes. Attempting to receive a message of this
   // size or bigger results in a channel error.
   static const size_t kMaximumMessageSize = 128 * 1024 * 1024;
 
   // Amount of data to read at once from the pipe.
   static const size_t kReadBufferSize = 4 * 1024;
 
   // Maximum persistent read buffer size. Read buffer can grow larger to
   // accommodate large messages, but it's recommended to shrink back to this
   // value because it fits 99.9% of all messages (see issue 529940 for data).
@@ skipping 68 matching lines @@
   // Close this Channel explicitly.  May be called multiple times.
   // On POSIX calling close on an IPC channel that listens for connections will
   // cause it to close any accepted connections, and it will stop listening for
   // new connections. If you just want to close the currently accepted
   // connection and listen for new ones, use ResetToAcceptingConnectionState.
   virtual void Close() = 0;
 
   // Get its own process id. This value is told to the peer.
   virtual base::ProcessId GetSelfPID() const = 0;
 
+  // Gets a helper for associating Mojo interfaces with this Channel.
+  //
+  // NOTE: Not all implementations support this.
+  virtual AssociatedInterfaceSupport* GetAssociatedInterfaceSupport();
+
   // Overridden from ipc::Sender.
   // Send a message over the Channel to the listener on the other end.
   //
   // |message| must be allocated using operator new.  This object will be
   // deleted once the contents of the Message have been sent.
   bool Send(Message* message) override = 0;
 
   // IsSendThreadSafe returns true iff it's safe to call |Send| from non-IO
   // threads. This is constant for the lifetime of the |Channel|.
   virtual bool IsSendThreadSafe() const;
@@ skipping 90 matching lines @@
 
 #if defined(OS_POSIX)
 // SocketPair() creates a pair of socket FDs suitable for using with
 // IPC::Channel.
 IPC_EXPORT bool SocketPair(int* fd1, int* fd2);
 #endif
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_H_