Add a race-checking mechanism.

webrtc/modules/video_coding/generic_encoder.cc

 /*
 *  Copyright (c) 2012 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 18 matching lines @@
     : encoder_(encoder),
       rate_observer_(rate_observer),
       vcm_encoded_frame_callback_(encoded_frame_callback),
       internal_source_(internal_source),
       encoder_params_({0, 0, 0, 0}),
       is_screenshare_(false) {}
 
 VCMGenericEncoder::~VCMGenericEncoder() {}
 
 int32_t VCMGenericEncoder::Release() {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   TRACE_EVENT0("webrtc", "VCMGenericEncoder::Release");
   return encoder_->Release();
 }
 
 int32_t VCMGenericEncoder::InitEncode(const VideoCodec* settings,
                                       int32_t number_of_cores,
                                       size_t max_payload_size) {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   TRACE_EVENT0("webrtc", "VCMGenericEncoder::InitEncode");
   is_screenshare_ = settings->mode == VideoCodecMode::kScreensharing;
   if (encoder_->InitEncode(settings, number_of_cores, max_payload_size) != 0) {
     LOG(LS_ERROR) << "Failed to initialize the encoder associated with "
                      "payload name: "
                   << settings->plName;
     return -1;
   }
   encoder_->RegisterEncodeCompleteCallback(vcm_encoded_frame_callback_);
   return 0;
 }
 
 int32_t VCMGenericEncoder::Encode(const VideoFrame& frame,
                                   const CodecSpecificInfo* codec_specific,
                                   const std::vector<FrameType>& frame_types) {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   TRACE_EVENT1("webrtc", "VCMGenericEncoder::Encode", "timestamp",
                frame.timestamp());
 
   for (FrameType frame_type : frame_types)
     RTC_DCHECK(frame_type == kVideoFrameKey || frame_type == kVideoFrameDelta);
 
   int32_t result = encoder_->Encode(frame, codec_specific, &frame_types);
 
   if (is_screenshare_ &&
       result == WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT) {
     // Target bitrate exceeded, encoder state has been reset - try again.
     return encoder_->Encode(frame, codec_specific, &frame_types);
   }
 
   return result;
 }
 
 const char* VCMGenericEncoder::ImplementationName() const {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   return encoder_->ImplementationName();
 }
 
 void VCMGenericEncoder::SetEncoderParameters(const EncoderParameters& params) {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   bool channel_parameters_have_changed;
   bool rates_have_changed;
   {
     rtc::CritScope lock(&params_lock_);
     channel_parameters_have_changed =
         params.loss_rate != encoder_params_.loss_rate ||
         params.rtt != encoder_params_.rtt;
     rates_have_changed =
         params.target_bitrate != encoder_params_.target_bitrate ||
         params.input_frame_rate != encoder_params_.input_frame_rate;
@@ skipping 10 matching lines @@
     }
   }
 }
 
 EncoderParameters VCMGenericEncoder::GetEncoderParameters() const {
   rtc::CritScope lock(&params_lock_);
   return encoder_params_;
 }
 
 int32_t VCMGenericEncoder::SetPeriodicKeyFrames(bool enable) {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   return encoder_->SetPeriodicKeyFrames(enable);
 }
 
 int32_t VCMGenericEncoder::RequestFrame(
     const std::vector<FrameType>& frame_types) {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   VideoFrame image;
   return encoder_->Encode(image, NULL, &frame_types);
 }
 
 bool VCMGenericEncoder::InternalSource() const {
   return internal_source_;
 }
 
 void VCMGenericEncoder::OnDroppedFrame() {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   encoder_->OnDroppedFrame();
 }
 
 bool VCMGenericEncoder::SupportsNativeHandle() const {
+  RTC_DCHECK_RUNS_SINGLE_THREADED(&race_checker_);
   return encoder_->SupportsNativeHandle();
 }
 
 VCMEncodedFrameCallback::VCMEncodedFrameCallback(
     EncodedImageCallback* post_encode_callback,
     media_optimization::MediaOptimization* media_opt)
     : internal_source_(false),
       post_encode_callback_(post_encode_callback),
       media_opt_(media_opt) {}
 
@@ skipping 12 matching lines @@
 
   if (media_opt_) {
     media_opt_->UpdateWithEncodedData(encoded_image);
     if (internal_source_)
       return media_opt_->DropFrame();  // Signal to encoder to drop next frame.
   }
   return VCM_OK;
 }
 
 }  // namespace webrtc