Lint clean video/ and add lint presubmit check.

BUG=webrtc:5316

Review URL: https://codereview.webrtc.org/1507643004

Cr-Commit-Position: refs/heads/master@{#10953}

PRESUBMIT.py

@@ -19,6 +19,7 @@ CPPLINT_DIRS = [
   'webrtc/audio',
   'webrtc/call',
   'webrtc/modules/video_processing',
+  'webrtc/video',
 ]
 
 # List of directories of "supported" native APIs. That means changes to headers

webrtc/video/end_to_end_tests.cc

@@ -48,7 +48,7 @@
 
 namespace webrtc {
 
-static const unsigned long kSilenceTimeoutMs = 2000;
+static const uint32_t kSilenceTimeoutMs = 2000;
 
 class EndToEndTest : public test::CallTest {
  public:
@@ -558,7 +558,7 @@ TEST_F(EndToEndTest, CanReceiveFec) {
 TEST_F(EndToEndTest, DISABLED_ReceivedFecPacketsNotNacked) {
   class FecNackObserver : public test::EndToEndTest {
    public:
-    explicit FecNackObserver()
+    FecNackObserver()
         : EndToEndTest(kDefaultTimeoutMs),
           state_(kFirstPacket),
           fec_sequence_number_(0),
@@ -3047,7 +3047,7 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
       }
       bool sender_done = false;
       bool receiver_done = false;
-      while(!sender_done || !receiver_done) {
+      while (!sender_done || !receiver_done) {
         packet_event_->Wait(kSilenceTimeoutMs);
         int64_t time_now_ms = clock_->TimeInMilliseconds();
         rtc::CritScope lock(&test_crit_);
@@ -3135,7 +3135,7 @@ TEST_F(EndToEndTest, CallReportsRttForSender) {
 
 TEST_F(EndToEndTest, NewSendStreamsRespectNetworkDown) {
   class UnusedEncoder : public test::FakeEncoder {
-    public:
+   public:
      UnusedEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {}
      int32_t Encode(const VideoFrame& input_image,
                     const CodecSpecificInfo* codec_specific_info,

webrtc/video/rampup_tests.cc

@@ -322,9 +322,9 @@ Call::Config RampUpDownUpTester::GetReceiverCallConfig() {
 
 std::string RampUpDownUpTester::GetModifierString() const {
   std::string str("_");
-  char temp_str[5];
-  sprintf(temp_str, "%i", static_cast<int>(num_streams_));
-  str += std::string(temp_str);
+  std::ostringstream s;
+  s << num_streams_;
+  str += s.str();
   str += "stream";
   str += (num_streams_ > 1 ? "s" : "");
   str += "_";

webrtc/video/send_statistics_proxy.h

@@ -11,6 +11,7 @@
 #ifndef WEBRTC_VIDEO_SEND_STATISTICS_PROXY_H_
 #define WEBRTC_VIDEO_SEND_STATISTICS_PROXY_H_
 
+#include <map>
 #include <string>
 
 #include "webrtc/base/criticalsection.h"

webrtc/video/video_quality_test.cc

@@ -13,6 +13,7 @@
 #include <deque>
 #include <map>
 #include <sstream>
+#include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ -97,7 +98,6 @@ class VideoAnalyzer : public PacketReceiver,
       thread->Start();
       comparison_thread_pool_.push_back(thread);
     }
-
   }
 
   ~VideoAnalyzer() {
@@ -1017,14 +1017,16 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
       test::VideoRenderer::Create("Local Preview", params_.common.width,
                                   params_.common.height));
   size_t stream_id = params_.ss.selected_stream;
-  char title[32];
-  if (params_.ss.streams.size() == 1) {
-    sprintf(title, "Loopback Video");
-  } else {
-    sprintf(title, "Loopback Video - Stream #%" PRIuS, stream_id);
+  std::string title = "Loopback Video";
+  if (params_.ss.streams.size() > 1) {
+    std::ostringstream s;
+    s << stream_id;
+    title += " - Stream #" + s.str();
   }
+
   rtc::scoped_ptr<test::VideoRenderer> loopback_video(
-      test::VideoRenderer::Create(title, params_.ss.streams[stream_id].width,
+      test::VideoRenderer::Create(title.c_str(),
+                                  params_.ss.streams[stream_id].width,
                                   params_.ss.streams[stream_id].height));
 
   // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to

webrtc/video/video_quality_test.h

@@ -11,6 +11,7 @@
 #define WEBRTC_VIDEO_VIDEO_QUALITY_TEST_H_
 
 #include <string>
+#include <vector>
 
 #include "webrtc/test/call_test.h"
 #include "webrtc/test/frame_generator.h"

webrtc/video/video_receive_stream.cc

@@ -12,6 +12,7 @@
 
 #include <stdlib.h>
 
+#include <set>
 #include <string>
 
 #include "webrtc/base/checks.h"
@@ -111,7 +112,7 @@ VideoCodec CreateDecoderVideoCodec(const VideoReceiveStream::Decoder& decoder) {
   memset(&codec, 0, sizeof(codec));
 
   codec.plType = decoder.payload_type;
-  strcpy(codec.plName, decoder.payload_name.c_str());
+  strncpy(codec.plName, decoder.payload_name.c_str(), sizeof(codec.plName));
   if (decoder.payload_name == "VP8") {
     codec.codecType = kVideoCodecVP8;
   } else if (decoder.payload_name == "VP9") {
@@ -228,7 +229,7 @@ VideoReceiveStream::VideoReceiveStream(
     VideoCodec codec;
     memset(&codec, 0, sizeof(codec));
     codec.codecType = kVideoCodecULPFEC;
-    strcpy(codec.plName, "ulpfec");
+    strncpy(codec.plName, "ulpfec", sizeof(codec.plName));
     codec.plType = config_.rtp.fec.ulpfec_payload_type;
     RTC_CHECK_EQ(0, vie_channel_->SetReceiveCodec(codec));
   }
@@ -236,7 +237,7 @@ VideoReceiveStream::VideoReceiveStream(
     VideoCodec codec;
     memset(&codec, 0, sizeof(codec));
     codec.codecType = kVideoCodecRED;
-    strcpy(codec.plName, "red");
+    strncpy(codec.plName, "red", sizeof(codec.plName));
     codec.plType = config_.rtp.fec.red_payload_type;
     RTC_CHECK_EQ(0, vie_channel_->SetReceiveCodec(codec));
     if (config_.rtp.fec.red_rtx_payload_type != -1) {

webrtc/video/video_send_stream.cc

@@ -400,8 +400,8 @@ bool VideoSendStream::ReconfigureVideoEncoder(
     RTC_DCHECK_GE(streams[i].max_bitrate_bps, streams[i].target_bitrate_bps);
     RTC_DCHECK_GE(streams[i].max_qp, 0);
 
-    sim_stream->width = static_cast<unsigned short>(streams[i].width);
-    sim_stream->height = static_cast<unsigned short>(streams[i].height);
+    sim_stream->width = static_cast<uint16_t>(streams[i].width);
+    sim_stream->height = static_cast<uint16_t>(streams[i].height);
     sim_stream->minBitrate = streams[i].min_bitrate_bps / 1000;
     sim_stream->targetBitrate = streams[i].target_bitrate_bps / 1000;
     sim_stream->maxBitrate = streams[i].max_bitrate_bps / 1000;
@@ -410,12 +410,12 @@ bool VideoSendStream::ReconfigureVideoEncoder(
         streams[i].temporal_layer_thresholds_bps.size() + 1);
 
     video_codec.width = std::max(video_codec.width,
-                                 static_cast<unsigned short>(streams[i].width));
+                                 static_cast<uint16_t>(streams[i].width));
     video_codec.height = std::max(
-        video_codec.height, static_cast<unsigned short>(streams[i].height));
+        video_codec.height, static_cast<uint16_t>(streams[i].height));
     video_codec.minBitrate =
-        std::min(video_codec.minBitrate,
-                 static_cast<unsigned int>(streams[i].min_bitrate_bps / 1000));
+        std::min(static_cast<uint16_t>(video_codec.minBitrate),
+                 static_cast<uint16_t>(streams[i].min_bitrate_bps / 1000));
     video_codec.maxBitrate += streams[i].max_bitrate_bps / 1000;
     video_codec.qpMax = std::max(video_codec.qpMax,
                                  static_cast<unsigned int>(streams[i].max_qp));
@@ -500,7 +500,7 @@ std::map<uint32_t, RtpState> VideoSendStream::GetRtpStates() const {
   std::map<uint32_t, RtpState> rtp_states;
   for (size_t i = 0; i < config_.rtp.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.ssrcs[i];
-    rtp_states[ssrc] = vie_channel_->GetRtpStateForSsrc( ssrc);
+    rtp_states[ssrc] = vie_channel_->GetRtpStateForSsrc(ssrc);
   }
 
   for (size_t i = 0; i < config_.rtp.rtx.ssrcs.size(); ++i) {

webrtc/video/video_send_stream_tests.cc

@@ -1122,7 +1122,7 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
     }
 
     void WaitOutputFrame() {
-      const unsigned long kWaitFrameTimeoutMs = 3000;
+      const uint32_t kWaitFrameTimeoutMs = 3000;
       EXPECT_EQ(kEventSignaled, output_frame_event_->Wait(kWaitFrameTimeoutMs))
           << "Timeout while waiting for output frames.";
     }
@@ -1423,7 +1423,6 @@ static const size_t kVideoCodecConfigObserverNumberOfTemporalLayers = 4;
 template <typename T>
 class VideoCodecConfigObserver : public test::SendTest,
                                  public test::FakeEncoder {
-
  public:
   VideoCodecConfigObserver(VideoCodecType video_codec_type,
                            const char* codec_name)