Combining SetVideoSend and SetSource into one method.

webrtc/media/base/videoengine_unittest.h

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 107 matching lines @@
     media_error_ = cricket::VideoMediaChannel::ERROR_NONE;
     cricket::VideoRecvParameters parameters;
     parameters.codecs = engine_.codecs();
     channel_->SetRecvParameters(parameters);
     EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams()));
     video_capturer_.reset(CreateFakeVideoCapturer());
     cricket::VideoFormat format(640, 480,
                                 cricket::VideoFormat::FpsToInterval(30),
                                 cricket::FOURCC_I420);
     EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(format));
-    EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
+    EXPECT_TRUE(
+        channel_->SetVideoSend(kSsrc, true, nullptr, video_capturer_.get()));
   }
 
   virtual cricket::FakeVideoCapturer* CreateFakeVideoCapturer() {
     return new cricket::FakeVideoCapturer();
   }
 
   // Utility method to setup an additional stream to send and receive video.
   // Used to test send and recv between two streams.
   void SetUpSecondStream() {
     SetUpSecondStreamWithNoRecv();
@@ skipping 16 matching lines @@
         cricket::StreamParams::CreateLegacy(kSsrc + 2)));
     // We dont add recv for the second stream.
 
     // Setup the receive and renderer for second stream after send.
     video_capturer_2_.reset(CreateFakeVideoCapturer());
     cricket::VideoFormat format(640, 480,
                                 cricket::VideoFormat::FpsToInterval(30),
                                 cricket::FOURCC_I420);
     EXPECT_EQ(cricket::CS_RUNNING, video_capturer_2_->Start(format));
 
-    EXPECT_TRUE(channel_->SetCapturer(kSsrc + 2, video_capturer_2_.get()));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc + 2, true, nullptr,
+                                       video_capturer_2_.get()));
   }
   virtual void TearDown() {
     channel_.reset();
   }
   bool SetDefaultCodec() {
     return SetOneCodec(DefaultCodec());
   }
 
   bool SetOneCodec(int pt, const char* name, int w, int h, int fr) {
     return SetOneCodec(cricket::VideoCodec(pt, name, w, h, fr, 0));
@@ skipping 192 matching lines @@
   }
 
   void OnVideoChannelError(uint32_t ssrc,
                            cricket::VideoMediaChannel::Error error) {
     media_error_ = error;
   }
 
   // Test that SetSend works.
   void SetSend() {
     EXPECT_FALSE(channel_->sending());
-    EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
+    EXPECT_TRUE(
+        channel_->SetVideoSend(kSsrc, true, nullptr, video_capturer_.get()));
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_FALSE(channel_->sending());
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->sending());
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     EXPECT_TRUE(SetSend(false));
     EXPECT_FALSE(channel_->sending());
   }
   // Test that SetSend fails without codecs being set.
@@ skipping 173 matching lines @@
     std::unique_ptr<cricket::FakeVideoCapturer> capturer(
         CreateFakeVideoCapturer());
     const int kTestWidth = 160;
     const int kTestHeight = 120;
     cricket::VideoFormat format(kTestWidth, kTestHeight,
                                 cricket::VideoFormat::FpsToInterval(5),
                                 cricket::FOURCC_I420);
     EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(5678)));
-    EXPECT_TRUE(channel_->SetCapturer(5678, capturer.get()));
+    EXPECT_TRUE(channel_->SetVideoSend(5678, true, nullptr, capturer.get()));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(5678)));
     EXPECT_TRUE(channel_->SetSink(5678, &renderer2));
     EXPECT_TRUE(capturer->CaptureCustomFrame(
         kTestWidth, kTestHeight, cricket::FOURCC_I420));
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer2, 1, kTestWidth, kTestHeight, kTimeout);
 
     // Get stats, and make sure they are correct for two senders. We wait until
     // the number of expected packets have been sent to avoid races where we
@@ skipping 15 matching lines @@
         << "Timed out while waiting for packet counts for all sent packets.";
     EXPECT_EQ(1U, info.senders[0].ssrcs().size());
     EXPECT_EQ(1234U, info.senders[0].ssrcs()[0]);
     EXPECT_EQ(DefaultCodec().width, info.senders[0].send_frame_width);
     EXPECT_EQ(DefaultCodec().height, info.senders[0].send_frame_height);
     EXPECT_EQ(1U, info.senders[1].ssrcs().size());
     EXPECT_EQ(5678U, info.senders[1].ssrcs()[0]);
     EXPECT_EQ(kTestWidth, info.senders[1].send_frame_width);
     EXPECT_EQ(kTestHeight, info.senders[1].send_frame_height);
     // The capturer must be unregistered here as it runs out of it's scope next.
-    EXPECT_TRUE(channel_->SetCapturer(5678, NULL));
+    EXPECT_TRUE(channel_->SetVideoSend(5678, true, nullptr, nullptr));
   }
 
   // Test that we can set the bandwidth.
   void SetSendBandwidth() {
     cricket::VideoSendParameters parameters;
     parameters.codecs.push_back(DefaultCodec());
     parameters.max_bandwidth_bps = -1;  // <= 0 means unlimited.
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
     parameters.max_bandwidth_bps = 128 * 1024;
     EXPECT_TRUE(channel_->SetSendParameters(parameters));
@@ skipping 16 matching lines @@
     EXPECT_EQ(0, NumRtpPackets(kSsrc - 1));
     EXPECT_EQ(0, NumRtpBytes(kSsrc - 1));
   }
   // Test that we can set the SSRC even after codecs are set.
   void SetSendSsrcAfterSetCodecs() {
     // Remove stream added in Setup.
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     EXPECT_TRUE(SetDefaultCodec());
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(999)));
-    EXPECT_TRUE(channel_->SetCapturer(999u, video_capturer_.get()));
+    EXPECT_TRUE(
+        channel_->SetVideoSend(999u, true, nullptr, video_capturer_.get()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(WaitAndSendFrame(0));
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     uint32_t ssrc = 0;
     std::unique_ptr<const rtc::CopyOnWriteBuffer> p(GetRtpPacket(0));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(999u, ssrc);
     // Packets are being paced out, so these can mismatch between the first and
     // second call to NumRtpPackets until pending packets are paced out.
     EXPECT_EQ_WAIT(NumRtpPackets(), NumRtpPackets(ssrc), kTimeout);
@@ skipping 45 matching lines @@
         p(GetRtpPacket(static_cast<int>(last_packet)));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(kSsrc, ssrc);
 
     // Remove the send stream that was added during Setup.
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     int rtp_packets = NumRtpPackets();
 
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(789u)));
-    EXPECT_TRUE(channel_->SetCapturer(789u, video_capturer_.get()));
+    EXPECT_TRUE(
+        channel_->SetVideoSend(789u, true, nullptr, video_capturer_.get()));
     EXPECT_EQ(rtp_packets, NumRtpPackets());
     // Wait 30ms to guarantee the engine does not drop the frame.
     EXPECT_TRUE(WaitAndSendFrame(30));
     EXPECT_TRUE_WAIT(NumRtpPackets() > rtp_packets, kTimeout);
 
     last_packet = NumRtpPackets() - 1;
     p.reset(GetRtpPacket(static_cast<int>(last_packet)));
     ParseRtpPacket(p.get(), NULL, NULL, NULL, NULL, &ssrc, NULL);
     EXPECT_EQ(789u, ssrc);
   }
@@ skipping 48 matching lines @@
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
     std::unique_ptr<cricket::FakeVideoCapturer> capturer(
         CreateFakeVideoCapturer());
 
     // TODO(nisse): This testcase fails if we don't configure
     // screencast. It's unclear why, I see nothing obvious in this
     // test which is related to screencast logic.
     cricket::VideoOptions video_options;
     video_options.is_screencast = rtc::Optional<bool>(true);
-    channel_->SetVideoSend(kSsrc, true, &video_options);
+    channel_->SetVideoSend(kSsrc, true, &video_options, nullptr);
 
     cricket::VideoFormat format(480, 360,
                                 cricket::VideoFormat::FpsToInterval(30),
                                 cricket::FOURCC_I420);
     EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format));
     // All capturers start generating frames with the same timestamp. ViE does
     // not allow the same timestamp to be used. Capture one frame before
     // associating the capturer with the channel.
     EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
                                              cricket::FOURCC_I420));
 
     int captured_frames = 1;
     for (int iterations = 0; iterations < 2; ++iterations) {
-      EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
+      EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, capturer.get()));
       rtc::Thread::Current()->ProcessMessages(time_between_send);
       EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
                                                cricket::FOURCC_I420));
       ++captured_frames;
       // Wait until frame of right size is captured.
       EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames &&
                        format.width == renderer_.width() &&
                        format.height == renderer_.height() &&
                        !renderer_.black_frame(), kTimeout);
       EXPECT_GE(renderer_.num_rendered_frames(), captured_frames);
       EXPECT_EQ(format.width, renderer_.width());
       EXPECT_EQ(format.height, renderer_.height());
       captured_frames = renderer_.num_rendered_frames() + 1;
       EXPECT_FALSE(renderer_.black_frame());
-      EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
+      EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr));
       // Make sure a black frame is generated within the specified timeout.
       // The black frame should be the resolution of the previous frame to
       // prevent expensive encoder reconfigurations.
       EXPECT_TRUE_WAIT(renderer_.num_rendered_frames() >= captured_frames &&
                        format.width == renderer_.width() &&
                        format.height == renderer_.height() &&
                        renderer_.black_frame(), kTimeout);
       EXPECT_GE(renderer_.num_rendered_frames(), captured_frames);
       EXPECT_EQ(format.width, renderer_.width());
       EXPECT_EQ(format.height, renderer_.height());
       EXPECT_TRUE(renderer_.black_frame());
 
       // The black frame has the same timestamp as the next frame since it's
       // timestamp is set to the last frame's timestamp + interval. WebRTC will
       // not render a frame with the same timestamp so capture another frame
       // with the frame capturer to increment the next frame's timestamp.
       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).
+  // Tests that if SetVideoSend is called with a NULL capturer after the
+  // capturer was already removed, the application doesn't crash (and no black
+  // frame is sent).
   void RemoveCapturerWithoutAdd() {
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetSink(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));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr));
     // Wait for one black frame for removing the capturer.
     EXPECT_FRAME_WAIT(2, 640, 400, kTimeout);
 
-    // No capturer was added, so this RemoveCapturer should
-    // fail.
-    EXPECT_FALSE(channel_->SetCapturer(kSsrc, NULL));
+    // No capturer was added, so this SetVideoSend shouldn't do anything.
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr));
     rtc::Thread::Current()->ProcessMessages(300);
     // Verify no more frames were sent.
     EXPECT_EQ(2, renderer_.num_rendered_frames());
   }
 
   // Tests that we can add and remove capturer as unique sources.
   void AddRemoveCapturerMultipleSources() {
     // WebRTC implementation will drop frames if pushed to quickly. Wait the
     // interval time to avoid that.
     // WebRTC implementation will drop frames if pushed to quickly. Wait the
@@ skipping 21 matching lines @@
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(2)));
     EXPECT_TRUE(channel_->SetSink(2, &renderer2));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(2)));
     std::unique_ptr<cricket::FakeVideoCapturer> capturer2(
         CreateFakeVideoCapturer());
     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
+    // A limitation in the lmi implementation requires that SetVideoSend() 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(channel_->SetVideoSend(1, true, nullptr, capturer1.get()));
+    EXPECT_TRUE(channel_->SetVideoSend(2, true, nullptr, capturer2.get()));
     EXPECT_TRUE(SetSend(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));
     EXPECT_FRAME_ON_RENDERER_WAIT(
         renderer2, 1, kTestWidth, kTestHeight, kTimeout);
     // Successfully remove the capturer.
-    EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
-    // Fail to re-remove the capturer.
-    EXPECT_FALSE(channel_->SetCapturer(kSsrc, NULL));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr));
     // The capturers must be unregistered here as it runs out of it's scope
     // next.
-    EXPECT_TRUE(channel_->SetCapturer(1, NULL));
-    EXPECT_TRUE(channel_->SetCapturer(2, NULL));
+    EXPECT_TRUE(channel_->SetVideoSend(1, true, nullptr, nullptr));
+    EXPECT_TRUE(channel_->SetVideoSend(2, true, nullptr, nullptr));
   }
 
   void HighAspectHighHeightCapturer() {
     const int kWidth  = 80;
     const int kHeight = 10000;
     const int kScaledWidth = 20;
     const int kScaledHeight = 2500;
 
     cricket::VideoCodec codec(DefaultCodec());
     EXPECT_TRUE(SetOneCodec(codec));
@@ skipping 12 matching lines @@
     // Registering an external capturer is currently the same as screen casting
     // (update the test when this changes).
     std::unique_ptr<cricket::FakeVideoCapturer> capturer(
         CreateFakeVideoCapturer());
     const std::vector<cricket::VideoFormat>* formats =
         capturer->GetSupportedFormats();
     cricket::VideoFormat capture_format = (*formats)[0];
     EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(capture_format));
     // Capture frame to not get same frame timestamps as previous capturer.
     capturer->CaptureFrame();
-    EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, capturer.get()));
     EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(capturer->CaptureCustomFrame(kWidth, kHeight,
                                              cricket::FOURCC_ARGB));
     EXPECT_GT_FRAME_ON_RENDERER_WAIT(
         renderer, 2, kScaledWidth, kScaledHeight, kTimeout);
-    EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr));
   }
 
   // Tests that we can adapt video resolution with 16:10 aspect ratio properly.
   void AdaptResolution16x10() {
     EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
     cricket::VideoCodec codec(DefaultCodec());
     codec.width = 640;
     codec.height = 400;
     SendAndReceive(codec);
     codec.width /= 2;
@@ skipping 99 matching lines @@
 
   // Tests that we can mute and unmute the channel properly.
   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(channel_->SetVideoSend(kSsrc, true, nullptr, &video_capturer));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetSink(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, false, nullptr));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr, &video_capturer));
     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.
-    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, &video_capturer));
     EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(video_capturer.CaptureFrame());
     ++frame_count;
     EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
     EXPECT_FALSE(renderer_.black_frame());
     // Test that we can also Mute using the correct send stream SSRC.
-    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr, &video_capturer));
     EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(video_capturer.CaptureFrame());
     ++frame_count;
     EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
     EXPECT_TRUE(renderer_.black_frame());
-    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, &video_capturer));
     EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(video_capturer.CaptureFrame());
     ++frame_count;
     EXPECT_EQ_WAIT(frame_count, renderer_.num_rendered_frames(), kTimeout);
     EXPECT_FALSE(renderer_.black_frame());
     // Test that muting an existing stream succeeds even if it's muted.
-    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr));
-    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr, &video_capturer));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, false, nullptr, &video_capturer));
     // Test that unmuting an existing stream succeeds even if it's not muted.
-    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
-    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, &video_capturer));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, &video_capturer));
     // Test that muting an invalid stream fails.
-    EXPECT_FALSE(channel_->SetVideoSend(kSsrc+1, false, nullptr));
-    EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
+    EXPECT_FALSE(
+        channel_->SetVideoSend(kSsrc + 1, false, nullptr, &video_capturer));
+    EXPECT_TRUE(channel_->SetVideoSend(kSsrc, true, nullptr, nullptr));
   }
 
   // Test that multiple send streams can be created and deleted properly.
   void MultipleSendStreams() {
     // Remove stream added in Setup. I.e. remove stream corresponding to default
     // channel.
     EXPECT_TRUE(channel_->RemoveSendStream(kSsrc));
     const unsigned int kSsrcsSize = sizeof(kSsrcs4)/sizeof(kSsrcs4[0]);
     for (unsigned int i = 0; i < kSsrcsSize; ++i) {
       EXPECT_TRUE(channel_->AddSendStream(
@@ skipping 26 matching lines @@
   std::unique_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  // WEBRTC_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_  NOLINT