Add support for attaching filters to an IPC TestSink.

ipc/ipc_test_sink.h

 // Copyright (c) 2011 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_TEST_SINK_H_
 #define IPC_IPC_TEST_SINK_H_
 #pragma once
 
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/observer_list.h"
 #include "ipc/ipc_channel.h"
 
 namespace IPC {
 
 class Message;
 
 // This test sink provides a "sink" for IPC messages that are sent. It allows
 // the caller to query messages received in various different ways.  It is
 // designed for tests for objects that use the IPC system.
 //
@@ skipping 11 matching lines @@
 //   // this: IPC_MESSAGE_ROUTED2(ViewMsg_Foo, bool, int)
 //   IPC::Message* msg = test_sink.GetFirstMessageMatching(ViewMsg_Foo::ID));
 //   ASSERT_TRUE(msg);
 //   bool first_param;
 //   int second_param;
 //   ViewMsg_Foo::Read(msg, &first_param, &second_param);
 //
 //   // Go on to the next phase of the test.
 //   test_sink.ClearMessages();
 //
+// You can also register to be notified when messages are posted to the sink.
+// This can be useful if you need to wait for a particular message that will
+// be posted asynchronously.  Example usage:
+//
+//   class MyListener : public IPC::Channel::Listener {
+//    public:
+//     virtual bool OnMessageReceived(const IPC::Message& msg) {
+//       <do something with the message>
+//       MessageLoop::current()->Quit();
+//       return false;  // to store the message in the sink, or true to drop it
+//     }
+//   };
+//
+//   MyListener listener;
+//   test_sink.AddFilter(&listener);
+//   StartSomeAsynchronousProcess(&test_sink);
+//   MessageLoop::current()->Run();
+//   <inspect the results>
+//   ...
+//
 // To hook up the sink, all you need to do is call OnMessageReceived when a
 // message is received.
 class TestSink : public Channel {
  public:
   TestSink();
   ~TestSink();
 
   // Interface in IPC::Channel. This copies the message to the sink and then
   // deletes it.
   virtual bool Send(IPC::Message* message);
@@ skipping 18 matching lines @@
   // valid until another message is received or the list is cleared.
   const Message* GetFirstMessageMatching(uint32 id) const;
 
   // Returns the message with the given ID in the queue. If there is no such
   // message or there is more than one of that message, this will return NULL
   // (with the expectation that you'll do an ASSERT_TRUE() on the result).
   // The returned pointer will only be valid until another message is received
   // or the list is cleared.
   const Message* GetUniqueMessageMatching(uint32 id) const;
 
+  // Adds the given listener as a filter to the TestSink.
+  // When a message is received by the TestSink, it will be dispatched to
+  // the filters, in the order they were added.  If a filter returns true
+  // from OnMessageReceived, subsequent filters will not receive the message
+  // and the TestSink will not store it.
+  void AddFilter(Channel::Listener* filter);
+
+  // Removes the given filter from the TestSink.
+  void RemoveFilter(Channel::Listener* filter);
+
  private:
   // The actual list of received messages.
   std::vector<Message> messages_;
+  ObserverList<Channel::Listener> filter_list_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSink);
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_TEST_SINK_H_