Lint enabled for webrtc/modules/video_coding folder.

webrtc/modules/video_coding/video_sender_unittest.cc

 /*
  *  Copyright (c) 2013 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 23 matching lines @@
 using ::testing::NiceMock;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::FloatEq;
 using std::vector;
 using webrtc::test::FrameGenerator;
 
 namespace webrtc {
 namespace vcm {
 namespace {
-enum {
-  kMaxNumberOfTemporalLayers = 3
-};
+enum { kMaxNumberOfTemporalLayers = 3 };
 
 struct Vp8StreamInfo {
   float framerate_fps[kMaxNumberOfTemporalLayers];
   int bitrate_kbps[kMaxNumberOfTemporalLayers];
 };
 
 MATCHER_P(MatchesVp8StreamInfo, expected, "") {
   bool res = true;
   for (int tl = 0; tl < kMaxNumberOfTemporalLayers; ++tl) {
     if (fabs(expected.framerate_fps[tl] - arg.framerate_fps[tl]) > 0.5) {
@@ skipping 23 matching lines @@
   }
 
  private:
   const int width_;
   const int height_;
   rtc::scoped_ptr<VideoFrame> frame_;
 };
 
 class PacketizationCallback : public VCMPacketizationCallback {
  public:
-  PacketizationCallback(Clock* clock)
+  explicit PacketizationCallback(Clock* clock)
       : clock_(clock), start_time_ms_(clock_->TimeInMilliseconds()) {}
 
   virtual ~PacketizationCallback() {}
 
   int32_t SendData(uint8_t payload_type,
                    const EncodedImage& encoded_image,
                    const RTPFragmentationHeader& fragmentation_header,
                    const RTPVideoHeader* rtp_video_header) override {
     assert(rtp_video_header);
     frame_data_.push_back(FrameData(encoded_image._length, *rtp_video_header));
@@ skipping 103 matching lines @@
   static const int kNumberOfStreams = 3;
   static const int kNumberOfLayers = 3;
   static const int kUnusedPayloadType = 10;
 
   void SetUp() override {
     TestVideoSender::SetUp();
     sender_->RegisterExternalEncoder(&encoder_, kUnusedPayloadType, false);
     memset(&settings_, 0, sizeof(settings_));
     EXPECT_EQ(0, VideoCodingModule::Codec(kVideoCodecVP8, &settings_));
     settings_.numberOfSimulcastStreams = kNumberOfStreams;
-    ConfigureStream(kDefaultWidth / 4,
-                    kDefaultHeight / 4,
-                    100,
+    ConfigureStream(kDefaultWidth / 4, kDefaultHeight / 4, 100,
                     &settings_.simulcastStream[0]);
-    ConfigureStream(kDefaultWidth / 2,
-                    kDefaultHeight / 2,
-                    500,
+    ConfigureStream(kDefaultWidth / 2, kDefaultHeight / 2, 500,
                     &settings_.simulcastStream[1]);
-    ConfigureStream(
-        kDefaultWidth, kDefaultHeight, 1200, &settings_.simulcastStream[2]);
+    ConfigureStream(kDefaultWidth, kDefaultHeight, 1200,
+                    &settings_.simulcastStream[2]);
     settings_.plType = kUnusedPayloadType;  // Use the mocked encoder.
     generator_.reset(
         new EmptyFrameGenerator(settings_.width, settings_.height));
     EXPECT_EQ(0, sender_->RegisterSendCodec(&settings_, 1, 1200));
   }
 
   void TearDown() override { sender_.reset(); }
 
   void ExpectIntraRequest(int stream) {
     if (stream == -1) {
       // No intra request expected.
       EXPECT_CALL(
           encoder_,
           Encode(_, _, Pointee(ElementsAre(kVideoFrameDelta, kVideoFrameDelta,
                                            kVideoFrameDelta))))
           .Times(1)
           .WillRepeatedly(Return(0));
       return;
     }
     assert(stream >= 0);
     assert(stream < kNumberOfStreams);
     std::vector<FrameType> frame_types(kNumberOfStreams, kVideoFrameDelta);
     frame_types[stream] = kVideoFrameKey;
-    EXPECT_CALL(
-        encoder_,
-        Encode(_,
-               _,
-               Pointee(ElementsAreArray(&frame_types[0], frame_types.size()))))
-        .Times(1).WillRepeatedly(Return(0));
+    EXPECT_CALL(encoder_,
+                Encode(_, _, Pointee(ElementsAreArray(&frame_types[0],
+                                                      frame_types.size()))))
+        .Times(1)
+        .WillRepeatedly(Return(0));
   }
 
   static void ConfigureStream(int width,
                               int height,
                               int max_bitrate,
                               SimulcastStream* stream) {
     assert(stream);
     stream->width = width;
     stream->height = height;
     stream->maxBitrate = max_bitrate;
@@ skipping 217 matching lines @@
   }
   {
     // TODO(andresp): Find out why this fails with framerate = 7.5
     Vp8StreamInfo expected = {{7.0, 7.0, 7.0}, {high_b, high_b, high_b}};
     EXPECT_THAT(SimulateWithFramerate(7.0), MatchesVp8StreamInfo(expected));
   }
 }
 }  // namespace
 }  // namespace vcm
 }  // namespace webrtc