Remove VideoMediaChannel::SetRender().

talk/media/base/videoengine_unittest.h

 /*
  * libjingle
  * Copyright 2014 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 742 matching lines @@
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
   }
   // Tests that we can send and receive frames.
   void SendAndReceive(const cricket::VideoCodec& codec) {
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
   }
   // Tests that we only get a VideoRenderer::SetSize() callback when needed.
   void SendManyResizeOnce() {
     cricket::VideoCodec codec(DefaultCodec());
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(WaitAndSendFrame(30));
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
     EXPECT_TRUE(WaitAndSendFrame(30));
     EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
     EXPECT_EQ(1, renderer_.num_set_sizes());
 
     codec.width /= 2;
     codec.height /= 2;
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(WaitAndSendFrame(30));
     EXPECT_FRAME_WAIT(3, codec.width, codec.height, kTimeout);
     EXPECT_EQ(2, renderer_.num_set_sizes());
   }
   void SendReceiveManyAndGetStats(const cricket::VideoCodec& codec,
                                   int duration_sec, int fps) {
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     for (int i = 0; i < duration_sec; ++i) {
       for (int frame = 1; frame <= fps; ++frame) {
         EXPECT_TRUE(WaitAndSendFrame(1000 / fps));
         EXPECT_FRAME_WAIT(frame + i * fps, codec.width, codec.height, kTimeout);
       }
     }
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
@@ skipping 48 matching lines @@
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(true);
     EXPECT_TRUE(channel_->SetOptions(vmo));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(1)));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(2)));
     EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
     EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(0, renderer1.num_rendered_frames());
     EXPECT_EQ(0, renderer2.num_rendered_frames());
     std::vector<uint32> ssrcs;
     ssrcs.push_back(1);
     ssrcs.push_back(2);
     network_interface_.SetConferenceMode(true, ssrcs);
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
     EXPECT_FRAME_ON_RENDERER_WAIT(
@@ skipping 25 matching lines @@
     // it will come first in the senders map.
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(true);
     EXPECT_TRUE(channel_->SetOptions(vmo));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc)));
     EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_));
     channel_->UpdateAspectRatio(640, 400);
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
 
     // Add an additional capturer, and hook up a renderer to receive it.
     cricket::FakeVideoRenderer renderer2;
     rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
         CreateFakeVideoCapturer());
     capturer->SetScreencast(true);
     const int kTestWidth = 160;
@@ skipping 92 matching lines @@
   void SetRenderer() {
     uint8 data1[] = {
         0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
     };
 
     rtc::Buffer packet1(data1, sizeof(data1));
     rtc::SetBE32(packet1.data() + 8, kSsrc);
     channel_->SetRenderer(kDefaultReceiveSsrc, NULL);
     EXPECT_TRUE(SetDefaultCodec());
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     channel_->OnPacketReceived(&packet1, rtc::PacketTime());
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
   }
 
   // Tests empty StreamParams is rejected.
   void RejectEmptyStreamParams() {
     // Remove the send stream that was added during Setup.
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
 
     cricket::StreamParams empty;
     EXPECT_FALSE(channel_->AddSendStream(empty));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(789u)));
   }
 
   // Tests setting up and configuring a send stream.
   void AddRemoveSendStreams() {
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
     EXPECT_GE(2, NumRtpPackets());
     uint32 ssrc = 0;
     size_t last_packet = NumRtpPackets() - 1;
     rtc::scoped_ptr<const rtc::Buffer>
         p(GetRtpPacket(static_cast<int>(last_packet)));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(kSsrc, ssrc);
@@ skipping 125 matching lines @@
     EXPECT_FALSE(channel_->GetRenderer(1, &renderer));
     EXPECT_FALSE(channel_->GetRenderer(2, &renderer));
   }
 
   // Test that no frames are rendered after the receive stream have been
   // removed.
   void AddRemoveRecvStreamAndRender() {
     cricket::FakeVideoRenderer renderer1;
     EXPECT_TRUE(SetDefaultCodec());
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc)));
     EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer1));
 
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer1, 1, DefaultCodec().width, DefaultCodec().height, kTimeout);
     EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc));
     // Send three more frames. This is to avoid that the test might be flaky
     // due to frame dropping.
@@ skipping 23 matching lines @@
   }
 
   // Tests the behavior of incoming streams in a conference scenario.
   void SimulateConference() {
     cricket::FakeVideoRenderer renderer1, renderer2;
     EXPECT_TRUE(SetDefaultCodec());
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(true);
     EXPECT_TRUE(channel_->SetOptions(vmo));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(1)));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(2)));
     EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
     EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
     EXPECT_EQ(0, renderer1.num_rendered_frames());
     EXPECT_EQ(0, renderer2.num_rendered_frames());
     std::vector<uint32> ssrcs;
     ssrcs.push_back(1);
@@ skipping 16 matching lines @@
   }
 
   // Tests that we can add and remove capturers and frames are sent out properly
   void AddRemoveCapturer() {
     cricket::VideoCodec codec = DefaultCodec();
     codec.width = 320;
     codec.height = 240;
     const int time_between_send = TimeBetweenSend(codec);
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
     rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
         CreateFakeVideoCapturer());
     capturer->SetScreencast(true);
     cricket::VideoFormat format(480, 360,
                                 cricket::VideoFormat::FpsToInterval(30),
                                 cricket::FOURCC_I420);
@@ skipping 41 matching lines @@
       EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
                                                cricket::FOURCC_I420));
     }
   }
 
   // Tests that if RemoveCapturer is called without a capturer ever being
   // added, the plugin shouldn't crash (and no black frame should be sent).
   void RemoveCapturerWithoutAdd() {
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, 640, 400, kTimeout);
     // Wait for one frame so they don't get dropped because we send frames too
     // tightly.
     rtc::Thread::Current()->ProcessMessages(30);
     // Remove the capturer.
     EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
     // Wait for one black frame for removing the capturer.
@@ skipping 44 matching lines @@
     capturer2->SetScreencast(true);
     EXPECT_EQ(cricket::CS_RUNNING, capturer2->Start(capture_format));
     // State for all the streams.
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     // A limitation in the lmi implementation requires that SetCapturer() is
     // called after SetOneCodec().
     // TODO(hellner): this seems like an unnecessary constraint, fix it.
     EXPECT_TRUE(channel_->SetCapturer(1, capturer1.get()));
     EXPECT_TRUE(channel_->SetCapturer(2, capturer2.get()));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     // Test capturer associated with engine.
     const int kTestWidth = 160;
     const int kTestHeight = 120;
     EXPECT_TRUE(capturer1->CaptureCustomFrame(
         kTestWidth, kTestHeight, cricket::FOURCC_I420));
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer1, 1, kTestWidth, kTestHeight, kTimeout);
     // Capture a frame with additional capturer2, frames should be received
     EXPECT_TRUE(capturer2->CaptureCustomFrame(
         kTestWidth, kTestHeight, cricket::FOURCC_I420));
@@ skipping 16 matching lines @@
     const int kScaledHeight = 2500;
 
     cricket::VideoCodec codec(DefaultCodec());
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
 
     cricket::FakeVideoRenderer renderer;
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc)));
     EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(0, renderer.num_rendered_frames());
 
     EXPECT_TRUE(SendFrame());
     EXPECT_GT_FRAME_ON_RENDERER_WAIT(
         renderer, 1, codec.width, codec.height, kTimeout);
 
     // Registering an external capturer is currently the same as screen casting
     // (update the test when this changes).
     rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer(
         CreateFakeVideoCapturer());
@@ skipping 42 matching lines @@
     EXPECT_FRAME_WAIT(2, codec.width, codec.height, kTimeout);
   }
   // Tests that we can drop all frames properly.
   void AdaptDropAllFrames() {
     // Set the channel codec's resolution to 0, which will require the adapter
     // to drop all frames.
     cricket::VideoCodec codec(DefaultCodec());
     codec.width = codec.height = codec.framerate = 0;
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE(SendFrame());
     rtc::Thread::Current()->ProcessMessages(500);
     EXPECT_EQ(0, renderer_.num_rendered_frames());
   }
   // Tests that we can reduce the frame rate on demand properly.
   // TODO(fbarchard): This test is flakey on pulse.  Fix and re-enable
   void AdaptFramerate() {
     cricket::VideoCodec codec(DefaultCodec());
     int frame_count = 0;
     // The capturer runs at 30 fps. The channel requires 30 fps.
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
     EXPECT_TRUE(WaitAndSendFrame(0));  // Should be rendered.
     EXPECT_TRUE(WaitAndSendFrame(30));  // Should be rendered.
     frame_count += 2;
     EXPECT_FRAME_WAIT(frame_count, codec.width, codec.height, kTimeout);
     rtc::scoped_ptr<const rtc::Buffer> p(GetRtpPacket(0));
     EXPECT_EQ(codec.id, GetPayloadType(p.get()));
 
     // The channel requires 15 fps.
     codec.framerate = 15;
@@ skipping 25 matching lines @@
     frame_count += 2;
     EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
   }
   // Tests that adapted frames won't be upscaled to a higher resolution.
   void SendsLowerResolutionOnSmallerFrames() {
     cricket::VideoCodec codec = DefaultCodec();
     codec.width = 320;
     codec.height = 240;
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
 
     // Check that we send smaller frames at the new resolution.
     EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(33));
     EXPECT_TRUE(video_capturer_->CaptureCustomFrame(
         codec.width / 2, codec.height / 2, cricket::FOURCC_I420));
     EXPECT_FRAME_WAIT(2, codec.width / 2, codec.height / 2, kTimeout);
@@ skipping 29 matching lines @@
     EXPECT_TRUE(SendFrame());
     rtc::Thread::Current()->ProcessMessages(500);
     EXPECT_EQ(frame_count, renderer_.num_rendered_frames());
   }
   // Test that setting send stream format to 0x0 resolution will result in
   // frames being dropped.
   void SetSendStreamFormat0x0() {
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_TRUE(SetSendStreamFormat(kSsrc, DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     // This frame should be received.
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
     const int64 interval = cricket::VideoFormat::FpsToInterval(
         DefaultCodec().framerate);
     cricket::VideoFormat format(
         0,
         0,
@@ skipping 11 matching lines @@
   void MuteStream() {
     EXPECT_TRUE(SetDefaultCodec());
     cricket::FakeVideoCapturer video_capturer;
     video_capturer.Start(
         cricket::VideoFormat(
             640, 480,
             cricket::VideoFormat::FpsToInterval(30),
             cricket::FOURCC_I420));
     EXPECT_TRUE(channel_->SetCapturer(kSsrc, &video_capturer));
     EXPECT_TRUE(SetSend(true));
-    EXPECT_TRUE(channel_->SetRender(true));
     EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     // Mute the channel and expect black output frame.
     int frame_count = 0;
     EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
     EXPECT_TRUE(video_capturer.CaptureFrame());
     ++frame_count;
     EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
     EXPECT_TRUE(renderer_.black_frame());
     // Unmute the channel and expect non-black output frame.
@@ skipping 93 matching lines @@
   }
 
   // Tests that we can send and receive frames with early receive.
   void TwoStreamsSendAndUnsignalledRecv(const cricket::VideoCodec& codec) {
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(true);
     vmo.unsignalled_recv_stream_limit.Set(1);
     EXPECT_TRUE(channel_->SetOptions(vmo));
     SetUpSecondStreamWithNoRecv();
     // Test sending and receiving on first stream.
-    EXPECT_TRUE(channel_->SetRender(true));
     Send(codec);
     EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout);
     EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout);
     // The first send is not expected to yield frames, because the ssrc
     // is not signalled yet. With unsignalled recv enabled, we will drop frames
     // instead of packets.
     EXPECT_EQ(0, renderer2_.num_rendered_frames());
     // Give a chance for the decoder to process before adding the receiver.
     rtc::Thread::Current()->ProcessMessages(100);
     // Test sending and receiving on second stream.
@@ skipping 11 matching lines @@
   }
 
   // Tests that we cannot receive key frames with unsignalled recv disabled.
   void TwoStreamsSendAndFailUnsignalledRecv(const cricket::VideoCodec& codec) {
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(true);
     vmo.unsignalled_recv_stream_limit.Set(0);
     EXPECT_TRUE(channel_->SetOptions(vmo));
     SetUpSecondStreamWithNoRecv();
     // Test sending and receiving on first stream.
-    EXPECT_TRUE(channel_->SetRender(true));
     Send(codec);
     EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout);
     rtc::Thread::Current()->ProcessMessages(100);
     EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout);
     EXPECT_EQ_WAIT(0, renderer2_.num_rendered_frames(), kTimeout);
     // Give a chance for the decoder to process before adding the receiver.
     rtc::Thread::Current()->ProcessMessages(10);
     // Test sending and receiving on second stream.
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc + 2)));
@@ skipping 10 matching lines @@
   // Tests that we drop key frames when conference mode is disabled and we
   // receive rtp packets on unsignalled streams.
   void TwoStreamsSendAndFailUnsignalledRecvInOneToOne(
       const cricket::VideoCodec& codec) {
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(false);
     vmo.unsignalled_recv_stream_limit.Set(1);
     EXPECT_TRUE(channel_->SetOptions(vmo));
     SetUpSecondStreamWithNoRecv();
     // Test sending and receiving on first stream.
-    EXPECT_TRUE(channel_->SetRender(true));
     Send(codec);
     EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout);
     // In one-to-one mode, we deliver frames to the default channel if there
     // is no registered recv channel for the ssrc.
     EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= 1, kTimeout);
     // Give a chance for the decoder to process before adding the receiver.
     rtc::Thread::Current()->ProcessMessages(100);
     // Test sending and receiving on second stream.
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc + 2)));
@@ skipping 10 matching lines @@
   // receive rtp packets on unsignalled streams. Removal of a unsignalled recv
   // stream is successful.
   void TwoStreamsAddAndRemoveUnsignalledRecv(
       const cricket::VideoCodec& codec) {
     cricket::VideoOptions vmo;
     vmo.conference_mode.Set(true);
     vmo.unsignalled_recv_stream_limit.Set(1);
     EXPECT_TRUE(channel_->SetOptions(vmo));
     SetUpSecondStreamWithNoRecv();
     // Sending and receiving on first stream.
-    EXPECT_TRUE(channel_->SetRender(true));
     Send(codec);
     EXPECT_EQ_WAIT(2, NumRtpPackets(), kTimeout);
     EXPECT_EQ_WAIT(1, renderer_.num_rendered_frames(), kTimeout);
     // The first send is not expected to yield frames, because the ssrc
     // is no signalled yet. With unsignalled recv enabled, we will drop frames
     // instead of packets.
     EXPECT_EQ(0, renderer2_.num_rendered_frames());
     // Give a chance for the decoder to process before adding the receiver.
     rtc::Thread::Current()->ProcessMessages(100);
     // Ensure that we can remove the unsignalled recv stream that was created
     // when the first video packet with unsignalled recv ssrc is received.
     EXPECT_TRUE(channel_->RemoveRecvStream(kSsrc + 2));
   }
 
   VideoEngineOverride<E> engine_;
   rtc::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_;
   rtc::scoped_ptr<cricket::FakeVideoCapturer> video_capturer_2_;
   rtc::scoped_ptr<C> channel_;
   cricket::FakeNetworkInterface network_interface_;
   cricket::FakeVideoRenderer renderer_;
   cricket::VideoMediaChannel::Error media_error_;
 
   // Used by test cases where 2 streams are run on the same channel.
   cricket::FakeVideoRenderer renderer2_;
 };
 
 #endif  // TALK_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_  NOLINT