Storing raw audio sink for default audio track.

talk/media/webrtc/webrtcvoiceengine_unittest.cc

 /*
  * libjingle
  * Copyright 2008 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 54 matching lines @@
                             engine,  // base
                             engine,  // codec
                             engine,  // hw
                             engine,  // network
                             engine,  // rtp
                             engine) {  // volume
   }
 };
 }  // namespace
 
+class FakeAudioSink : public rtc::RefCountedObject<webrtc::AudioSinkInterface> {
+ public:
+  void OnData(const Data& audio) override {}
+};
+
 class WebRtcVoiceEngineTestFake : public testing::Test {
  public:
   WebRtcVoiceEngineTestFake()
       : call_(webrtc::Call::Config()),
         engine_(new FakeVoEWrapper(&voe_)),
         channel_(nullptr) {
     send_parameters_.codecs.push_back(kPcmuCodec);
     recv_parameters_.codecs.push_back(kPcmuCodec);
   }
   bool SetupEngine() {
@@ skipping 33 matching lines @@
     delete channel_;
     engine_.Terminate();
   }
 
   const cricket::FakeAudioSendStream& GetSendStream(uint32_t ssrc) {
     const auto* send_stream = call_.GetAudioSendStream(ssrc);
     EXPECT_TRUE(send_stream);
     return *send_stream;
   }
 
+  const cricket::FakeAudioReceiveStream& GetRecvStream(uint32_t ssrc) {
+    const auto* recv_stream = call_.GetAudioReceiveStream(ssrc);
+    EXPECT_TRUE(recv_stream);
+    return *recv_stream;
+  }
+
   const webrtc::AudioSendStream::Config& GetSendStreamConfig(uint32_t ssrc) {
     const auto* send_stream = call_.GetAudioSendStream(ssrc);
     EXPECT_TRUE(send_stream);
     return send_stream->GetConfig();
   }
 
   const webrtc::AudioReceiveStream::Config& GetRecvStreamConfig(uint32_t ssrc) {
     const auto* recv_stream = call_.GetAudioReceiveStream(ssrc);
     EXPECT_TRUE(recv_stream);
     return recv_stream->GetConfig();
@@ skipping 2960 matching lines @@
   // channel of |recv_ch|.This is not a common case, since， normally, only the
   // default channel can be associated. However, the default is not deletable.
   // So we force the |recv_ch| to associate with a non-default channel.
   EXPECT_EQ(0, voe_.AssociateSendChannel(recv_ch, send_ch));
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), send_ch);
 
   EXPECT_TRUE(channel_->RemoveSendStream(2));
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1);
 }
 
+TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSink) {
+  EXPECT_TRUE(SetupEngine());
+  rtc::scoped_refptr<FakeAudioSink> fake_sink = new FakeAudioSink();
+
+  // This should do nothing, since there's no recv stream yet.
+  channel_->SetRawAudioSink(kSsrc1, fake_sink);
+  // Ensure the ref count wasn't incremented.
+  EXPECT_TRUE(fake_sink->HasOneRef());
+
+  EXPECT_TRUE(
+      channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc1)));
+  // Now, the channel should latch on to the sink.
+  channel_->SetRawAudioSink(kSsrc1, fake_sink);
+  EXPECT_FALSE(fake_sink->HasOneRef());
+  EXPECT_EQ(fake_sink, GetRecvStream(kSsrc1).sink());
+
+  // Setting a nullptr should release the reference.
+  channel_->SetRawAudioSink(kSsrc1, nullptr);
+  EXPECT_TRUE(fake_sink->HasOneRef());
+}
+
+TEST_F(WebRtcVoiceEngineTestFake, SetRawAudioSinkDefaultRecvStream) {
+  EXPECT_TRUE(SetupEngine());
+  rtc::scoped_refptr<FakeAudioSink> fake_sink_1 = new FakeAudioSink();
+  rtc::scoped_refptr<FakeAudioSink> fake_sink_2 = new FakeAudioSink();
+
+  // Should be able to set a default sink even when no stream exists.
+  channel_->SetRawAudioSink(0, fake_sink_1);
+  EXPECT_FALSE(fake_sink_1->HasOneRef());
+
+  // Create default channel.
+  DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
+  EXPECT_EQ(fake_sink_1, GetRecvStream(0x01).sink());
+
+  // Should be able to set the default sink after a stream exists.
+  channel_->SetRawAudioSink(0, fake_sink_2);
+  EXPECT_TRUE(fake_sink_1->HasOneRef());
+  EXPECT_FALSE(fake_sink_2->HasOneRef());
+  EXPECT_EQ(fake_sink_2, GetRecvStream(0x01).sink());
+
+  // If we remove and add a default stream, it should get the same sink.
+  EXPECT_TRUE(channel_->RemoveRecvStream(0x01));
+  DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
+  EXPECT_FALSE(fake_sink_2->HasOneRef());
+  EXPECT_EQ(fake_sink_2, GetRecvStream(0x01).sink());
+
+  // Finally, try resetting the default sink.
+  channel_->SetRawAudioSink(0, nullptr);
+  EXPECT_TRUE(fake_sink_2->HasOneRef());
+}
+
 // Tests that the library initializes and shuts down properly.
 TEST(WebRtcVoiceEngineTest, StartupShutdown) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   rtc::scoped_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::VoiceMediaChannel* channel =
       engine.CreateChannel(call.get(), cricket::AudioOptions());
   EXPECT_TRUE(channel != nullptr);
   delete channel;
@@ skipping 120 matching lines @@
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   rtc::scoped_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::AudioOptions(),
                                            call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }