Fix flaky ViEEncoder tests.

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 63 matching lines @@
 
   void PostTaskAndWait(bool down, AdaptReason reason) {
     rtc::Event event(false, false);
     encoder_queue()->PostTask([this, &event, reason, down] {
       down ? AdaptDown(reason) : AdaptUp(reason);
       event.Set();
     });
     ASSERT_TRUE(event.Wait(5000));
   }
 
+  // This is used as a synchronisation mechanism, to make sure that the
+  // encoder queue is not blocked before we start sending it frames.
+  void WaitUntilTaskQueueIsIdle() {
+    rtc::Event event(false, false);
+    encoder_queue()->PostTask([&event] {
+      event.Set();
+    });
+    ASSERT_TRUE(event.Wait(5000));
+  }
+
   void TriggerCpuOveruse() { PostTaskAndWait(true, AdaptReason::kCpu); }
 
   void TriggerCpuNormalUsage() { PostTaskAndWait(false, AdaptReason::kCpu); }
 
   void TriggerQualityLow() { PostTaskAndWait(true, AdaptReason::kQuality); }
 
   void TriggerQualityHigh() { PostTaskAndWait(false, AdaptReason::kQuality); }
 };
 
 class VideoStreamFactory
@@ skipping 100 matching lines @@
     if (vie_encoder_)
       vie_encoder_->Stop();
     vie_encoder_.reset(new ViEEncoderUnderTest(
         stats_proxy_.get(), video_send_config_.encoder_settings));
     vie_encoder_->SetSink(&sink_, false /* rotation_applied */);
     vie_encoder_->SetSource(&video_source_,
                             VideoSendStream::DegradationPreference::kBalanced);
     vie_encoder_->SetStartBitrate(kTargetBitrateBps);
     vie_encoder_->ConfigureEncoder(std::move(video_encoder_config),
                                    kMaxPayloadLength, nack_enabled);
+    vie_encoder_->WaitUntilTaskQueueIsIdle();
   }
 
   void ResetEncoder(const std::string& payload_name,
                     size_t num_streams,
                     size_t num_temporal_layers,
                     bool nack_enabled) {
     video_send_config_.encoder_settings.payload_name = payload_name;
 
     VideoEncoderConfig video_encoder_config;
     video_encoder_config.number_of_streams = num_streams;
@@ skipping 30 matching lines @@
       rtc::CritScope lock(&crit_sect_);
       return config_;
     }
 
     void BlockNextEncode() {
       rtc::CritScope lock(&local_crit_sect_);
       block_next_encode_ = true;
     }
 
     VideoEncoder::ScalingSettings GetScalingSettings() const override {
+      rtc::CritScope lock(&local_crit_sect_);
       if (quality_scaling_)
         return VideoEncoder::ScalingSettings(true, 1, 2);
       return VideoEncoder::ScalingSettings(false);
     }
 
     void ContinueEncode() { continue_encode_event_.Set(); }
 
     void CheckLastTimeStampsMatch(int64_t ntp_time_ms,
                                   uint32_t timestamp) const {
       rtc::CritScope lock(&local_crit_sect_);
       EXPECT_EQ(timestamp_, timestamp);
       EXPECT_EQ(ntp_time_ms_, ntp_time_ms);
     }
 
-    void SetQualityScaling(bool b) { quality_scaling_ = b; }
+    void SetQualityScaling(bool b) {
+      rtc::CritScope lock(&local_crit_sect_);
+      quality_scaling_ = b;
+    }
 
    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(&local_crit_sect_);
         EXPECT_GT(input_image.timestamp(), timestamp_);
         EXPECT_GT(input_image.ntp_time_ms(), ntp_time_ms_);
@@ skipping 45 matching lines @@
       EXPECT_TRUE(encoded_frame_event_.Wait(kDefaultTimeoutMs));
       {
         rtc::CritScope lock(&crit_);
         width = last_width_;
         height = last_height_;
       }
       EXPECT_EQ(expected_height, height);
       EXPECT_EQ(expected_width, width);
     }
 
-    void ExpectDroppedFrame() { EXPECT_FALSE(encoded_frame_event_.Wait(20)); }
+    void ExpectDroppedFrame() { EXPECT_FALSE(encoded_frame_event_.Wait(100)); }
 
     void SetExpectNoFrames() {
       rtc::CritScope lock(&crit_);
       expect_frames_ = false;
     }
 
     int number_of_reconfigurations() {
       rtc::CritScope lock(&crit_);
       return number_of_reconfigurations_;
     }
@@ skipping 787 matching lines @@
       CreateFrame(2, frame_width * 3 / 4, frame_height * 3 / 4));
 
   // Expect to drop this frame, the wait should time out.
   sink_.ExpectDroppedFrame();
 
   EXPECT_LT(*video_source_.sink_wants().max_pixel_count, last_pixel_count);
 
   vie_encoder_->Stop();
 }
 
-#if defined(MEMORY_SANITIZER)
-// Fails under MemorySanitizer: See http://crbug.com/webrtc/7232
-#define MAYBE_NrOfDroppedFramesLimited DISABLED_NrOfDroppedFramesLimited
-#else
-#define MAYBE_NrOfDroppedFramesLimited NrOfDroppedFramesLimited
-#endif
-TEST_F(ViEEncoderTest, MAYBE_NrOfDroppedFramesLimited) {
+TEST_F(ViEEncoderTest, NrOfDroppedFramesLimited) {
   // 1kbps. This can never be achieved.
   vie_encoder_->OnBitrateUpdated(1000, 0, 0);
   int frame_width = 640;
   int frame_height = 360;
 
   // We expect the n initial frames to get dropped.
   int i;
   for (i = 1; i <= kMaxInitialFramedrop; ++i) {
     video_source_.IncomingCapturedFrame(
         CreateFrame(i, frame_width, frame_height));
@@ skipping 22 matching lines @@
       VideoSendStream::DegradationPreference::kMaintainResolution);
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
   // Frame should not be dropped, even if it's too large.
   sink_.WaitForEncodedFrame(1);
 
   vie_encoder_->Stop();
 }
 
-// Disable for TSan v2, see https://crbug.com/webrtc/7260 for details.
-#if defined(THREAD_SANITIZER)
-#define MAYBE_InitialFrameDropOffWhenEncoderDisabledScaling \
-  DISABLED_InitialFrameDropOffWhenEncoderDisabledScaling
-#else
-#define MAYBE_InitialFrameDropOffWhenEncoderDisabledScaling \
-  InitialFrameDropOffWhenEncoderDisabledScaling
-#endif
-TEST_F(ViEEncoderTest, MAYBE_InitialFrameDropOffWhenEncoderDisabledScaling) {
+TEST_F(ViEEncoderTest, InitialFrameDropOffWhenEncoderDisabledScaling) {
   int frame_width = 640;
   int frame_height = 360;
   fake_encoder_.SetQualityScaling(false);
   vie_encoder_->OnBitrateUpdated(kLowTargetBitrateBps, 0, 0);
   // Force quality scaler reconfiguration by resetting the source.
   vie_encoder_->SetSource(&video_source_,
                           VideoSendStream::DegradationPreference::kBalanced);
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
@@ skipping 26 matching lines @@
 
   // Trigger CPU normal use, return to original resoluton;
   vie_encoder_->TriggerCpuNormalUsage();
   video_source_.IncomingCapturedFrame(
       CreateFrame(3, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(kFrameWidth, kFrameHeight);
 
   vie_encoder_->Stop();
 }
 }  // namespace webrtc