Remove VideoMediaChannel::SetRender().

talk/session/media/channel_unittest.cc

 /*
  * libjingle
  * Copyright 2009 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 108 matching lines @@
       rtc::Pathname(path), "wb");
 }
 
 // Base class for Voice/VideoChannel tests
 template<class T>
 class ChannelTest : public testing::Test, public sigslot::has_slots<> {
  public:
   enum Flags { RTCP = 0x1, RTCP_MUX = 0x2, SECURE = 0x4, SSRC_MUX = 0x8,
                DTLS = 0x10 };
 
-  ChannelTest(const uint8* rtp_data,
+  ChannelTest(bool verify_playout,
+              const uint8* rtp_data,
               int rtp_len,
               const uint8* rtcp_data,
               int rtcp_len)
-      : transport_controller1_(cricket::ICEROLE_CONTROLLING),
+      : verify_playout_(verify_playout),
+        transport_controller1_(cricket::ICEROLE_CONTROLLING),
         transport_controller2_(cricket::ICEROLE_CONTROLLED),
         media_channel1_(NULL),
         media_channel2_(NULL),
         rtp_packet_(reinterpret_cast<const char*>(rtp_data), rtp_len),
         rtcp_packet_(reinterpret_cast<const char*>(rtcp_data), rtcp_len),
         media_info_callbacks1_(),
         media_info_callbacks2_(),
         ssrc_(0),
         error_(T::MediaChannel::ERROR_NONE) {}
 
@@ skipping 338 matching lines @@
     // Base implementation.
   }
 
   // Tests that can be used by derived classes.
 
   // Basic sanity check.
   void TestInit() {
     CreateChannels(0, 0);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_FALSE(media_channel1_->sending());
-    EXPECT_FALSE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel1_->playout());
+    }
     EXPECT_TRUE(media_channel1_->codecs().empty());
     EXPECT_TRUE(media_channel1_->recv_streams().empty());
     EXPECT_TRUE(media_channel1_->rtp_packets().empty());
     EXPECT_TRUE(media_channel1_->rtcp_packets().empty());
   }
 
   // Test that SetLocalContent and SetRemoteContent properly configure
   // the codecs.
   void TestSetContents() {
     CreateChannels(0, 0);
@@ skipping 306 matching lines @@
 
     EXPECT_TRUE(channel1_->secure());
     EXPECT_TRUE(channel2_->secure());
     EXPECT_TRUE(SendCustomRtp2(kSsrc2, 0));
     EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
   }
 
   // Test that we only start playout and sending at the right times.
   void TestPlayoutAndSendingStates() {
     CreateChannels(0, 0);
-    EXPECT_FALSE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel1_->playout());
+    }
     EXPECT_FALSE(media_channel1_->sending());
-    EXPECT_FALSE(media_channel2_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel2_->playout());
+    }
     EXPECT_FALSE(media_channel2_->sending());
     EXPECT_TRUE(channel1_->Enable(true));
-    EXPECT_FALSE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel1_->playout());
+    }
     EXPECT_FALSE(media_channel1_->sending());
     EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_,
                                            CA_OFFER, NULL));
-    EXPECT_TRUE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel1_->playout());
+    }
     EXPECT_FALSE(media_channel1_->sending());
     EXPECT_TRUE(channel2_->SetRemoteContent(&local_media_content1_,
                                             CA_OFFER, NULL));
-    EXPECT_FALSE(media_channel2_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel2_->playout());
+    }
     EXPECT_FALSE(media_channel2_->sending());
     EXPECT_TRUE(channel2_->SetLocalContent(&local_media_content2_,
                                            CA_ANSWER, NULL));
-    EXPECT_FALSE(media_channel2_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel2_->playout());
+    }
     EXPECT_FALSE(media_channel2_->sending());
     transport_controller1_.Connect(&transport_controller2_);
-    EXPECT_TRUE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel1_->playout());
+    }
     EXPECT_FALSE(media_channel1_->sending());
-    EXPECT_FALSE(media_channel2_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel2_->playout());
+    }
     EXPECT_FALSE(media_channel2_->sending());
     EXPECT_TRUE(channel2_->Enable(true));
-    EXPECT_TRUE(media_channel2_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel2_->playout());
+    }
     EXPECT_TRUE(media_channel2_->sending());
     EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_,
                                             CA_ANSWER, NULL));
-    EXPECT_TRUE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel1_->playout());
+    }
     EXPECT_TRUE(media_channel1_->sending());
   }
 
   // Test that changing the MediaContentDirection in the local and remote
   // session description start playout and sending at the right time.
   void TestMediaContentDirection() {
     CreateChannels(0, 0);
     typename T::Content content1;
     CreateContent(0, kPcmuCodec, kH264Codec, &content1);
     typename T::Content content2;
     CreateContent(0, kPcmuCodec, kH264Codec, &content2);
     // Set |content2| to be InActive.
     content2.set_direction(cricket::MD_INACTIVE);
 
     EXPECT_TRUE(channel1_->Enable(true));
     EXPECT_TRUE(channel2_->Enable(true));
-    EXPECT_FALSE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel1_->playout());
+    }
     EXPECT_FALSE(media_channel1_->sending());
-    EXPECT_FALSE(media_channel2_->playout());
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel2_->playout());
+    }
     EXPECT_FALSE(media_channel2_->sending());
 
     EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, NULL));
     EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER, NULL));
     EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER, NULL));
     transport_controller1_.Connect(&transport_controller2_);
 
-    EXPECT_TRUE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel1_->playout());
+    }
     EXPECT_FALSE(media_channel1_->sending());  // remote InActive
-    EXPECT_FALSE(media_channel2_->playout());  // local InActive
+    if (verify_playout_) {
+      EXPECT_FALSE(media_channel2_->playout());  // local InActive
+    }
     EXPECT_FALSE(media_channel2_->sending());  // local InActive
 
     // Update |content2| to be RecvOnly.
     content2.set_direction(cricket::MD_RECVONLY);
     EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER, NULL));
 
-    EXPECT_TRUE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel1_->playout());
+    }
     EXPECT_TRUE(media_channel1_->sending());
-    EXPECT_TRUE(media_channel2_->playout());  // local RecvOnly
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel2_->playout());  // local RecvOnly
+    }
     EXPECT_FALSE(media_channel2_->sending());  // local RecvOnly
 
     // Update |content2| to be SendRecv.
     content2.set_direction(cricket::MD_SENDRECV);
     EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER, NULL));
 
-    EXPECT_TRUE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel1_->playout());
+    }
     EXPECT_TRUE(media_channel1_->sending());
-    EXPECT_TRUE(media_channel2_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel2_->playout());
+    }
     EXPECT_TRUE(media_channel2_->sending());
   }
 
   // Test setting up a call.
   void TestCallSetup() {
     CreateChannels(0, 0);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_TRUE(SendInitiate());
-    EXPECT_TRUE(media_channel1_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel1_->playout());
+    }
     EXPECT_FALSE(media_channel1_->sending());
     EXPECT_TRUE(SendAccept());
     EXPECT_FALSE(channel1_->secure());
     EXPECT_TRUE(media_channel1_->sending());
     EXPECT_EQ(1U, media_channel1_->codecs().size());
-    EXPECT_TRUE(media_channel2_->playout());
+    if (verify_playout_) {
+      EXPECT_TRUE(media_channel2_->playout());
+    }
     EXPECT_TRUE(media_channel2_->sending());
     EXPECT_EQ(1U, media_channel2_->codecs().size());
   }
 
   // Test that we don't crash if packets are sent during call teardown
   // when RTCP mux is enabled. This is a regression test against a specific
   // race condition that would only occur when a RTCP packet was sent during
   // teardown of a channel on which RTCP mux was enabled.
   void TestCallTeardownRtcpMux() {
     class LastWordMediaChannel : public T::MediaChannel {
@@ skipping 807 matching lines @@
     EXPECT_FALSE(media_channel1_->ready_to_send());
     // In the case of rtcp mux, the SignalReadyToSend() from rtp channel
     // should trigger the MediaChannel's OnReadyToSend.
     rtp->SignalReadyToSend(rtp);
     EXPECT_TRUE(media_channel1_->ready_to_send());
     channel1_->SetReadyToSend(false, false);
     EXPECT_FALSE(media_channel1_->ready_to_send());
   }
 
  protected:
+  // TODO(pbos): Remove playout from all media channels and let renderers mute
+  // themselves.
+  const bool verify_playout_;
   cricket::FakeTransportController transport_controller1_;
   cricket::FakeTransportController transport_controller2_;
   cricket::FakeMediaEngine media_engine_;
   // The media channels are owned by the voice channel objects below.
   typename T::MediaChannel* media_channel1_;
   typename T::MediaChannel* media_channel2_;
   rtc::scoped_ptr<typename T::Channel> channel1_;
   rtc::scoped_ptr<typename T::Channel> channel2_;
   typename T::Content local_media_content1_;
   typename T::Content local_media_content2_;
   typename T::Content remote_media_content1_;
   typename T::Content remote_media_content2_;
   // The RTP and RTCP packets to send in the tests.
   std::string rtp_packet_;
   std::string rtcp_packet_;
   int media_info_callbacks1_;
   int media_info_callbacks2_;
 
   uint32 ssrc_;
   typename T::MediaChannel::Error error_;
 };
 
-
 template<>
 void ChannelTest<VoiceTraits>::CreateContent(
     int flags,
     const cricket::AudioCodec& audio_codec,
     const cricket::VideoCodec& video_codec,
     cricket::AudioContentDescription* audio) {
   audio->AddCodec(audio_codec);
   audio->set_rtcp_mux((flags & RTCP_MUX) != 0);
   if (flags & SECURE) {
     audio->AddCrypto(cricket::CryptoParams(
@@ skipping 20 matching lines @@
 void ChannelTest<VoiceTraits>::AddLegacyStreamInContent(
     uint32 ssrc, int flags, cricket::AudioContentDescription* audio) {
   audio->AddLegacyStream(ssrc);
 }
 
 class VoiceChannelTest
     : public ChannelTest<VoiceTraits> {
  public:
   typedef ChannelTest<VoiceTraits> Base;
   VoiceChannelTest()
-      : Base(kPcmuFrame, sizeof(kPcmuFrame), kRtcpReport, sizeof(kRtcpReport)) {
-  }
+      : Base(true,
+             kPcmuFrame,
+             sizeof(kPcmuFrame),
+             kRtcpReport,
+             sizeof(kRtcpReport)) {}
 };
 
 // override to add NULL parameter
 template <>
 cricket::VideoChannel* ChannelTest<VideoTraits>::CreateChannel(
     rtc::Thread* thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeVideoMediaChannel* ch,
     cricket::TransportController* transport_controller,
     bool rtcp) {
@@ skipping 45 matching lines @@
 void ChannelTest<VideoTraits>::AddLegacyStreamInContent(
     uint32 ssrc, int flags, cricket::VideoContentDescription* video) {
   video->AddLegacyStream(ssrc);
 }
 
 class VideoChannelTest
     : public ChannelTest<VideoTraits> {
  public:
   typedef ChannelTest<VideoTraits> Base;
   VideoChannelTest()
-      : Base(kH264Packet,
+      : Base(false,
+             kH264Packet,
              sizeof(kH264Packet),
              kRtcpReport,
              sizeof(kRtcpReport)) {}
 };
 
 
 // VoiceChannelTest
 
 TEST_F(VoiceChannelTest, TestInit) {
   Base::TestInit();
@@ skipping 667 matching lines @@
 }
 
 
 // DataChannelTest
 
 class DataChannelTest
     : public ChannelTest<DataTraits> {
  public:
   typedef ChannelTest<DataTraits>
   Base;
-  DataChannelTest() : Base(kDataPacket, sizeof(kDataPacket),
-                           kRtcpReport, sizeof(kRtcpReport)) {
-  }
+  DataChannelTest()
+      : Base(true,
+             kDataPacket,
+             sizeof(kDataPacket),
+             kRtcpReport,
+             sizeof(kRtcpReport)) {}
 };
 
 // Override to avoid engine channel parameter.
 template <>
 cricket::DataChannel* ChannelTest<DataTraits>::CreateChannel(
     rtc::Thread* thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeDataMediaChannel* ch,
     cricket::TransportController* transport_controller,
     bool rtcp) {
@@ skipping 177 matching lines @@
   };
   rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?