Lint enabled for webrtc/modules/video_coding folder.

webrtc/modules/video_coding/utility/quality_scaler_unittest.cc

 /*
  *  Copyright (c) 2014 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 15 matching lines @@
 }  // namespace
 
 class QualityScalerTest : public ::testing::Test {
  public:
   // Temporal and spatial resolution.
   struct Resolution {
     int framerate;
     int width;
     int height;
   };
+
  protected:
   enum ScaleDirection {
     kKeepScaleAtHighQp,
     kScaleDown,
     kScaleDownAboveHighQp,
     kScaleUp
   };
   enum BadQualityMetric { kDropFrame, kReportLowQP };
 
   QualityScalerTest() {
-    input_frame_.CreateEmptyFrame(
-        kWidth, kHeight, kWidth, kHalfWidth, kHalfWidth);
+    input_frame_.CreateEmptyFrame(kWidth, kHeight, kWidth, kHalfWidth,
+                                  kHalfWidth);
     qs_.Init(kMaxQp / QualityScaler::kDefaultLowQpDenominator, kHighQp, false);
     qs_.ReportFramerate(kFramerate);
     qs_.OnEncodeFrame(input_frame_);
   }
 
   bool TriggerScale(ScaleDirection scale_direction) {
     qs_.OnEncodeFrame(input_frame_);
     int initial_width = qs_.GetScaledResolution().width;
     for (int i = 0; i < kFramerate * kNumSeconds; ++i) {
       switch (scale_direction) {
@@ skipping 32 matching lines @@
   }
 
   void ContinuouslyDownscalesByHalfDimensionsAndBackUp();
 
   void DoesNotDownscaleFrameDimensions(int width, int height);
 
   Resolution TriggerResolutionChange(BadQualityMetric dropframe_lowqp,
                                      int num_second,
                                      int initial_framerate);
 
-  void VerifyQualityAdaptation(int initial_framerate, int seconds,
+  void VerifyQualityAdaptation(int initial_framerate,
+                               int seconds,
                                bool expect_spatial_resize,
                                bool expect_framerate_reduction);
 
   void DownscaleEndsAt(int input_width,
                        int input_height,
                        int end_width,
                        int end_height);
 
   QualityScaler qs_;
   VideoFrame input_frame_;
@@ skipping 65 matching lines @@
 
     qs_.ReportDroppedFrame();
     qs_.OnEncodeFrame(input_frame_);
     ASSERT_EQ(input_frame_.width(), qs_.GetScaledResolution().width)
         << "Unexpected scale on half framedrop.";
   }
 }
 
 void QualityScalerTest::ContinuouslyDownscalesByHalfDimensionsAndBackUp() {
   const int initial_min_dimension = input_frame_.width() < input_frame_.height()
-                                  ? input_frame_.width()
-                                  : input_frame_.height();
+                                        ? input_frame_.width()
+                                        : input_frame_.height();
   int min_dimension = initial_min_dimension;
   int current_shift = 0;
   // Drop all frames to force-trigger downscaling.
   while (min_dimension >= 2 * QualityScaler::kDefaultMinDownscaleDimension) {
     EXPECT_TRUE(TriggerScale(kScaleDown)) << "No downscale within "
                                           << kNumSeconds << " seconds.";
     qs_.OnEncodeFrame(input_frame_);
     QualityScaler::Resolution res = qs_.GetScaledResolution();
     min_dimension = res.width < res.height ? res.width : res.height;
     ++current_shift;
@@ skipping 24 matching lines @@
 
 TEST_F(QualityScalerTest, ContinuouslyDownscalesByHalfDimensionsAndBackUp) {
   ContinuouslyDownscalesByHalfDimensionsAndBackUp();
 }
 
 TEST_F(QualityScalerTest,
        ContinuouslyDownscalesOddResolutionsByHalfDimensionsAndBackUp) {
   const int kOddWidth = 517;
   const int kHalfOddWidth = (kOddWidth + 1) / 2;
   const int kOddHeight = 1239;
-  input_frame_.CreateEmptyFrame(
-      kOddWidth, kOddHeight, kOddWidth, kHalfOddWidth, kHalfOddWidth);
+  input_frame_.CreateEmptyFrame(kOddWidth, kOddHeight, kOddWidth, kHalfOddWidth,
+                                kHalfOddWidth);
   ContinuouslyDownscalesByHalfDimensionsAndBackUp();
 }
 
 void QualityScalerTest::DoesNotDownscaleFrameDimensions(int width, int height) {
-  input_frame_.CreateEmptyFrame(
-      width, height, width, (width + 1) / 2, (width + 1) / 2);
+  input_frame_.CreateEmptyFrame(width, height, width, (width + 1) / 2,
+                                (width + 1) / 2);
 
   for (int i = 0; i < kFramerate * kNumSeconds; ++i) {
     qs_.ReportDroppedFrame();
     qs_.OnEncodeFrame(input_frame_);
     ASSERT_EQ(input_frame_.width(), qs_.GetScaledResolution().width)
         << "Unexpected scale of minimal-size frame.";
   }
 }
 
 TEST_F(QualityScalerTest, DoesNotDownscaleFrom1PxWidth) {
   DoesNotDownscaleFrameDimensions(1, kHeight);
 }
 
 TEST_F(QualityScalerTest, DoesNotDownscaleFrom1PxHeight) {
   DoesNotDownscaleFrameDimensions(kWidth, 1);
 }
 
 TEST_F(QualityScalerTest, DoesNotDownscaleFrom1Px) {
   DoesNotDownscaleFrameDimensions(1, 1);
 }
 
 QualityScalerTest::Resolution QualityScalerTest::TriggerResolutionChange(
-    BadQualityMetric dropframe_lowqp, int num_second, int initial_framerate) {
+    BadQualityMetric dropframe_lowqp,
+    int num_second,
+    int initial_framerate) {
   QualityScalerTest::Resolution res;
   res.framerate = initial_framerate;
   qs_.OnEncodeFrame(input_frame_);
   res.width = qs_.GetScaledResolution().width;
   res.height = qs_.GetScaledResolution().height;
   for (int i = 0; i < kFramerate * num_second; ++i) {
     switch (dropframe_lowqp) {
       case kReportLowQP:
         qs_.ReportQP(kLowQp);
         break;
       case kDropFrame:
         qs_.ReportDroppedFrame();
         break;
     }
     qs_.OnEncodeFrame(input_frame_);
     // Simulate the case when SetRates is called right after reducing
     // framerate.
     qs_.ReportFramerate(initial_framerate);
     res.framerate = qs_.GetTargetFramerate();
     if (res.framerate != -1)
       qs_.ReportFramerate(res.framerate);
     res.width = qs_.GetScaledResolution().width;
     res.height = qs_.GetScaledResolution().height;
   }
   return res;
 }
 
 void QualityScalerTest::VerifyQualityAdaptation(
-    int initial_framerate, int seconds, bool expect_spatial_resize,
+    int initial_framerate,
+    int seconds,
+    bool expect_spatial_resize,
     bool expect_framerate_reduction) {
   const int kDisabledBadQpThreshold = kMaxQp + 1;
   qs_.Init(kMaxQp / QualityScaler::kDefaultLowQpDenominator,
            kDisabledBadQpThreshold, true);
   qs_.OnEncodeFrame(input_frame_);
   int init_width = qs_.GetScaledResolution().width;
   int init_height = qs_.GetScaledResolution().height;
 
   // Test reducing framerate by dropping frame continuously.
-  QualityScalerTest::Resolution res = TriggerResolutionChange(
-      kDropFrame, seconds, initial_framerate);
+  QualityScalerTest::Resolution res =
+      TriggerResolutionChange(kDropFrame, seconds, initial_framerate);
 
   if (expect_framerate_reduction) {
     EXPECT_LT(res.framerate, initial_framerate);
   } else {
     // No framerate reduction, video decimator should be disabled.
     EXPECT_EQ(-1, res.framerate);
   }
 
   if (expect_spatial_resize) {
     EXPECT_LT(res.width, init_width);
@@ skipping 97 matching lines @@
   DownscaleEndsAt(1600, 800, 200, 100);
 }
 
 TEST_F(QualityScalerTest, RespectsMinResolutionHeight) {
   // Should end at 100x200, as height can't go lower.
   qs_.SetMinResolution(10, 200);
   DownscaleEndsAt(800, 1600, 100, 200);
 }
 
 }  // namespace webrtc