Lint enabled for webrtc/modules/video_coding folder.

webrtc/modules/video_coding/video_coding_impl.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.
  */
 
+#include <algorithm>
+
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/encoded_frame.h"
 #include "webrtc/modules/video_coding/jitter_buffer.h"
 #include "webrtc/modules/video_coding/packet.h"
 #include "webrtc/modules/video_coding/video_coding_impl.h"

[mflodman, 2015/12/17 13:05:39]

Should be on top.

[mflodman, 2015/12/18 12:44:26]

You missed this comment.

 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 namespace vcm {
 
-int64_t
-VCMProcessTimer::Period() const {
-    return _periodMs;
+int64_t VCMProcessTimer::Period() const {
+  return _periodMs;
 }
 
-int64_t
-VCMProcessTimer::TimeUntilProcess() const {
-    const int64_t time_since_process = _clock->TimeInMilliseconds() - _latestMs;
-    const int64_t time_until_process = _periodMs - time_since_process;
-    return std::max<int64_t>(time_until_process, 0);
+int64_t VCMProcessTimer::TimeUntilProcess() const {
+  const int64_t time_since_process = _clock->TimeInMilliseconds() - _latestMs;
+  const int64_t time_until_process = _periodMs - time_since_process;
+  return std::max<int64_t>(time_until_process, 0);
 }
 
-void
-VCMProcessTimer::Processed() {
-    _latestMs = _clock->TimeInMilliseconds();
+void VCMProcessTimer::Processed() {
+  _latestMs = _clock->TimeInMilliseconds();
 }
 }  // namespace vcm
 
 namespace {
 // This wrapper provides a way to modify the callback without the need to expose
 // a register method all the way down to the function calling it.
 class EncodedImageCallbackWrapper : public EncodedImageCallback {
  public:
   EncodedImageCallbackWrapper()
       : cs_(CriticalSectionWrapper::CreateCriticalSection()), callback_(NULL) {}
 
   virtual ~EncodedImageCallbackWrapper() {}
 
   void Register(EncodedImageCallback* callback) {
     CriticalSectionScoped cs(cs_.get());
     callback_ = callback;
   }
 
   // TODO(andresp): Change to void as return value is ignored.
   virtual int32_t Encoded(const EncodedImage& encoded_image,
                           const CodecSpecificInfo* codec_specific_info,
                           const RTPFragmentationHeader* fragmentation) {
     CriticalSectionScoped cs(cs_.get());
     if (callback_)
-      return callback_->Encoded(
-          encoded_image, codec_specific_info, fragmentation);
+      return callback_->Encoded(encoded_image, codec_specific_info,
+                                fragmentation);
     return 0;
   }
 
  private:
   rtc::scoped_ptr<CriticalSectionWrapper> cs_;
   EncodedImageCallback* callback_ GUARDED_BY(cs_);
 };
 
 class VideoCodingModuleImpl : public VideoCodingModule {
  public:
   VideoCodingModuleImpl(Clock* clock,
                         EventFactory* event_factory,
                         bool owns_event_factory,
                         VideoEncoderRateObserver* encoder_rate_observer,
                         VCMQMSettingsCallback* qm_settings_callback)
       : VideoCodingModule(),
         sender_(clock,
                 &post_encode_callback_,
                 encoder_rate_observer,
                 qm_settings_callback),
         receiver_(clock, event_factory),
         own_event_factory_(owns_event_factory ? event_factory : NULL) {}
 
-  virtual ~VideoCodingModuleImpl() {
-    own_event_factory_.reset();
-  }
+  virtual ~VideoCodingModuleImpl() { own_event_factory_.reset(); }
 
   int64_t TimeUntilNextProcess() override {
     int64_t sender_time = sender_.TimeUntilNextProcess();
     int64_t receiver_time = receiver_.TimeUntilNextProcess();
     assert(sender_time >= 0);
     assert(receiver_time >= 0);
     return VCM_MIN(sender_time, receiver_time);
   }
 
   int32_t Process() override {
@@ skipping 214 matching lines @@
 }
 
 VideoCodingModule* VideoCodingModule::Create(
     Clock* clock,
     VideoEncoderRateObserver* encoder_rate_observer,
     VCMQMSettingsCallback* qm_settings_callback) {
   return new VideoCodingModuleImpl(clock, new EventFactoryImpl, true,
                                    encoder_rate_observer, qm_settings_callback);
 }
 
-VideoCodingModule* VideoCodingModule::Create(
-    Clock* clock,
-    EventFactory* event_factory) {
+VideoCodingModule* VideoCodingModule::Create(Clock* clock,
+                                             EventFactory* event_factory) {
   assert(clock);
   assert(event_factory);
   return new VideoCodingModuleImpl(clock, event_factory, false, nullptr,
                                    nullptr);
 }
 
 void VideoCodingModule::Destroy(VideoCodingModule* module) {
   if (module != NULL) {
     delete static_cast<VideoCodingModuleImpl*>(module);
   }
 }
 }  // namespace webrtc