Decouple IPC::MessageFilter from IPC::Channel

ipc/message_filter.h

 // Copyright 2014 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_MESSAGE_FILTER_H_
 #define IPC_MESSAGE_FILTER_H_
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "ipc/ipc_export.h"
 
 namespace IPC {
 
-class Channel;
+class Sender;
 class Message;
 
 // 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> {
  public:
   MessageFilter();
 
   // Called on the background thread to provide the filter with access to the
   // channel.  Called when the IPC channel is initialized or when AddFilter
   // is called if the channel is already initialized.
-  virtual void OnFilterAdded(Channel* channel);
+  virtual void OnFilterAdded(Sender* sender);
 
   // Called on the background thread when the filter has been removed from
   // the ChannelProxy and when the Channel is closing.  After a filter is
   // removed, it will not be called again.
   virtual void OnFilterRemoved();
 
   // Called to inform the filter that the IPC channel is connected and we
   // have received the internal Hello message from the peer.
-  virtual void OnChannelConnected(int32 peer_pid);
+  virtual void OnSenderConnected();

[darin (slow to review), 2014/06/10 19:39:15]

I think it is a bit awkward to use the term Sender in these methods. It is not
the sender that is connected exactly. It is the channel that became connected.
Maybe it is still OK to use the term "Channel" here? I get that OnFilterAdded
only provides a Sender. That makes sense. It doesn't have to be a channel for
these methods to make sense using the term channel, right?

 
   // Called when there is an error on the channel, typically that the channel
   // has been closed.
-  virtual void OnChannelError();
+  virtual void OnSenderError();
 
   // Called to inform the filter that the IPC channel will be destroyed.
   // OnFilterRemoved is called immediately after this.
-  virtual void OnChannelClosing();
+  virtual void OnSenderClosing();
 
   // Return true to indicate that the message was handled, or false to let
   // the message be handled in the default way.
   virtual bool OnMessageReceived(const Message& message);
 
   // Called to query the Message classes supported by the filter.  Return
   // false to indicate that all message types should reach the filter, or true
   // if the resulting contents of |supported_message_classes| may be used to
   // selectively offer messages of a particular class to the filter.
   virtual bool GetSupportedMessageClasses(
       std::vector<uint32>* supported_message_classes) const;
 
  protected:
   virtual ~MessageFilter();
 
  private:
   friend class base::RefCountedThreadSafe<MessageFilter>;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_MESSAGE_FILTER_H_