ipc: Make a common subclass for Channel and ProxyChannel.

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 <string>
 
 #if defined(OS_POSIX)
 #include <sys/types.h>
 #endif
 
 #include "base/compiler_specific.h"
 #include "base/files/scoped_file.h"
 #include "base/process/process.h"
 #include "ipc/ipc_channel_handle.h"
+#include "ipc/ipc_endpoint.h"
 #include "ipc/ipc_message.h"
-#include "ipc/ipc_sender.h"
 
 namespace IPC {
 
 class AttachmentBroker;
 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.
 
-class IPC_EXPORT Channel : public Sender {
+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,
@@ skipping 104 matching lines @@
       AttachmentBroker* broker);
 #endif
   // TODO(erikchen): Remove default parameter for |broker|. It exists only to
   // make the upcoming refactor decomposable into smaller CLs.
   // http://crbug.com/493414.
   static scoped_ptr<Channel> CreateServer(
       const IPC::ChannelHandle& channel_handle,
       Listener* listener,
       AttachmentBroker* broker = nullptr);
 
-  Channel() : attachment_broker_endpoint_(false) {}
   ~Channel() override;
 
   // Connect the pipe.  On the server side, this will initiate
   // waiting for connections.  On the client, it attempts to
   // connect to a pre-existing pipe.  Note, calling Connect()
   // will not block the calling thread and may complete
   // asynchronously.
   virtual bool Connect() WARN_UNUSED_RESULT = 0;
 
   // 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 the process ID for the connected peer.
-  //
-  // Returns base::kNullProcessId if the peer is not connected yet. Watch out
-  // for race conditions. You can easily get a channel to another process, but
-  // if your process has not yet processed the "hello" message from the remote
-  // side, this will fail. You should either make sure calling this is either
-  // in response to a message from the remote side (which guarantees that it's
-  // been connected), or you wait for the "connected" notification on the
-  // listener.
-  virtual base::ProcessId GetPeerPID() const = 0;
-
   // Get its own process id. This value is told to the peer.
   virtual base::ProcessId GetSelfPID() const = 0;
 
   // 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;
 
@@ skipping 39 matching lines @@
   static void SetGlobalPid(int pid);
 #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
-
-  void set_attachment_broker_endpoint(bool is_endpoint) {
-    attachment_broker_endpoint_ = is_endpoint;
-  }
-
- protected:
-  bool is_attachment_broker_endpoint() { return attachment_broker_endpoint_; }
-
- private:
-  // Whether this channel is used as an endpoint for sending and receiving
-  // brokerable attachment messages to/from the broker process.
-  bool attachment_broker_endpoint_;
 };
 
 #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_