Jingle_glue bugfixes.

remoting/jingle_glue/jingle_channel_unittest.cc

 // 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 "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"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/base/stream.h"
 
 using testing::_;
 using testing::Return;
 using testing::Mock;
 using testing::SetArgumentPointee;
 
 namespace remoting {
 
 namespace {
 // Size of test buffer in bytes.
 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*,
                                       scoped_refptr<media::DataBuffer>));
 };
 
 class MockStream : public talk_base::StreamInterface {
  public:
   virtual ~MockStream() {}
   MOCK_CONST_METHOD0(GetState, talk_base::StreamState());
 
   MOCK_METHOD4(Read, talk_base::StreamResult(void*, size_t, size_t*, int*));
   MOCK_METHOD4(Write, talk_base::StreamResult(const void*, size_t,
                                               size_t*, int*));
   MOCK_CONST_METHOD1(GetAvailable, bool(size_t*));
   MOCK_METHOD0(Close, void());
 
   MOCK_METHOD3(PostEvent, void(talk_base::Thread*, int, int));
   MOCK_METHOD2(PostEvent, void(int, int));
 };
 
-TEST(JingleChannelTest, Init) {
-  JingleThread thread;
+class JingleChannelTest : public testing::Test {
+ public:
+  virtual ~JingleChannelTest() { }
 
-  MockStream* stream = new MockStream();
-  MockCallback callback;
+  // 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();
+  }
 
-  EXPECT_CALL(*stream, GetState())
+  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_;
+};
+
+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);
 
-  EXPECT_CALL(*stream, Close())
+  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();
+}
+
+TEST_F(JingleChannelTest, ClosedTask) {
+  EXPECT_CALL(*stream_, Close())
       .Times(1);
 
-  scoped_refptr<JingleChannel> channel = new JingleChannel(&callback);
+  thread_.Start();
+  bool closed = false;
+  channel_->Close(NewRunnableFunction(&JingleChannelTest::OnClosed,
+                                      &closed));
+  thread_.Stop();
+  EXPECT_TRUE(closed);
+}
 
-  channel->thread_ = &thread;
-  channel->stream_.reset(stream);
-  channel->state_ = JingleChannel::OPEN;
-
-  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