Add some unit tests to vie_encoder.

webrtc/video/vie_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 195 matching lines @@
         wants.target_pixel_count.reset();
         wants.max_framerate_fps = std::numeric_limits<int>::max();
     }
     return wants;
   }
 
   void RequestResolutionLowerThan(int pixel_count) {
     // Called on the encoder task queue.
     rtc::CritScope lock(&crit_);
     if (!IsResolutionScalingEnabledLocked()) {
-      // This can happen since |degradation_preference_| is set on
-      // libjingle's worker thread but the adaptation is done on the encoder
-      // task queue.
+      // This can happen since |degradation_preference_| is set on libjingle's
+      // worker thread but the adaptation is done on the encoder task queue.
       return;
     }
     // The input video frame size will have a resolution with less than or
     // equal to |max_pixel_count| depending on how the source can scale the
     // input frame size.
     const int pixels_wanted = (pixel_count * 3) / 5;
     if (pixels_wanted < kMinPixelsPerFrame)
       return;
     sink_wants_.max_pixel_count = pixels_wanted;
     sink_wants_.target_pixel_count = rtc::Optional<int>();
     if (source_)
       source_->AddOrUpdateSink(vie_encoder_, GetActiveSinkWants());
   }
 
   void RequestFramerateLowerThan(int framerate_fps) {
     // Called on the encoder task queue.
     rtc::CritScope lock(&crit_);
     if (!IsFramerateScalingEnabledLocked()) {
-      // This can happen since |degradation_preference_| is set on
-      // libjingle's worker thread but the adaptation is done on the encoder
-      // task queue.
+      // This can happen since |degradation_preference_| is set on libjingle's
+      // worker thread but the adaptation is done on the encoder task queue.
       return;
     }
     // The input video frame rate will be scaled down to 2/3 of input fps,
     // rounding down.
     const int framerate_wanted =
         std::max(kMinFramerateFps, (framerate_fps * 2) / 3);
     sink_wants_.max_framerate_fps = framerate_wanted;
     if (source_)
       source_->AddOrUpdateSink(vie_encoder_, GetActiveSinkWants());
   }
 
   void RequestHigherResolutionThan(int pixel_count) {
     rtc::CritScope lock(&crit_);
     if (!IsResolutionScalingEnabledLocked()) {
-      // This can happen since |degradation_preference_| is set on
-      // libjingle's worker thread but the adaptation is done on the encoder
-      // task queue.
+      // This can happen since |degradation_preference_| is set on libjingle's
+      // worker thread but the adaptation is done on the encoder task queue.
       return;
     }
 
     if (pixel_count == std::numeric_limits<int>::max()) {
       // Remove any constraints.
       sink_wants_.target_pixel_count.reset();
       sink_wants_.max_pixel_count = std::numeric_limits<int>::max();
     } else {
       // On step down we request at most 3/5 the pixel count of the previous
       // resolution, so in order to take "one step up" we request a resolution
       // as close as possible to 5/3 of the current resolution. The actual pixel
       // count selected depends on the capabilities of the source. In order to
       // not take a too large step up, we cap the requested pixel count to be at
       // most four time the current number of pixels.
       sink_wants_.target_pixel_count =
           rtc::Optional<int>((pixel_count * 5) / 3);
       sink_wants_.max_pixel_count = pixel_count * 4;
     }
     if (source_)
       source_->AddOrUpdateSink(vie_encoder_, GetActiveSinkWants());
   }
 
   void RequestHigherFramerateThan(int framerate_fps) {
     // Called on the encoder task queue.
     rtc::CritScope lock(&crit_);
     if (!IsFramerateScalingEnabledLocked()) {
-      // This can happen since |degradation_preference_| is set on
-      // libjingle's worker thread but the adaptation is done on the encoder
-      // task queue.
+      // This can happen since |degradation_preference_| is set on libjingle's
+      // worker thread but the adaptation is done on the encoder task queue.
       return;
     }
     if (framerate_fps == std::numeric_limits<int>::max()) {
       // Remove any restrains.
       sink_wants_.max_framerate_fps = std::numeric_limits<int>::max();
     } else {
       // The input video frame rate will be scaled up to the last step, with
       // rounding.
       const int framerate_wanted = (framerate_fps * 3) / 2;
       sink_wants_.max_framerate_fps = framerate_wanted;
@@ skipping 675 matching lines @@
 void ViEEncoder::IncrementScaleCounter(int reason, int delta) {
   // Get the counters and validate. This may also lazily initialize the state.
   const std::vector<int>& counter = GetScaleCounters();
   if (delta < 0) {
     RTC_DCHECK_GE(counter[reason], delta);
   }
   scale_counters_[degradation_preference_][reason] += delta;
 }
 
 }  // namespace webrtc