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 MyObserver : public IPC::TestSink::Observer {
+//     public:

[noelutz, 2011/01/28 02:13:06]

nit: indentation is wrong I think.

[Brian Ryner, 2011/01/28 20:43:07]

Done.

+//       virtual void OnMessageReceived(const IPC::Message& msg) {
+//         <do something with the message>
+//         MessageLoop::current()->Quit();
+//       }
+//   };
+//
+//   MyObserver observer;
+//   test_sink.AddObserver(&observer);
+//   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:
+  // Callers can register as an observer to be notified for each message
+  // that is sent to the TestSink.
+  class Observer {
+   public:
+    virtual ~Observer() {}
+
+    // OnMessageReceived is called after each message is added to the TestSink.
+    virtual void OnMessageReceived(const Message& msg) = 0;
+  };
+
   TestSink();
   ~TestSink();
 
   // Interface in IPC::Channel. This copies the message to the sink and then
   // deletes it.
   virtual bool Send(IPC::Message* message);
 
   // Used by the source of the messages to send the message to the sink. This
   // will make a copy of the message and store it in the list.
   bool OnMessageReceived(const Message& msg);
@@ skipping 14 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 observer to the TestSink.
+  void AddObserver(Observer* obs);
+
+  // Removes the given observer from the TestSink.
+  void RemoveObserver(Observer* obs);
+
  private:
   // The actual list of received messages.
   std::vector<Message> messages_;
+  ObserverList<Observer> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSink);
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_TEST_SINK_H_