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 142 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;
 

[yzshen1, 2016/07/13 17:38:42]

It seems cleaner to me to group associated interface support into a separate
interface, say, AssociatedInterfaceSupport, and let IPC::Channel have a getter
for that. WDYT?

+  // Accesses the AssociatedGroup used to associate new interface endpoints with
+  // this Channel.
+  //
+  // NOTE: Not all implementations support this.
+  virtual mojo::AssociatedGroup* GetAssociatedGroup();
+
+  // Adds an interface factory to this channel for interface |name|.
+  //
+  // NOTE: Not all implementations support this.
+  using GenericAssociatedInterfaceFactory =
+      base::Callback<void(mojo::ScopedInterfaceEndpointHandle)>;
+  virtual void AddGenericAssociatedInterface(
+      const std::string& name,
+      const GenericAssociatedInterfaceFactory& factory);
+
+  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));
+  }
+
+  // Requests an associated interface from the remote endpoint.
+  //
+  // NOTE: Not all implementations support this.
+  virtual void GetGenericRemoteAssociatedInterface(
+      const std::string& name,
+      mojo::ScopedInterfaceEndpointHandle handle);
+
+  // Acquires an associated interface proxied to the remote endpoint.
+  template <typename Interface>
+  void GetRemoteAssociatedInterface(
+      mojo::AssociatedInterfacePtr<Interface>* proxy) {
+    mojo::AssociatedInterfaceRequest<Interface> request =
+        mojo::GetProxy(proxy, GetAssociatedGroup());
+    GetGenericRemoteAssociatedInterface(Interface::Name_, request.PassHandle());
+  }
+
   // 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 78 matching lines @@
   };
 
   // Endpoint overrides.
   void OnSetAttachmentBrokerEndpoint() override;
 
   // Subclasses must call this method at the beginning of their implementation
   // of Connect().
   void WillConnect();
 
  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));
+  }
+
   bool did_start_connect_ = false;
 };
 
 #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_