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

ipc/ipc_channel_proxy.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_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 #pragma once
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_handle.h"
+#include "ipc/ipc_listener.h"
+#include "ipc/ipc_sender.h"
 
 namespace IPC {
 
 class SendCallbackHelper;
 
 //-----------------------------------------------------------------------------
 // IPC::ChannelProxy
 //
 // This class is a helper class that is useful when you wish to run an IPC
 // channel on a background thread.  It provides you with the option of either
@@ skipping 13 matching lines @@
 // An IPC::ChannelProxy can have a MessageFilter associated with it, which will
 // be notified of incoming messages on the IPC::Channel's thread.  This gives
 // the consumer of IPC::ChannelProxy the ability to respond to incoming
 // messages on this background thread instead of on their own thread, which may
 // be bogged down with other processing.  The result can be greatly improved
 // latency for messages that can be handled on a background thread.
 //
 // The consumer of IPC::ChannelProxy is responsible for allocating the Thread
 // instance where the IPC::Channel will be created and operated.
 //
-class IPC_EXPORT ChannelProxy : public Message::Sender {
+class IPC_EXPORT ChannelProxy : public Sender {
  public:
-
   struct MessageFilterTraits;
 
   // A class that receives messages on the thread where the IPC channel is
   // running.  It can choose to prevent the default action for an IPC message.
   class IPC_EXPORT MessageFilter
       : public base::RefCountedThreadSafe<MessageFilter, MessageFilterTraits> {
    public:
     MessageFilter();
 
     // Called on the background thread to provide the filter with access to the
@@ skipping 54 matching lines @@
   // Initializes a channel proxy.  The channel_handle and mode parameters are
   // passed directly to the underlying IPC::Channel.  The listener is called on
   // the thread that creates the ChannelProxy.  The filter's OnMessageReceived
   // method is called on the thread where the IPC::Channel is running.  The
   // filter may be null if the consumer is not interested in handling messages
   // on the background thread.  Any message not handled by the filter will be
   // dispatched to the listener.  The given message loop indicates where the
   // IPC::Channel should be created.
   ChannelProxy(const IPC::ChannelHandle& channel_handle,
                Channel::Mode mode,
-               Channel::Listener* listener,
+               Listener* listener,
                base::MessageLoopProxy* ipc_thread_loop);
 
   // Creates an uninitialized channel proxy. Init must be called to receive
   // or send any messages. This two-step setup allows message filters to be
   // added before any messages are sent or received.
-  ChannelProxy(Channel::Listener* listener,
+  ChannelProxy(Listener* listener,
                base::MessageLoopProxy* ipc_thread_loop);
 
   virtual ~ChannelProxy();
 
   // Initializes the channel proxy. Only call this once to initialize a channel
   // proxy that was not initialized in its constructor. If create_pipe_now is
   // true, the pipe is created synchronously. Otherwise it's created on the IO
   // thread.
   void Init(const IPC::ChannelHandle& channel_handle, Channel::Mode mode,
             bool create_pipe_now);
@@ skipping 43 matching lines @@
 #endif  // defined(OS_POSIX)
 
  protected:
   class Context;
   // A subclass uses this constructor if it needs to add more information
   // to the internal state.
   ChannelProxy(Context* context);
 
   // Used internally to hold state that is referenced on the IPC thread.
   class Context : public base::RefCountedThreadSafe<Context>,
-                  public Channel::Listener {
+                  public Listener {
    public:
-    Context(Channel::Listener* listener, base::MessageLoopProxy* ipc_thread);
+    Context(Listener* listener, base::MessageLoopProxy* ipc_thread);
     void ClearIPCMessageLoop() { ipc_message_loop_ = NULL; }
     base::MessageLoopProxy* ipc_message_loop() const {
       return ipc_message_loop_.get();
     }
     const std::string& channel_id() const { return channel_id_; }
 
     // Dispatches a message on the listener thread.
     void OnDispatchMessage(const Message& message);
 
    protected:
     friend class base::RefCountedThreadSafe<Context>;
     virtual ~Context();
 
-    // IPC::Channel::Listener methods:
+    // IPC::Listener methods:
     virtual bool OnMessageReceived(const Message& message) OVERRIDE;
     virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
     virtual void OnChannelError() OVERRIDE;
 
     // Like OnMessageReceived but doesn't try the filters.
     bool OnMessageReceivedNoFilter(const Message& message);
 
     // Gives the filters a chance at processing |message|.
     // Returns true if the message was processed, false otherwise.
     bool TryFilters(const Message& message);
@@ skipping 19 matching lines @@
     void OnSendMessage(scoped_ptr<Message> message_ptr);
     void OnAddFilter();
     void OnRemoveFilter(MessageFilter* filter);
 
     // Methods called on the listener thread.
     void AddFilter(MessageFilter* filter);
     void OnDispatchConnected();
     void OnDispatchError();
 
     scoped_refptr<base::MessageLoopProxy> listener_message_loop_;
-    Channel::Listener* listener_;
+    Listener* listener_;
 
     // List of filters.  This is only accessed on the IPC thread.
     std::vector<scoped_refptr<MessageFilter> > filters_;
     scoped_refptr<base::MessageLoopProxy> ipc_message_loop_;
     scoped_ptr<Channel> channel_;
     std::string channel_id_;
     bool channel_connected_called_;
 
     // Holds filters between the AddFilter call on the listerner thread and the
     // IPC thread when they're added to filters_.
@@ skipping 22 matching lines @@
 
   OutgoingMessageFilter* outgoing_message_filter_;
 
   // Whether the channel has been initialized.
   bool did_init_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_