Make FakeEncoder and FakeH264Encoder thread safe.

webrtc/video/vie_encoder_unittest.cc

 /*
  *  Copyright (c) 2016 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 168 matching lines @@
     return frame;
   }
 
   class TestEncoder : public test::FakeEncoder {
    public:
     TestEncoder()
         : FakeEncoder(Clock::GetRealTimeClock()),
           continue_encode_event_(false, false) {}
 
     VideoCodec codec_config() {
-      rtc::CritScope lock(&crit_);
+      rtc::CritScope lock(&crit_sect_);
       return config_;
     }
 
     void BlockNextEncode() {
-      rtc::CritScope lock(&crit_);
+      rtc::CritScope lock(&local_crit_sect_);
       block_next_encode_ = true;
     }
 
     VideoEncoder::ScalingSettings GetScalingSettings() const override {
       return VideoEncoder::ScalingSettings(true, 1, 2);
     }
 
     void ContinueEncode() { continue_encode_event_.Set(); }
 
     void CheckLastTimeStampsMatch(int64_t ntp_time_ms,
                                   uint32_t timestamp) const {
-      rtc::CritScope lock(&crit_);
+      rtc::CritScope lock(&local_crit_sect_);
       EXPECT_EQ(timestamp_, timestamp);
       EXPECT_EQ(ntp_time_ms_, ntp_time_ms);
     }
 
    private:
     int32_t Encode(const VideoFrame& input_image,
                    const CodecSpecificInfo* codec_specific_info,
                    const std::vector<FrameType>* frame_types) override {
       bool block_encode;
       {
-        rtc::CritScope lock(&crit_);
+        rtc::CritScope lock(&local_crit_sect_);
         EXPECT_GT(input_image.timestamp(), timestamp_);
         EXPECT_GT(input_image.ntp_time_ms(), ntp_time_ms_);
         EXPECT_EQ(input_image.timestamp(), input_image.ntp_time_ms() * 90);
 
         timestamp_ = input_image.timestamp();
         ntp_time_ms_ = input_image.ntp_time_ms();
         last_input_width_ = input_image.width();
         last_input_height_ = input_image.height();
         block_encode = block_next_encode_;
         block_next_encode_ = false;
       }
       int32_t result =
           FakeEncoder::Encode(input_image, codec_specific_info, frame_types);
       if (block_encode)
         EXPECT_TRUE(continue_encode_event_.Wait(kDefaultTimeoutMs));
       return result;
     }
 
-    rtc::CriticalSection crit_;
+    rtc::CriticalSection local_crit_sect_;
     bool block_next_encode_ = false;
     rtc::Event continue_encode_event_;
     uint32_t timestamp_ = 0;
     int64_t ntp_time_ms_ = 0;
     int last_input_width_ = 0;
     int last_input_height_ = 0;
   };
 
   class TestSink : public ViEEncoder::EncoderSink {
    public:
@@ skipping 726 matching lines @@
   vie_encoder_->Stop();
 
   stats_proxy_.reset();
   EXPECT_EQ(1,
             metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent"));
   EXPECT_EQ(
       1, metrics::NumEvents("WebRTC.Video.CpuLimitedResolutionInPercent", 50));
 }
 
 }  // namespace webrtc