Move IPC::MessageFilter and router to a separate file

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_
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace IPC {
 
+class MessageFilter;
+class MessageFilterRouter;
 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
 // handling IPC messages on that background thread or having them dispatched to
 // your main thread (the thread on which the IPC::ChannelProxy is created).
 //
@@ skipping 12 matching lines @@
 // 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 Sender, public base::NonThreadSafe {
  public:
-
-  // 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);
-
-    // 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);
-
-    // Called when there is an error on the channel, typically that the channel
-    // has been closed.
-    virtual void OnChannelError();
-
-    // Called to inform the filter that the IPC channel will be destroyed.
-    // OnFilterRemoved is called immediately after this.
-    virtual void OnChannelClosing();
-
-    // 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>;
-  };
-
   // 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 task runner correspond to a thread
   // on which IPC::Channel is created and used (e.g. IO thread).
   ChannelProxy(const IPC::ChannelHandle& channel_handle,
                Channel::Mode mode,
                Listener* listener,
                base::SingleThreadTaskRunner* ipc_task_runner);
 
   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);
 
   // Close the IPC::Channel.  This operation completes asynchronously, once the
   // background thread processes the command to close the channel.  It is ok to
   // call this method multiple times.  Redundant calls are ignored.
   //
-  // WARNING: The MessageFilter object held by the ChannelProxy is also
+  // WARNING: MessageFilter objects held by the ChannelProxy is also
   // released asynchronously, and it may in fact have its final reference
   // released on the background thread.  The caller should be careful to deal
   // with / allow for this possibility.
   void Close();
 
   // Send a message asynchronously.  The message is routed to the background
   // thread where it is passed to the IPC::Channel's Send method.
   virtual bool Send(Message* message) OVERRIDE;
 
   // Used to intercept messages as they are received on the background thread.
@@ skipping 94 matching lines @@
 
     // Note, channel_ may be set on the Listener thread or the IPC thread.
     // But once it has been set, it must only be read or cleared on the IPC
     // thread.
     scoped_ptr<Channel> channel_;
     std::string channel_id_;
     bool channel_connected_called_;
 
     // Routes a given message to a proper subset of |filters_|, depending
     // on which message classes a filter might support.
-    class MessageFilterRouter;
     scoped_ptr<MessageFilterRouter> message_filter_router_;
 
     // Holds filters between the AddFilter call on the listerner thread and the
     // IPC thread when they're added to filters_.
     std::vector<scoped_refptr<MessageFilter> > pending_filters_;
     // Lock for pending_filters_.
     base::Lock pending_filters_lock_;
 
     // Cached copy of the peer process ID. Set on IPC but read on both IPC and
     // listener threads.
@@ skipping 10 matching lines @@
   // that involves this data.
   scoped_refptr<Context> context_;
 
   // Whether the channel has been initialized.
   bool did_init_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_