Delete IPC::ChannelPosix, IPC::ChannelWin and IPC::AttachmentBroker.

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>
 
@@ skipping 21 matching lines @@
 
 namespace IPC {
 
 class Listener;
 
 //------------------------------------------------------------------------------
 // See
 // http://www.chromium.org/developers/design-documents/inter-process-communication
 // for overview of IPC in Chromium.
 
-// Channels are implemented using named pipes on Windows, and
-// socket pairs (or in some special cases unix domain sockets) on POSIX.
-// On Windows we access pipes in various processes by name.
-// On POSIX we pass file descriptors to child processes and assign names to them
-// in a lookup table.
-// In general on POSIX we do not use unix domain sockets due to security
-// concerns and the fact that they can leave garbage around the file system
-// (MacOS does not support abstract named unix domain sockets).
-// You can use unix domain sockets if you like on POSIX by constructing the
-// the channel with the mode set to one of the NAMED modes. NAMED modes are
-// currently used by automation and service processes.
+// Channels are implemented using mojo message pipes on all platforms other
+// than NaCl.
 
 class IPC_EXPORT Channel : public Endpoint {
   // Security tests need access to the pipe handle.
   friend class ChannelTest;
 
  public:
   // Flags to test modes
   enum ModeFlags {
     MODE_NO_FLAG = 0x0,
     MODE_SERVER_FLAG = 0x1,
     MODE_CLIENT_FLAG = 0x2,
-    MODE_NAMED_FLAG = 0x4,
   };
 
   // Some Standard Modes
   // TODO(morrita): These are under deprecation work. You should use Create*()
   // functions instead.
   enum Mode {
     MODE_NONE = MODE_NO_FLAG,
     MODE_SERVER = MODE_SERVER_FLAG,
     MODE_CLIENT = MODE_CLIENT_FLAG,
-    MODE_NAMED_SERVER = MODE_SERVER_FLAG | MODE_NAMED_FLAG,
-    MODE_NAMED_CLIENT = MODE_CLIENT_FLAG | MODE_NAMED_FLAG,
   };
 
   // Messages internal to the IPC implementation are defined here.
   // Uses Maximum value of message type (uint16_t), to avoid conflicting
   // with normal message types, which are enumeration constants starting from 0.
   enum {
     // The Hello message is sent by the peer when the channel is connected.
     // The message contains just the process id (pid).
     // The message has a special routing_id (MSG_ROUTING_NONE)
     // and type (HELLO_MESSAGE_TYPE).
@@ skipping 100 matching lines @@
       const IPC::ChannelHandle& channel_handle,
       Mode mode,
       Listener* listener);
 
   static std::unique_ptr<Channel> CreateClient(
       const IPC::ChannelHandle& channel_handle,
       Listener* listener,
       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner =
           base::ThreadTaskRunnerHandle::Get());
 
-  // Channels on Windows are named by default and accessible from other
-  // processes. On POSIX channels are anonymous by default and not accessible
-  // from other processes. Named channels work via named unix domain sockets.
-  // On Windows MODE_NAMED_SERVER is equivalent to MODE_SERVER and
-  // MODE_NAMED_CLIENT is equivalent to MODE_CLIENT.
-  static std::unique_ptr<Channel> CreateNamedServer(
-      const IPC::ChannelHandle& channel_handle,
-      Listener* listener);
-  static std::unique_ptr<Channel> CreateNamedClient(
-      const IPC::ChannelHandle& channel_handle,
-      Listener* listener);
   static std::unique_ptr<Channel> CreateServer(
       const IPC::ChannelHandle& channel_handle,
       Listener* listener,
       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner =
           base::ThreadTaskRunnerHandle::Get());
 
   ~Channel() override;
 
   // Connect the pipe.  On the server side, this will initiate
   // waiting for connections.  On the client, it attempts to
@@ skipping 58 matching lines @@
   // This method may only be called on the server side of a channel.
   // This method can be called on any thread.
   virtual int GetClientFileDescriptor() const = 0;
 
   // Same as GetClientFileDescriptor, but transfers the ownership of the
   // file descriptor to the caller.
   // This method can be called on any thread.
   virtual base::ScopedFD TakeClientFileDescriptor() = 0;
 #endif
 
-  // Returns true if a named server channel is initialized on the given channel
-  // ID. Even if true, the server may have already accepted a connection.
-  static bool IsNamedServerInitialized(const std::string& channel_id);
-
 #if !defined(OS_NACL_SFI)
   // Generates a channel ID that's non-predictable and unique.
   static std::string GenerateUniqueRandomChannelID();
 
   // Generates a channel ID that, if passed to the client as a shared secret,
   // will validate that the client's authenticity. On platforms that do not
   // require additional this is simply calls GenerateUniqueRandomChannelID().
   // For portability the prefix should not include the \ character.
   static std::string GenerateVerifiedChannelID(const std::string& prefix);
 #endif
 
   // Deprecated: Create a mojo::MessagePipe directly and release() its handles
   // instead.
   //
   // Generates a pair of channel handles that can be used as the client and
   // server ends of a ChannelMojo. |name_postfix| is ignored.
   static void GenerateMojoChannelHandlePair(
       const std::string& name_postfix,
       IPC::ChannelHandle* handle0,
       IPC::ChannelHandle* handle1);
 
 #if defined(OS_LINUX)
   // Sandboxed processes live in a PID namespace, so when sending the IPC hello
   // message from client to server we need to send the PID from the global
   // PID namespace.
   static void SetGlobalPid(int pid);
   static int GetGlobalPid();
 #endif
 
-#if defined(OS_ANDROID)
-  // Most tests are single process and work the same on all platforms. However
-  // in some cases we want to test multi-process, and Android differs in that it
-  // can't 'exec' after forking. This callback resets any data in the forked
-  // process such that it acts similar to if it was exec'd, for tests.
-  static void NotifyProcessForkedForTesting();
-#endif
-
  protected:
   // An OutputElement is a wrapper around a Message or raw buffer while it is
   // waiting to be passed to the system's underlying IPC mechanism.
   class OutputElement {
    public:
     // Takes ownership of message.
     OutputElement(Message* message);
     // Takes ownership of the buffer. |buffer| is freed via free(), so it
     // must be malloced.
     OutputElement(void* buffer, size_t length);
@@ skipping 12 matching lines @@
   void OnSetAttachmentBrokerEndpoint() override;
 
   // Subclasses must call this method at the beginning of their implementation
   // of Connect().
   void WillConnect();
 
  private:
   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_