Revert of 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_