Make FakeEncoder and FakeH264Encoder thread safe.

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include <algorithm>  // max
@@ skipping 431 matching lines @@
     config.loss_percent = 5;
     config.queue_delay_ms = kNetworkDelayMs;
     return new test::PacketTransport(sender_call, this,
                                      test::PacketTransport::kSender, config);
   }
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
-    transport_adapter_.reset(
-        new internal::TransportAdapter(send_config->send_transport));
-    transport_adapter_->Enable();
     if (use_nack_) {
       send_config->rtp.nack.rtp_history_ms =
           (*receive_configs)[0].rtp.nack.rtp_history_ms =
               VideoSendStreamTest::kNackRtpHistoryMs;
     }
     send_config->encoder_settings.encoder = encoder_;
     send_config->encoder_settings.payload_name = payload_name_;
     send_config->rtp.ulpfec.red_payload_type =
         VideoSendStreamTest::kRedPayloadType;
     send_config->rtp.ulpfec.ulpfec_payload_type =
         VideoSendStreamTest::kUlpfecPayloadType;
     if (header_extensions_enabled_) {
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                        test::kTransportSequenceNumberExtensionId));
     }
     (*receive_configs)[0].rtp.ulpfec.red_payload_type =
         send_config->rtp.ulpfec.red_payload_type;
     (*receive_configs)[0].rtp.ulpfec.ulpfec_payload_type =
         send_config->rtp.ulpfec.ulpfec_payload_type;
   }
 
   void PerformTest() override {
     EXPECT_EQ(expect_ulpfec_, Wait())
         << "Timed out waiting for ULPFEC and/or media packets.";
   }
 
-  std::unique_ptr<internal::TransportAdapter> transport_adapter_;
   VideoEncoder* const encoder_;
   std::string payload_name_;
   const bool use_nack_;
   const bool expect_red_;
   const bool expect_ulpfec_;
   bool sent_media_;
   bool sent_ulpfec_;
   bool header_extensions_enabled_;
   RTPHeader prev_header_;
 };
@@ skipping 36 matching lines @@
 }
 
 #if !defined(RTC_DISABLE_VP9)
 TEST_F(VideoSendStreamTest, DoesUtilizeUlpfecForVp9WithNackEnabled) {
   std::unique_ptr<VideoEncoder> encoder(VP9Encoder::Create());
   UlpfecObserver test(false, true, true, true, "VP9", encoder.get());
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
-TEST_F(VideoSendStreamTest, SupportsUlpfecWithMultiThreadedH264) {
+TEST_F(VideoSendStreamTest, SupportsUlpfecWithMultithreadedH264) {
   std::unique_ptr<VideoEncoder> encoder(
-      new test::MultiThreadedFakeH264Encoder(Clock::GetRealTimeClock()));
+      new test::MultithreadedFakeH264Encoder(Clock::GetRealTimeClock()));
   UlpfecObserver test(false, false, true, true, "H264", encoder.get());
   RunBaseTest(&test);
 }
 
 // TODO(brandtr): Move these FlexFEC tests when we have created
 // FlexfecSendStream.
 class FlexfecObserver : public test::EndToEndTest {
  public:
   FlexfecObserver(bool header_extensions_enabled,
                   bool use_nack,
@@ skipping 45 matching lines @@
     config.loss_percent = 5;
     config.queue_delay_ms = kNetworkDelayMs;
     return new test::PacketTransport(sender_call, this,
                                      test::PacketTransport::kSender, config);
   }
 
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
       VideoEncoderConfig* encoder_config) override {
-    transport_adapter_.reset(
-        new internal::TransportAdapter(send_config->send_transport));
-    transport_adapter_->Enable();
     if (use_nack_) {
       send_config->rtp.nack.rtp_history_ms =
           (*receive_configs)[0].rtp.nack.rtp_history_ms =
               VideoSendStreamTest::kNackRtpHistoryMs;
     }
     send_config->encoder_settings.encoder = encoder_;
     send_config->encoder_settings.payload_name = payload_name_;
     if (header_extensions_enabled_) {
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
       send_config->rtp.extensions.push_back(RtpExtension(
           RtpExtension::kTimestampOffsetUri, test::kTOffsetExtensionId));
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumberUri,
                        test::kTransportSequenceNumberExtensionId));
     }
   }
 
   void PerformTest() override {
     EXPECT_TRUE(Wait())
         << "Timed out waiting for FlexFEC and/or media packets.";
   }
 
-  std::unique_ptr<internal::TransportAdapter> transport_adapter_;
   VideoEncoder* const encoder_;
   std::string payload_name_;
   const bool use_nack_;
   bool sent_media_;
   bool sent_flexfec_;
   bool header_extensions_enabled_;
 };
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecVp8) {
   std::unique_ptr<VideoEncoder> encoder(VP8Encoder::Create());
@@ skipping 34 matching lines @@
   RunBaseTest(&test);
 }
 
 TEST_F(VideoSendStreamTest, SupportsFlexfecWithNackH264) {
   std::unique_ptr<VideoEncoder> encoder(
       new test::FakeH264Encoder(Clock::GetRealTimeClock()));
   FlexfecObserver test(false, true, "H264", encoder.get());
   RunBaseTest(&test);
 }
 
-TEST_F(VideoSendStreamTest, SupportsFlexfecWithMultiThreadedH264) {
+TEST_F(VideoSendStreamTest, SupportsFlexfecWithMultithreadedH264) {
   std::unique_ptr<VideoEncoder> encoder(
-      new test::MultiThreadedFakeH264Encoder(Clock::GetRealTimeClock()));
+      new test::MultithreadedFakeH264Encoder(Clock::GetRealTimeClock()));
   FlexfecObserver test(false, false, "H264", encoder.get());
   RunBaseTest(&test);
 }
 
 void VideoSendStreamTest::TestNackRetransmission(
     uint32_t retransmit_ssrc,
     uint8_t retransmit_payload_type) {
   class NackObserver : public test::SendTest {
    public:
     explicit NackObserver(uint32_t retransmit_ssrc,
@@ skipping 1929 matching lines @@
       uint8_t buffer[16] = {0};
       EncodedImage encoded(buffer, sizeof(buffer), sizeof(buffer));
       encoded._timeStamp = input_image.timestamp();
       encoded.capture_time_ms_ = input_image.render_time_ms();
 
       for (size_t i = 0; i < kNumStreams; ++i) {
         specifics.codecSpecific.generic.simulcast_idx = static_cast<uint8_t>(i);
         encoded._frameType = (*frame_types)[i];
         encoded._encodedWidth = kEncodedResolution[i].width;
         encoded._encodedHeight = kEncodedResolution[i].height;
-        RTC_DCHECK(callback_);
-        if (callback_->OnEncodedImage(encoded, &specifics, nullptr).error !=
+        EncodedImageCallback* callback;
+        {
+          rtc::CritScope cs(&crit_sect_);
+          callback = callback_;
+        }
+        RTC_DCHECK(callback);
+        if (callback->OnEncodedImage(encoded, &specifics, nullptr).error !=
             EncodedImageCallback::Result::OK) {
           return -1;
         }
       }
 
       observation_complete_.Set();
       return 0;
     }
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
@@ skipping 582 matching lines @@
    private:
     Call* call_;
     rtc::CriticalSection crit_;
     uint32_t max_bitrate_kbps_ GUARDED_BY(&crit_);
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc