Separate out IPC::Message::Sender and channel::Listener into a separate class.

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_
 #pragma once
 
 #include <string>
 
 #if defined(OS_POSIX)
 #include <sys/types.h>
 #endif
 
 #include "base/compiler_specific.h"
 #include "base/process.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_message.h"
+#include "ipc/ipc_message_sender.h"
+
+// TODO(brettw) remove this when the "typedef Sender" is removed below.
+#include "ipc/ipc_channel_listener.h"
 
 namespace IPC {
 
+class ChannelListener;
+
 //------------------------------------------------------------------------------
 // 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 Message::Sender {
+class IPC_EXPORT Channel : public MessageSender {
   // Security tests need access to the pipe handle.
   friend class ChannelTest;
 
  public:
-  // Implemented by consumers of a Channel to receive messages.
-  class IPC_EXPORT Listener {
-   public:
-    virtual ~Listener() {}
-
-    // Called when a message is received.  Returns true iff the message was
-    // handled.
-    virtual bool OnMessageReceived(const Message& message) = 0;
-
-    // Called when the channel is connected and we have received the internal
-    // Hello message from the peer.
-    virtual void OnChannelConnected(int32 peer_pid) {}
-
-    // Called when an error is detected that causes the channel to close.
-    // This method is not called when a channel is closed normally.
-    virtual void OnChannelError() {}
-
-#if defined(OS_POSIX)
-    // Called on the server side when a channel that listens for connections
-    // denies an attempt to connect.
-    virtual void OnChannelDenied() {}
-
-    // Called on the server side when a channel that listens for connections
-    // has an error that causes the listening channel to close.
-    virtual void OnChannelListenError() {}
-#endif  // OS_POSIX
-  };
+  // IPC::ChannelListener used to be IPC::Channel::Listener which prevented
+  // forward declarations. To keep existing code compiling, we provide this
+  // backwards-compatible definition. New code should use IPC::ChannelListener.
+  // TODO(brettw) converto users of this and delete.
+  typedef ChannelListener Listener;
 
   // Flags to test modes
   enum ModeFlags {
     MODE_NO_FLAG = 0x0,
     MODE_SERVER_FLAG = 0x1,
     MODE_CLIENT_FLAG = 0x2,
     MODE_NAMED_FLAG = 0x4,
 #if defined(OS_POSIX)
     MODE_OPEN_ACCESS_FLAG = 0x8, // Don't restrict access based on client UID.
 #endif
@@ skipping 45 matching lines @@
   // ownership of the file descriptor and will close it appropriately, otherwise
   // it will create a new descriptor internally.
   // |mode| specifies whether this Channel is to operate in server mode or
   // client mode.  In server mode, the Channel is responsible for setting up the
   // IPC object, whereas in client mode, the Channel merely connects to the
   // already established IPC object.
   // |listener| receives a callback on the current thread for each newly
   // received message.
   //
   Channel(const IPC::ChannelHandle &channel_handle, Mode mode,
-          Listener* listener);
+          ChannelListener* listener);
 
   virtual ~Channel();
 
   // 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.
   bool Connect() WARN_UNUSED_RESULT;
 
   // 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.
   void Close();
 
   // Modify the Channel's listener.
-  void set_listener(Listener* listener);
+  void set_listener(ChannelListener* listener);
 
   // Get the process ID for the connected peer.
   // Returns base::kNullProcessId if the peer is not connected yet.
   base::ProcessId peer_pid() const;
 
   // 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.
   virtual bool Send(Message* message) OVERRIDE;
@@ skipping 60 matching lines @@
 
  private:
   // PIMPL to which all channel calls are delegated.
   class ChannelImpl;
   ChannelImpl *channel_impl_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_H_