Refactor VideoStub interface to accept ownership of video packets.

remoting/protocol/message_reader_unittest.cc

Index: remoting/protocol/message_reader_unittest.cc
diff --git a/remoting/protocol/message_reader_unittest.cc b/remoting/protocol/message_reader_unittest.cc
index 30115d129be51840dd0d9fedb54748e0a4c321ed..f178d8e351641b1770134cca1d6bc2065b6237fb 100644
--- a/remoting/protocol/message_reader_unittest.cc
+++ b/remoting/protocol/message_reader_unittest.cc
@@ -8,6 +8,7 @@
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
+#include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "net/socket/socket.h"
@@ -30,13 +31,13 @@ const char kTestMessage1[] = "Message1";
 const char kTestMessage2[] = "Message2";
 
 ACTION(CallDoneTask) {
-  arg1.Run();
-}
+  arg0.Run();
 }
+}  // namespace
 
 class MockMessageReceivedCallback {
  public:
-  MOCK_METHOD2(OnMessage, void(CompoundBuffer*, const base::Closure&));
+  MOCK_METHOD1(OnMessage, void(const base::Closure&));
 };
 
 class MessageReaderTest : public testing::Test {
@@ -46,22 +47,25 @@ class MessageReaderTest : public testing::Test {
         run_task_finished_(false, false) {
   }
 
-  void RunDoneTaskOnOtherThread(CompoundBuffer* buffer,
-                                const base::Closure& done_task) {
+  void RunDoneTaskOnOtherThread(const base::Closure& done_task) {
     other_thread_.message_loop()->PostTask(
         FROM_HERE,
-        base::Bind(&MessageReaderTest::RunAndDeleteTask,
+        base::Bind(&MessageReaderTest::RunClosure,
                    base::Unretained(this), done_task));
   }
 
  protected:
-  virtual void SetUp() {
+  virtual void SetUp() OVERRIDE {
     reader_ = new MessageReader();
   }
 
+  virtual void TearDown() OVERRIDE {
+    STLDeleteElements(&messages_);
+  }
+
   void InitReader() {
     reader_->Init(&socket_, base::Bind(
-        &MockMessageReceivedCallback::OnMessage, base::Unretained(&callback_)));
+        &MessageReaderTest::OnMessage, base::Unretained(this)));
   }
 
   void AddMessage(const std::string& message) {
@@ -77,43 +81,48 @@ class MessageReaderTest : public testing::Test {
     return result == expected;
   }
 
-  void RunAndDeleteTask(const base::Closure& task) {
+  void RunClosure(const base::Closure& task) {
     task.Run();
     run_task_finished_.Signal();
   }
 
+  void OnMessage(scoped_ptr<CompoundBuffer> buffer,
+                 const base::Closure& done_callback) {
+    messages_.push_back(buffer.release());
+    callback_.OnMessage(done_callback);
+  }
+
   MessageLoop message_loop_;
   base::Thread other_thread_;
   base::WaitableEvent run_task_finished_;
   scoped_refptr<MessageReader> reader_;
   FakeSocket socket_;
   MockMessageReceivedCallback callback_;
+  std::vector<CompoundBuffer*> messages_;
 };
 
 // Receive one message and process it with delay
 TEST_F(MessageReaderTest, OneMessage_Delay) {
-  CompoundBuffer* buffer;
   base::Closure done_task;
 
   AddMessage(kTestMessage1);
 
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(1)
-      .WillOnce(DoAll(SaveArg<0>(&buffer),
-                      SaveArg<1>(&done_task)));
+      .WillOnce(SaveArg<0>(&done_task));
 
   InitReader();
 
   Mock::VerifyAndClearExpectations(&callback_);
   Mock::VerifyAndClearExpectations(&socket_);
 
-  EXPECT_TRUE(CompareResult(buffer, kTestMessage1));
+  EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
 
   // Verify that the reader starts reading again only after we've
   // finished processing the previous message.
   EXPECT_FALSE(socket_.read_pending());
 
-  RunAndDeleteTask(done_task);
+  done_task.Run();
 
   EXPECT_TRUE(socket_.read_pending());
 }
@@ -122,49 +131,46 @@ TEST_F(MessageReaderTest, OneMessage_Delay) {
 TEST_F(MessageReaderTest, OneMessage_Instant) {
   AddMessage(kTestMessage1);
 
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(1)
       .WillOnce(CallDoneTask());
 
   InitReader();
 
   EXPECT_TRUE(socket_.read_pending());
+  EXPECT_EQ(1U, messages_.size());
 }
 
 // Receive two messages in one packet.
 TEST_F(MessageReaderTest, TwoMessages_Together) {
-  CompoundBuffer* buffer1;
   base::Closure done_task1;
-  CompoundBuffer* buffer2;
   base::Closure done_task2;
 
   AddMessage(kTestMessage1);
   AddMessage(kTestMessage2);
 
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(2)
-      .WillOnce(DoAll(SaveArg<0>(&buffer1),
-                      SaveArg<1>(&done_task1)))
-      .WillOnce(DoAll(SaveArg<0>(&buffer2),
-                      SaveArg<1>(&done_task2)));
+      .WillOnce(SaveArg<0>(&done_task1))
+      .WillOnce(SaveArg<0>(&done_task2));
 
   InitReader();
 
   Mock::VerifyAndClearExpectations(&callback_);
   Mock::VerifyAndClearExpectations(&socket_);
 
-  EXPECT_TRUE(CompareResult(buffer1, kTestMessage1));
-  EXPECT_TRUE(CompareResult(buffer2, kTestMessage2));
+  EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
+  EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
 
   // Verify that the reader starts reading again only after we've
   // finished processing the previous message.
   EXPECT_FALSE(socket_.read_pending());
 
-  RunAndDeleteTask(done_task1);
+  done_task1.Run();
 
   EXPECT_FALSE(socket_.read_pending());
 
-  RunAndDeleteTask(done_task2);
+  done_task2.Run();
 
   EXPECT_TRUE(socket_.read_pending());
 }
@@ -172,30 +178,28 @@ TEST_F(MessageReaderTest, TwoMessages_Together) {
 // Receive two messages in one packet, and process the first one
 // instantly.
 TEST_F(MessageReaderTest, TwoMessages_Instant) {
-  CompoundBuffer* buffer2;
   base::Closure done_task2;
 
   AddMessage(kTestMessage1);
   AddMessage(kTestMessage2);
 
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(2)
       .WillOnce(CallDoneTask())
-      .WillOnce(DoAll(SaveArg<0>(&buffer2),
-                      SaveArg<1>(&done_task2)));
+      .WillOnce(SaveArg<0>(&done_task2));
 
   InitReader();
 
   Mock::VerifyAndClearExpectations(&callback_);
   Mock::VerifyAndClearExpectations(&socket_);
 
-  EXPECT_TRUE(CompareResult(buffer2, kTestMessage2));
+  EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
 
   // Verify that the reader starts reading again only after we've
   // finished processing the second message.
   EXPECT_FALSE(socket_.read_pending());
 
-  RunAndDeleteTask(done_task2);
+  done_task2.Run();
 
   EXPECT_TRUE(socket_.read_pending());
 }
@@ -206,7 +210,7 @@ TEST_F(MessageReaderTest, TwoMessages_Instant2) {
   AddMessage(kTestMessage1);
   AddMessage(kTestMessage2);
 
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(2)
       .WillOnce(CallDoneTask())
       .WillOnce(CallDoneTask());
@@ -218,45 +222,42 @@ TEST_F(MessageReaderTest, TwoMessages_Instant2) {
 
 // Receive two messages in separate packets.
 TEST_F(MessageReaderTest, TwoMessages_Separately) {
-  CompoundBuffer* buffer;
   base::Closure done_task;
 
   AddMessage(kTestMessage1);
 
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(1)
-      .WillOnce(DoAll(SaveArg<0>(&buffer),
-                      SaveArg<1>(&done_task)));
+      .WillOnce(SaveArg<0>(&done_task));
 
   InitReader();
 
   Mock::VerifyAndClearExpectations(&callback_);
   Mock::VerifyAndClearExpectations(&socket_);
 
-  EXPECT_TRUE(CompareResult(buffer, kTestMessage1));
+  EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
 
   // Verify that the reader starts reading again only after we've
   // finished processing the previous message.
   EXPECT_FALSE(socket_.read_pending());
 
-  RunAndDeleteTask(done_task);
+  done_task.Run();
 
   EXPECT_TRUE(socket_.read_pending());
 
   // Write another message and verify that we receive it.
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(1)
-      .WillOnce(DoAll(SaveArg<0>(&buffer),
-                      SaveArg<1>(&done_task)));
+      .WillOnce(SaveArg<0>(&done_task));
   AddMessage(kTestMessage2);
 
-  EXPECT_TRUE(CompareResult(buffer, kTestMessage2));
+  EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
 
   // Verify that the reader starts reading again only after we've
   // finished processing the previous message.
   EXPECT_FALSE(socket_.read_pending());
 
-  RunAndDeleteTask(done_task);
+  done_task.Run();
 
   EXPECT_TRUE(socket_.read_pending());
 }
@@ -264,11 +265,10 @@ TEST_F(MessageReaderTest, TwoMessages_Separately) {
 // Verify that socket operations occur on same thread, even when the OnMessage()
 // callback triggers |done_task| to run on a different thread.
 TEST_F(MessageReaderTest, UseSocketOnCorrectThread) {
-
   AddMessage(kTestMessage1);
   other_thread_.Start();
 
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(1)
       .WillOnce(Invoke(this, &MessageReaderTest::RunDoneTaskOnOtherThread));
 
@@ -278,16 +278,14 @@ TEST_F(MessageReaderTest, UseSocketOnCorrectThread) {
   message_loop_.RunAllPending();
 
   // Write another message and verify that we receive it.
-  CompoundBuffer* buffer;
   base::Closure done_task;
-  EXPECT_CALL(callback_, OnMessage(_, _))
+  EXPECT_CALL(callback_, OnMessage(_))
       .Times(1)
-      .WillOnce(DoAll(SaveArg<0>(&buffer),
-                      SaveArg<1>(&done_task)));
+      .WillOnce(SaveArg<0>(&done_task));
   AddMessage(kTestMessage2);
-  EXPECT_TRUE(CompareResult(buffer, kTestMessage2));
+  EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
 
-  RunAndDeleteTask(done_task);
+  done_task.Run();
 }
 
 }  // namespace protocol