MediaController/Call instantiation.

talk/media/webrtc/webrtcvideoengine2_unittest.cc

 /*
  * libjingle
  * Copyright 2004 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 92 matching lines @@
                 it->second == config.rtp.fec.red_rtx_payload_type);
   }
 }
 }  // namespace
 
 namespace cricket {
 class WebRtcVideoEngine2Test : public ::testing::Test {
  public:
   WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test(nullptr) {}
   WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine)
-      : engine_(voice_engine) {
+      : call_(webrtc::Call::Create(webrtc::Call::Config())),
+        engine_() {
     std::vector<VideoCodec> engine_codecs = engine_.codecs();
     DCHECK(!engine_codecs.empty());
     bool codec_set = false;
     for (size_t i = 0; i < engine_codecs.size(); ++i) {
       if (engine_codecs[i].name == "red") {
         default_red_codec_ = engine_codecs[i];
       } else if (engine_codecs[i].name == "ulpfec") {
         default_ulpfec_codec_ = engine_codecs[i];
       } else if (engine_codecs[i].name == "rtx") {
         int associated_payload_type;
         if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
                                       &associated_payload_type)) {
           default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id;
         }
       } else if (!codec_set) {
         default_codec_ = engine_codecs[i];
         codec_set = true;
       }
     }
 
     DCHECK(codec_set);
   }
 
  protected:
-  class FakeCallFactory : public WebRtcCallFactory {
-   public:
-    FakeCallFactory() : fake_call_(NULL) {}
-    FakeCall* GetCall() { return fake_call_; }
-
-   private:
-    webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
-      DCHECK(fake_call_ == NULL);
-      fake_call_ = new FakeCall(config);
-      return fake_call_;
-    }
-
-    FakeCall* fake_call_;
-  };
-
   VideoMediaChannel* SetUpForExternalEncoderFactory(
       cricket::WebRtcVideoEncoderFactory* encoder_factory,
       const std::vector<VideoCodec>& codecs);
 
   VideoMediaChannel* SetUpForExternalDecoderFactory(
       cricket::WebRtcVideoDecoderFactory* decoder_factory,
       const std::vector<VideoCodec>& codecs);
 
   // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly
   // initialized when the constructor is called.
+  rtc::scoped_ptr<webrtc::Call> call_;
   WebRtcVoiceEngine voice_engine_;
   WebRtcVideoEngine2 engine_;
   VideoCodec default_codec_;
   VideoCodec default_red_codec_;
   VideoCodec default_ulpfec_codec_;
   std::map<int, int> default_apt_rtx_types_;
 };
 
 TEST_F(WebRtcVideoEngine2Test, FindCodec) {
   const std::vector<cricket::VideoCodec>& c = engine_.codecs();
@@ skipping 170 matching lines @@
 
   // Verify removing header extension turns on applying rotation.
   extensions.clear();
   EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
   EXPECT_TRUE(capturer.GetApplyRotation());
 }
 
 TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
   engine_.Init();
   rtc::scoped_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(cricket::VideoOptions(), NULL));
+      engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
 
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
 
   EXPECT_FALSE(channel->SetSend(true))
       << "Channel should not start without codecs.";
   EXPECT_TRUE(channel->SetSend(false))
       << "Channel should be stoppable even without set codecs.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
   engine_.Init();
   rtc::scoped_ptr<VideoMediaChannel> channel(
-      engine_.CreateChannel(cricket::VideoOptions(), NULL));
+      engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
   VideoMediaInfo info;
   channel->GetStats(&info);
 }
 
 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kVp8Codec);
@@ skipping 41 matching lines @@
   EXPECT_TRUE(
       channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
 }
 
 TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kVp8Codec);
 
-  FakeCallFactory factory;
-  engine_.SetCallFactory(&factory);
+  FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
+  call_.reset(fake_call);
   rtc::scoped_ptr<VideoMediaChannel> channel(
       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
 
   FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
   capturer.Start(cricket::VideoFormat(1280, 720,
                                       cricket::VideoFormat::FpsToInterval(60),
                                       cricket::FOURCC_I420));
   channel->SetSend(true);
 
-  FakeVideoSendStream* stream = factory.GetCall()->GetVideoSendStreams()[0];
-
+  FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
 
   EXPECT_TRUE(capturer.CaptureFrame());
   int64_t last_timestamp = stream->GetLastTimestamp();
   for (int i = 0; i < 10; i++) {
     EXPECT_TRUE(capturer.CaptureFrame());
     int64_t timestamp = stream->GetLastTimestamp();
     int64_t interval = timestamp - last_timestamp;
 
     // Precision changes from nanosecond to millisecond.
     // Allow error to be no more than 1.
@@ skipping 24 matching lines @@
   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
 }
 
 TEST_F(WebRtcVideoEngine2Test,
        ProducesIncreasingTimestampsWithResetInputSources) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kVp8Codec);
 
-  FakeCallFactory factory;
-  engine_.SetCallFactory(&factory);
+  FakeCall* fake_call = new FakeCall(webrtc::Call::Config());
+  call_.reset(fake_call);
   rtc::scoped_ptr<VideoMediaChannel> channel(
       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   channel->SetSend(true);
-  FakeVideoSendStream* stream = factory.GetCall()->GetVideoSendStreams()[0];
+  FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
 
   FakeVideoCapturer capturer1;
   EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer1));
 
   cricket::CapturedFrame frame;
   frame.width = 1280;
   frame.height = 720;
   frame.fourcc = cricket::FOURCC_I420;
   frame.data_size = static_cast<uint32>(
       cricket::VideoFrame::SizeOf(frame.width, frame.height));
@@ skipping 29 matching lines @@
   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
 }
 
 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     const std::vector<VideoCodec>& codecs) {
   engine_.SetExternalEncoderFactory(encoder_factory);
   engine_.Init();
 
   VideoMediaChannel* channel =
-      engine_.CreateChannel(cricket::VideoOptions(), NULL);
+      engine_.CreateChannel(call_.get(), cricket::VideoOptions());
   EXPECT_TRUE(channel->SetSendCodecs(codecs));
 
   return channel;
 }
 
 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
     cricket::WebRtcVideoDecoderFactory* decoder_factory,
     const std::vector<VideoCodec>& codecs) {
   engine_.SetExternalDecoderFactory(decoder_factory);
   engine_.Init();
 
   VideoMediaChannel* channel =
-      engine_.CreateChannel(cricket::VideoOptions(), NULL);
+      engine_.CreateChannel(call_.get(), cricket::VideoOptions());
   EXPECT_TRUE(channel->SetRecvCodecs(codecs));
 
   return channel;
 }
 
 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kVp8Codec);
@@ skipping 330 matching lines @@
   EXPECT_TRUE(SetOneCodec(codec));
   codec.width /= 2;
   codec.height /= 2;
   EXPECT_TRUE(SetSend(true));
   EXPECT_TRUE(channel_->SetRender(true));
   EXPECT_EQ(0, renderer_.num_rendered_frames());
   EXPECT_TRUE(SendFrame());
   EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
 }
 
-class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test,
-                                public WebRtcCallFactory {
+class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
  public:
-  WebRtcVideoChannel2Test() : fake_call_(NULL), last_ssrc_(0) {}
+  WebRtcVideoChannel2Test() : last_ssrc_(0) {}
   void SetUp() override {
-    engine_.SetCallFactory(this);
+    fake_call_.reset(new FakeCall(webrtc::Call::Config()));
     engine_.Init();
-    channel_.reset(engine_.CreateChannel(cricket::VideoOptions(), NULL));
-    ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory.";
+    channel_.reset(
+        engine_.CreateChannel(fake_call_.get(), cricket::VideoOptions()));
     last_ssrc_ = 123;
     ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
   }
 
  protected:
   virtual std::vector<cricket::VideoCodec> GetCodecs() {
     return engine_.codecs();
   }
 
-  webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
-    DCHECK(fake_call_ == NULL);
-    fake_call_ = new FakeCall(config);
-    return fake_call_;
-  }
-
   FakeVideoSendStream* AddSendStream() {
     return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
   }
 
   FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
     size_t num_streams = fake_call_->GetVideoSendStreams().size();
     EXPECT_TRUE(channel_->AddSendStream(sp));
     std::vector<FakeVideoSendStream*> streams =
         fake_call_->GetVideoSendStreams();
     EXPECT_EQ(num_streams + 1, streams.size());
@@ skipping 33 matching lines @@
     EXPECT_EQ(expected_min_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
     EXPECT_EQ(expected_start_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
     EXPECT_EQ(expected_max_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
   }
 
   void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
                                       const std::string& webrtc_ext) {
-    FakeCall* call = fake_call_;
     // Enable extension.
     const int id = 1;
     std::vector<cricket::RtpHeaderExtension> extensions;
     extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
     EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
 
     FakeVideoSendStream* send_stream =
         AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
     // Verify the send extension id.
     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
     // Verify call with same set of extensions returns true.
     EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
     // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
     // receivers.
     EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
                     ->GetConfig()
                     .rtp.extensions.empty());
 
     // Verify that existing RTP header extensions can be removed.
     std::vector<cricket::RtpHeaderExtension> empty_extensions;
     EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions));
-    ASSERT_EQ(1u, call->GetVideoSendStreams().size());
-    send_stream = call->GetVideoSendStreams()[0];
+    ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
+    send_stream = fake_call_->GetVideoSendStreams()[0];
     EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
 
     // Verify that adding receive RTP header extensions adds them for existing
     // streams.
     EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
-    send_stream = call->GetVideoSendStreams()[0];
+    send_stream = fake_call_->GetVideoSendStreams()[0];
     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
   }
 
   void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
                                       const std::string& webrtc_ext) {
-    FakeCall* call = fake_call_;
     // Enable extension.
     const int id = 1;
     std::vector<cricket::RtpHeaderExtension> extensions;
     extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
 
     FakeVideoReceiveStream* recv_stream =
         AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 
     // Verify the recv extension id.
     ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
     // Verify call with same set of extensions returns true.
     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
 
     // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
     // senders.
     EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
                     ->GetConfig()
                     .rtp.extensions.empty());
 
     // Verify that existing RTP header extensions can be removed.
     std::vector<cricket::RtpHeaderExtension> empty_extensions;
     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions));
-    ASSERT_EQ(1u, call->GetVideoReceiveStreams().size());
-    recv_stream = call->GetVideoReceiveStreams()[0];
+    ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
+    recv_stream = fake_call_->GetVideoReceiveStreams()[0];
     EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
 
     // Verify that adding receive RTP header extensions adds them for existing
     // streams.
     EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
-    recv_stream = call->GetVideoReceiveStreams()[0];
+    recv_stream = fake_call_->GetVideoReceiveStreams()[0];
     ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
   }
 
   void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
   void TestReceiverLocalSsrcConfiguration(bool receiver_first);
   void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type,
                                         bool expect_created_receive_stream);
 
@@ skipping 17 matching lines @@
         rtx_ssrcs.push_back(ssrc + kRtxSsrcOffset);
       }
     }
     if (with_rtx) {
       return AddSendStream(
           cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
     }
     return AddSendStream(CreateSimStreamParams("cname", ssrcs));
   }
 
-  FakeCall* fake_call_;
+  rtc::scoped_ptr<FakeCall> fake_call_;
   rtc::scoped_ptr<VideoMediaChannel> channel_;
   uint32 last_ssrc_;
 };
 
 TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) {
   const uint32 kVideoSsrc = 123;
   const std::string kSyncLabel = "AvSyncLabel";
 
   cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc);
   sp.sync_label = kSyncLabel;
@@ skipping 1716 matching lines @@
 }
 
 TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrc) {
   TestReceiverLocalSsrcConfiguration(false);
 }
 
 TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers) {
   TestReceiverLocalSsrcConfiguration(true);
 }
 
-class WebRtcVideoEngine2SimulcastTest : public testing::Test {
- public:
-  WebRtcVideoEngine2SimulcastTest() : engine_(nullptr) {}
-
- protected:
-  WebRtcVideoEngine2 engine_;
-};
+class WebRtcVideoEngine2SimulcastTest : public testing::Test {};
 
 // Test that if we add a stream with RTX SSRC's, SSRC's get set correctly.
 TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestStreamWithRtx) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 // Test that if we get too few ssrcs are given in AddSendStream(),
 // only supported sub-streams will be added.
 TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TooFewSimulcastSsrcs) {
@@ skipping 126 matching lines @@
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 TEST_F(WebRtcVideoEngine2SimulcastTest,
        DISABLED_DontUseSimulcastAdapterOnNonVp8Factory) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
-class WebRtcVideoChannel2SimulcastTest : public WebRtcVideoEngine2SimulcastTest,
-                                         public WebRtcCallFactory {
+class WebRtcVideoChannel2SimulcastTest : public testing::Test {
  public:
-  WebRtcVideoChannel2SimulcastTest() : fake_call_(NULL) {}
+  WebRtcVideoChannel2SimulcastTest() : fake_call_(webrtc::Call::Config()) {}
 
   void SetUp() override {
-    engine_.SetCallFactory(this);
     engine_.Init();
-    channel_.reset(engine_.CreateChannel(VideoOptions(), NULL));
-    ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory.";
+    channel_.reset(engine_.CreateChannel(&fake_call_, VideoOptions()));
     last_ssrc_ = 123;
   }
 
  protected:
-  webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
-    DCHECK(fake_call_ == NULL);
-    fake_call_ = new FakeCall(config);
-    return fake_call_;
-  }
-
   void VerifySimulcastSettings(const VideoCodec& codec,
                                VideoOptions::HighestBitrate bitrate_mode,
                                size_t num_configured_streams,
                                size_t expected_num_streams,
                                SimulcastBitrateMode simulcast_bitrate_mode) {
     cricket::VideoOptions options;
     options.video_highest_bitrate.Set(bitrate_mode);
     EXPECT_TRUE(channel_->SetOptions(options));
 
     std::vector<VideoCodec> codecs;
@@ skipping 73 matching lines @@
 
     EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), NULL));
   }
 
   FakeVideoSendStream* AddSendStream() {
     return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++));
   }
 
   FakeVideoSendStream* AddSendStream(const StreamParams& sp) {
     size_t num_streams =
-        fake_call_->GetVideoSendStreams().size();
+        fake_call_.GetVideoSendStreams().size();
     EXPECT_TRUE(channel_->AddSendStream(sp));
     std::vector<FakeVideoSendStream*> streams =
-        fake_call_->GetVideoSendStreams();
+        fake_call_.GetVideoSendStreams();
     EXPECT_EQ(num_streams + 1, streams.size());
     return streams[streams.size() - 1];
   }
 
   std::vector<FakeVideoSendStream*> GetFakeSendStreams() {
-    return fake_call_->GetVideoSendStreams();
+    return fake_call_.GetVideoSendStreams();
   }
 
   FakeVideoReceiveStream* AddRecvStream() {
     return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++));
   }
 
   FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) {
     size_t num_streams =
-        fake_call_->GetVideoReceiveStreams().size();
+        fake_call_.GetVideoReceiveStreams().size();
     EXPECT_TRUE(channel_->AddRecvStream(sp));
     std::vector<FakeVideoReceiveStream*> streams =
-        fake_call_->GetVideoReceiveStreams();
+        fake_call_.GetVideoReceiveStreams();
     EXPECT_EQ(num_streams + 1, streams.size());
     return streams[streams.size() - 1];
   }
 
-  FakeCall* fake_call_;
+  FakeCall fake_call_;
+  WebRtcVideoEngine2 engine_;
   rtc::scoped_ptr<VideoMediaChannel> channel_;
   uint32 last_ssrc_;
 };
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
   VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL);
 }
 
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
   VerifySimulcastSettings(
@@ skipping 105 matching lines @@
 // Ensures that the correct settings are applied to the codec when two temporal
 // layer screencasting is enabled, and that the correct simulcast settings are
 // reapplied when disabling screencasting.
 TEST_F(WebRtcVideoChannel2SimulcastTest,
        DISABLED_TwoTemporalLayerScreencastSettings) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 }  // namespace cricket