Jingle_glue bugfixes.

remoting/jingle_glue/jingle_channel_unittest.cc

Index: remoting/jingle_glue/jingle_channel_unittest.cc
diff --git a/remoting/jingle_glue/jingle_channel_unittest.cc b/remoting/jingle_glue/jingle_channel_unittest.cc
index 94bb137ca1649de217d46fec97c6e4ca03f24dfd..175d69cad1a7776c6941a041aca0e545d94d1115 100644
--- a/remoting/jingle_glue/jingle_channel_unittest.cc
+++ b/remoting/jingle_glue/jingle_channel_unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "base/ref_counted.h"
+#include "base/waitable_event.h"
 #include "media/base/data_buffer.h"
 #include "remoting/jingle_glue/jingle_channel.h"
 #include "remoting/jingle_glue/jingle_thread.h"
@@ -22,7 +23,7 @@ namespace {
 const size_t kBufferSize = 100;
 }  // namespace
 
-class MockCallback : public JingleChannel::Callback {
+class MockJingleChannelCallback : public JingleChannel::Callback {
  public:
   MOCK_METHOD2(OnStateChange, void(JingleChannel*, JingleChannel::State));
   MOCK_METHOD2(OnPacketReceived, void(JingleChannel*,
@@ -44,107 +45,146 @@ class MockStream : public talk_base::StreamInterface {
   MOCK_METHOD2(PostEvent, void(int, int));
 };
 
-TEST(JingleChannelTest, Init) {
-  JingleThread thread;
-
-  MockStream* stream = new MockStream();
-  MockCallback callback;
+class JingleChannelTest : public testing::Test {
+ public:
+  virtual ~JingleChannelTest() { }
+
+  // A helper that calls OnStreamEvent(). Need this because we want
+  // to call it on the jingle thread.
+  static void StreamEvent(JingleChannel* channel,
+                          talk_base::StreamInterface* stream,
+                          int event, int error,
+                          base::WaitableEvent* done_event) {
+    channel->OnStreamEvent(stream, event, error);
+    if (done_event)
+      done_event->Signal();
+  }
+
+  static void OnClosed(bool* called) {
+    *called = true;
+  }
+
+ protected:
+  virtual void SetUp() {
+    stream_ = new MockStream();  // Freed by the channel.
+    channel_ = new JingleChannel(&callback_);
+    channel_->thread_ = &thread_;
+    channel_->stream_.reset(stream_);
+  }
+
+  JingleThread thread_;
+  MockStream* stream_;
+  MockJingleChannelCallback callback_;
+  scoped_refptr<JingleChannel> channel_;
+};
 
-  EXPECT_CALL(*stream, GetState())
+TEST_F(JingleChannelTest, Init) {
+  EXPECT_CALL(*stream_, GetState())
       .Times(1)
       .WillRepeatedly(Return(talk_base::SS_OPENING));
 
-  scoped_refptr<JingleChannel> channel = new JingleChannel(&callback);
-
-  EXPECT_CALL(callback, OnStateChange(channel.get(), JingleChannel::CONNECTING))
+  EXPECT_CALL(callback_, OnStateChange(channel_.get(),
+                                       JingleChannel::CONNECTING))
       .Times(1);
 
-  thread.Start();
+  thread_.Start();
 
-  EXPECT_EQ(JingleChannel::INITIALIZING, channel->state());
-  channel->Init(&thread, stream, "user@domain.com");
-  EXPECT_EQ(JingleChannel::CONNECTING, channel->state());
-  channel->state_ = JingleChannel::CLOSED;
+  EXPECT_EQ(JingleChannel::INITIALIZING, channel_->state());
+  channel_->Init(&thread_, stream_, "user@domain.com");
+  EXPECT_EQ(JingleChannel::CONNECTING, channel_->state());
+  channel_->closed_ = true;
 
-  thread.Stop();
+  thread_.Stop();
 }
 
-TEST(JingleChannelTest, Write) {
-  JingleThread thread;
-  MockStream* stream = new MockStream();  // Freed by the channel.
-  MockCallback callback;
-
+TEST_F(JingleChannelTest, Write) {
   scoped_refptr<media::DataBuffer> data = new media::DataBuffer(kBufferSize);
   data->SetDataSize(kBufferSize);
 
-  EXPECT_CALL(*stream, Write(static_cast<const void*>(data->GetData()),
+  EXPECT_CALL(*stream_, Write(static_cast<const void*>(data->GetData()),
                              kBufferSize, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(kBufferSize),
                       Return(talk_base::SR_SUCCESS)));
 
-  scoped_refptr<JingleChannel> channel = new JingleChannel(&callback);
-
-  channel->thread_ = &thread;
-  channel->stream_.reset(stream);
-  channel->state_ = JingleChannel::OPEN;
-  thread.Start();
-  channel->Write(data);
-  thread.Stop();
-  channel->state_ = JingleChannel::CLOSED;
+  channel_->state_ = JingleChannel::OPEN;
+  thread_.Start();
+  channel_->Write(data);
+  thread_.Stop();
+  channel_->closed_ = true;
 }
 
-TEST(JingleChannelTest, Read) {
-  JingleThread thread;
-  MockStream* stream = new MockStream();  // Freed by the channel.
-  MockCallback callback;
-
+TEST_F(JingleChannelTest, Read) {
   scoped_refptr<media::DataBuffer> data = new media::DataBuffer(kBufferSize);
   data->SetDataSize(kBufferSize);
 
-  scoped_refptr<JingleChannel> channel = new JingleChannel(&callback);
-
-  EXPECT_CALL(callback, OnPacketReceived(channel.get(), _))
+  EXPECT_CALL(callback_, OnPacketReceived(channel_.get(), _))
       .Times(1);
 
-  EXPECT_CALL(*stream, GetAvailable(_))
+  EXPECT_CALL(*stream_, GetAvailable(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(kBufferSize),
                       Return(true)))
       .WillOnce(DoAll(SetArgumentPointee<0>(0),
                       Return(true)));
 
-  EXPECT_CALL(*stream, Read(_, kBufferSize, _, _))
+  EXPECT_CALL(*stream_, Read(_, kBufferSize, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(kBufferSize),
                       Return(talk_base::SR_SUCCESS)));
 
-  channel->thread_ = &thread;
-  channel->stream_.reset(stream);
-  channel->state_ = JingleChannel::OPEN;
-  thread.Start();
-  channel->OnStreamEvent(stream, talk_base::SE_READ, 0);
-  thread.Stop();
-  channel->state_ = JingleChannel::CLOSED;
+  channel_->state_ = JingleChannel::OPEN;
+  thread_.Start();
+
+  base::WaitableEvent done_event(true, false);
+  thread_.message_loop()->PostTask(FROM_HERE, NewRunnableFunction(
+      &JingleChannelTest::StreamEvent, channel_.get(), stream_,
+      talk_base::SE_READ, 0, &done_event));
+  done_event.Wait();
+
+  thread_.Stop();
+
+  channel_->closed_ = true;
 }
 
-TEST(JingleChannelTest, Close) {
-  JingleThread thread;
-  MockStream* stream = new MockStream();  // Freed by the channel.
-  MockCallback callback;
+TEST_F(JingleChannelTest, Close) {
+  EXPECT_CALL(*stream_, Close()).Times(1);
+  // Don't expect any calls except Close().
+  EXPECT_CALL(*stream_, GetAvailable(_)).Times(0);
+  EXPECT_CALL(*stream_, Read(_, _, _, _)).Times(0);
+  EXPECT_CALL(callback_, OnPacketReceived(_, _)).Times(0);
+
+  thread_.Start();
+  channel_->Close();
+  // Verify that the channel doesn't call callback anymore.
+  thread_.message_loop()->PostTask(FROM_HERE, NewRunnableFunction(
+      &JingleChannelTest::StreamEvent, channel_.get(), stream_,
+      talk_base::SE_READ, 0, static_cast<base::WaitableEvent*>(NULL)));
+  thread_.Stop();
+}
 
-  EXPECT_CALL(*stream, Close())
+TEST_F(JingleChannelTest, ClosedTask) {
+  EXPECT_CALL(*stream_, Close())
       .Times(1);
 
-  scoped_refptr<JingleChannel> channel = new JingleChannel(&callback);
-
-  channel->thread_ = &thread;
-  channel->stream_.reset(stream);
-  channel->state_ = JingleChannel::OPEN;
+  thread_.Start();
+  bool closed = false;
+  channel_->Close(NewRunnableFunction(&JingleChannelTest::OnClosed,
+                                      &closed));
+  thread_.Stop();
+  EXPECT_TRUE(closed);
+}
 
-  EXPECT_CALL(callback, OnStateChange(channel.get(), JingleChannel::CLOSED))
+TEST_F(JingleChannelTest, DoubleClose) {
+  EXPECT_CALL(*stream_, Close())
       .Times(1);
 
-  thread.Start();
-  channel->Close();
-  thread.Stop();
+  thread_.Start();
+  bool closed1 = false;
+  channel_->Close(NewRunnableFunction(&JingleChannelTest::OnClosed,
+                                     &closed1));
+  bool closed2 = false;
+  channel_->Close(NewRunnableFunction(&JingleChannelTest::OnClosed,
+                                     &closed2));
+  thread_.Stop();
+  EXPECT_TRUE(closed1 && closed2);
 }
 
 }  // namespace remoting