Changed MessageReader so that it doesn't read from the socket if there are

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
new file mode 100644
index 0000000000000000000000000000000000000000..e150215939ad39c6bc742bdc3188ebc6a7d40a99
--- /dev/null
+++ b/remoting/protocol/message_reader_unittest.cc
@@ -0,0 +1,171 @@
+// Copyright (c) 2010 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.
+
+#include <string>
+
+#include "base/message_loop.h"
+#include "net/socket/socket.h"
+#include "remoting/protocol/fake_session.h"
+#include "remoting/protocol/message_reader.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "third_party/libjingle/source/talk/base/byteorder.h"
+
+using testing::_;
+using testing::DoAll;
+using testing::Mock;
+using testing::SaveArg;
+
+namespace remoting {
+namespace protocol {
+
+class MockMessageReceivedCallback {
+ public:
+  MOCK_METHOD2(OnMessage, void(CompoundBuffer*, Task*));
+};
+
+class MessageReaderTest : public testing::Test {
+ protected:
+  void AddMessage(const std::string& message) {
+    std::string data = std::string(4, ' ') + message;
+    talk_base::SetBE32(const_cast<char*>(data.data()), message.size());
+
+    socket_.AppendInputData(data.data(), data.size());
+  }
+
+  bool CompareResult(CompoundBuffer* buffer, const std::string& expected) {
+    std::string result(buffer->total_bytes(), ' ');
+    buffer->CopyTo(const_cast<char*>(result.data()), result.size());
+    return result == expected;
+  }
+
+  // MessageLoop must be first here, so that is is destroyed the last.
+  MessageLoop message_loop_;
+
+  MessageReader reader_;
+  FakeSocket socket_;
+  MockMessageReceivedCallback callback_;
+};
+
+TEST_F(MessageReaderTest, OneMessage) {
+  CompoundBuffer* buffer;
+  Task* done_task;
+
+  std::string msg1("Message1");
+
+  AddMessage(msg1);
+
+  EXPECT_CALL(callback_, OnMessage(_, _))
+      .Times(1)
+      .WillOnce(DoAll(SaveArg<0>(&buffer),
+                      SaveArg<1>(&done_task)));
+
+  reader_.Init(&socket_, NewCallback(
+      &callback_, &MockMessageReceivedCallback::OnMessage));
+
+  Mock::VerifyAndClearExpectations(&callback_);
+  Mock::VerifyAndClearExpectations(&socket_);
+
+  EXPECT_TRUE(CompareResult(buffer, msg1));
+
+  // Verify that the reader starts reading again only after we've
+  // finished processing the previous message.
+  EXPECT_FALSE(socket_.read_pending());
+
+  done_task->Run();
+
+  EXPECT_TRUE(socket_.read_pending());
+}
+
+TEST_F(MessageReaderTest, TwoMessages_Together) {
+  CompoundBuffer* buffer1;
+  Task* done_task1;
+  CompoundBuffer* buffer2;
+  Task* done_task2;
+
+  std::string msg1("Message1");
+  std::string msg2("Message2");
+
+  AddMessage(msg1);
+  AddMessage(msg2);
+
+  EXPECT_CALL(callback_, OnMessage(_, _))
+      .Times(2)
+      .WillOnce(DoAll(SaveArg<0>(&buffer1),
+                      SaveArg<1>(&done_task1)))
+      .WillOnce(DoAll(SaveArg<0>(&buffer2),
+                      SaveArg<1>(&done_task2)));
+
+  reader_.Init(&socket_, NewCallback(
+      &callback_, &MockMessageReceivedCallback::OnMessage));
+
+  Mock::VerifyAndClearExpectations(&callback_);
+  Mock::VerifyAndClearExpectations(&socket_);
+
+  EXPECT_TRUE(CompareResult(buffer1, msg1));
+  EXPECT_TRUE(CompareResult(buffer2, msg2));
+
+  // Verify that the reader starts reading again only after we've
+  // finished processing the previous message.
+  EXPECT_FALSE(socket_.read_pending());
+
+  done_task1->Run();
+
+  EXPECT_FALSE(socket_.read_pending());
+
+  done_task2->Run();
+
+  EXPECT_TRUE(socket_.read_pending());
+}
+
+TEST_F(MessageReaderTest, TwoMessages_Separately) {
+  CompoundBuffer* buffer;
+  Task* done_task;
+
+  std::string msg1("Message1");
+  std::string msg2("Message2");
+
+  AddMessage(msg1);
+
+  EXPECT_CALL(callback_, OnMessage(_, _))
+      .Times(1)
+      .WillOnce(DoAll(SaveArg<0>(&buffer),
+                      SaveArg<1>(&done_task)));
+
+  reader_.Init(&socket_, NewCallback(
+      &callback_, &MockMessageReceivedCallback::OnMessage));
+
+  Mock::VerifyAndClearExpectations(&callback_);
+  Mock::VerifyAndClearExpectations(&socket_);
+
+  EXPECT_TRUE(CompareResult(buffer, msg1));
+
+  // Verify that the reader starts reading again only after we've
+  // finished processing the previous message.
+  EXPECT_FALSE(socket_.read_pending());
+
+  done_task->Run();
+
+  EXPECT_TRUE(socket_.read_pending());
+
+  // Write another message and verify that we receive it.
+  EXPECT_CALL(callback_, OnMessage(_, _))
+      .Times(1)
+      .WillOnce(DoAll(SaveArg<0>(&buffer),
+                      SaveArg<1>(&done_task)));
+  AddMessage(msg2);
+
+  EXPECT_TRUE(CompareResult(buffer, msg2));
+
+  // Verify that the reader starts reading again only after we've
+  // finished processing the previous message.
+  EXPECT_FALSE(socket_.read_pending());
+
+  done_task->Run();
+
+  EXPECT_TRUE(socket_.read_pending());
+}
+
+}  // namespace protocol
+}  // namespace remoting