Address some violations of chromium-style.

BUG=webrtc:163

Review-Url: https://codereview.webrtc.org/2913793002
Cr-Commit-Position: refs/heads/master@{#18345}

webrtc/call/rtp_transport_controller_send.cc

@@ -18,4 +18,21 @@ RtpTransportControllerSend::RtpTransportControllerSend(
     : send_side_cc_(clock, nullptr /* observer */, event_log, &packet_router_) {
 }
 
+PacketRouter* RtpTransportControllerSend::packet_router() {
+  return &packet_router_;
+}
+
+SendSideCongestionController* RtpTransportControllerSend::send_side_cc() {
+  return &send_side_cc_;
+}
+
+TransportFeedbackObserver*
+RtpTransportControllerSend::transport_feedback_observer() {
+  return &send_side_cc_;
+}
+
+RtpPacketSender* RtpTransportControllerSend::packet_sender() {
+  return send_side_cc_.pacer();
+}
+
 }  // namespace webrtc

webrtc/call/rtp_transport_controller_send.h

@@ -27,14 +27,10 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
   RtpTransportControllerSend(Clock* clock, webrtc::RtcEventLog* event_log);
 
   // Implements RtpTransportControllerSendInterface
-  PacketRouter* packet_router() override { return &packet_router_; }
-  SendSideCongestionController* send_side_cc() override {
-    return &send_side_cc_;
-  }
-  TransportFeedbackObserver* transport_feedback_observer() override {
-    return &send_side_cc_;
-  }
-  RtpPacketSender* packet_sender() override { return send_side_cc_.pacer(); }
+  PacketRouter* packet_router() override;
+  SendSideCongestionController* send_side_cc() override;
+  TransportFeedbackObserver* transport_feedback_observer() override;
+  RtpPacketSender* packet_sender() override;
 
  private:
   PacketRouter packet_router_;

webrtc/call/rtx_receive_stream.cc

@@ -23,6 +23,8 @@ RtxReceiveStream::RtxReceiveStream(
       rtx_payload_type_map_(std::move(rtx_payload_type_map)),
       media_ssrc_(media_ssrc) {}
 
+RtxReceiveStream::~RtxReceiveStream() = default;
+
 void RtxReceiveStream::OnRtpPacket(const RtpPacketReceived& rtx_packet) {
   rtc::ArrayView<const uint8_t> payload = rtx_packet.payload();
 

webrtc/call/rtx_receive_stream.h

@@ -22,7 +22,7 @@ class RtxReceiveStream : public RtpPacketSinkInterface {
   RtxReceiveStream(RtpPacketSinkInterface* media_sink,
                    std::map<int, int> rtx_payload_type_map,
                    uint32_t media_ssrc);
-
+  ~RtxReceiveStream() override;
   // RtpPacketSinkInterface.
   void OnRtpPacket(const RtpPacketReceived& packet) override;
 

webrtc/modules/congestion_controller/delay_based_bwe.cc

@@ -174,6 +174,8 @@ DelayBasedBwe::DelayBasedBwe(RtcEventLog* event_log, const Clock* clock)
   network_thread_.DetachFromThread();
 }
 
+DelayBasedBwe::~DelayBasedBwe() {}
+
 DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector(
     const std::vector<PacketFeedback>& packet_feedback_vector) {
   RTC_DCHECK(network_thread_.CalledOnValidThread());

webrtc/modules/congestion_controller/delay_based_bwe.h

@@ -45,7 +45,7 @@ class DelayBasedBwe {
   };
 
   DelayBasedBwe(RtcEventLog* event_log, const Clock* clock);
-  virtual ~DelayBasedBwe() {}
+  virtual ~DelayBasedBwe();
 
   Result IncomingPacketFeedbackVector(
       const std::vector<PacketFeedback>& packet_feedback_vector);

webrtc/modules/congestion_controller/include/send_side_congestion_controller.h

@@ -67,7 +67,7 @@ class SendSideCongestionController : public CallStatsObserver,
                                Observer* observer,
                                RtcEventLog* event_log,
                                std::unique_ptr<PacedSender> pacer);
-  virtual ~SendSideCongestionController();
+  ~SendSideCongestionController() override;
 
   void RegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
   void DeRegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
@@ -92,10 +92,9 @@ class SendSideCongestionController : public CallStatsObserver,
   virtual int64_t GetFirstPacketTimeMs() const;
   // TODO(nisse): Delete this accessor function. The pacer should be
   // internal to the congestion controller.
-  virtual PacedSender* pacer() { return pacer_.get(); }
-  virtual TransportFeedbackObserver* GetTransportFeedbackObserver() {
-    return this;
-  }
+  virtual PacedSender* pacer();
+  virtual TransportFeedbackObserver* GetTransportFeedbackObserver();
+
   RateLimiter* GetRetransmissionRateLimiter();
   void EnablePeriodicAlrProbing(bool enable);
 

webrtc/modules/congestion_controller/median_slope_estimator.cc

@@ -33,6 +33,15 @@ MedianSlopeEstimator::MedianSlopeEstimator(size_t window_size,
 
 MedianSlopeEstimator::~MedianSlopeEstimator() {}
 
+MedianSlopeEstimator::DelayInfo::DelayInfo(int64_t time,
+                                           double delay,
+                                           size_t slope_count)
+    : time(time), delay(delay) {
+  slopes.reserve(slope_count);
+}
+
+MedianSlopeEstimator::DelayInfo::~DelayInfo() = default;
+
 void MedianSlopeEstimator::Update(double recv_delta_ms,
                                   double send_delta_ms,
                                   int64_t arrival_time_ms) {

webrtc/modules/congestion_controller/median_slope_estimator.h

@@ -48,10 +48,8 @@ class MedianSlopeEstimator {
 
  private:
   struct DelayInfo {
-    DelayInfo(int64_t time, double delay, size_t slope_count)
-        : time(time), delay(delay) {
-      slopes.reserve(slope_count);
-    }
+    DelayInfo(int64_t time, double delay, size_t slope_count);
+    ~DelayInfo();
     int64_t time;
     double delay;
     std::vector<double> slopes;

webrtc/modules/congestion_controller/probe_bitrate_estimator.cc

@@ -43,6 +43,8 @@ namespace webrtc {
 ProbeBitrateEstimator::ProbeBitrateEstimator(RtcEventLog* event_log)
     : event_log_(event_log) {}
 
+ProbeBitrateEstimator::~ProbeBitrateEstimator() = default;
+
 int ProbeBitrateEstimator::HandleProbeAndEstimateBitrate(
     const PacketFeedback& packet_feedback) {
   int cluster_id = packet_feedback.pacing_info.probe_cluster_id;

webrtc/modules/congestion_controller/probe_bitrate_estimator.h

@@ -22,6 +22,7 @@ class RtcEventLog;
 class ProbeBitrateEstimator {
  public:
   explicit ProbeBitrateEstimator(RtcEventLog* event_log);
+  ~ProbeBitrateEstimator();
 
   // Should be called for every probe packet we receive feedback about.
   // Returns the estimated bitrate if the probe completes a valid cluster.

webrtc/modules/congestion_controller/send_side_congestion_controller.cc

@@ -181,6 +181,15 @@ int64_t SendSideCongestionController::GetFirstPacketTimeMs() const {
   return pacer_->FirstSentPacketTimeMs();
 }
 
+PacedSender* SendSideCongestionController::pacer() {
+  return pacer_.get();
+}
+
+TransportFeedbackObserver*
+SendSideCongestionController::GetTransportFeedbackObserver() {
+  return this;
+}
+
 void SendSideCongestionController::SignalNetworkState(NetworkState state) {
   LOG(LS_INFO) << "SignalNetworkState "
                << (state == kNetworkUp ? "Up" : "Down");

webrtc/modules/pacing/paced_sender.h

@@ -73,7 +73,7 @@ class PacedSender : public Module, public RtpPacketSender {
               PacketSender* packet_sender,
               RtcEventLog* event_log);
 
-  virtual ~PacedSender();
+  ~PacedSender() override;
 
   virtual void CreateProbeCluster(int bitrate_bps);
 

webrtc/modules/pacing/packet_router.h

@@ -40,7 +40,7 @@ class PacketRouter : public PacedSender::PacketSender,
                      public RemoteBitrateObserver {
  public:
   PacketRouter();
-  virtual ~PacketRouter();
+  ~PacketRouter() override;
 
   // TODO(nisse): Delete, as soon as downstream app is updated.
   RTC_DEPRECATED void AddRtpModule(RtpRtcp* rtp_module) {

webrtc/modules/remote_bitrate_estimator/bwe_defines.cc

@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace webrtc {
@@ -25,4 +26,15 @@ int GetMinBitrateBps() {
 }
 
 }  // namespace congestion_controller
+
+RateControlInput::RateControlInput(
+    BandwidthUsage bw_state,
+    const rtc::Optional<uint32_t>& incoming_bitrate,
+    double noise_var)
+    : bw_state(bw_state),
+      incoming_bitrate(incoming_bitrate),
+      noise_var(noise_var) {}
+
+RateControlInput::~RateControlInput() = default;
+
 }  // namespace webrtc

webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h

@@ -48,10 +48,8 @@ enum RateControlRegion { kRcNearMax, kRcAboveMax, kRcMaxUnknown };
 struct RateControlInput {
   RateControlInput(BandwidthUsage bw_state,
                    const rtc::Optional<uint32_t>& incoming_bitrate,
-                   double noise_var)
-      : bw_state(bw_state),
-        incoming_bitrate(incoming_bitrate),
-        noise_var(noise_var) {}
+                   double noise_var);
+  ~RateControlInput();
 
   BandwidthUsage bw_state;
   rtc::Optional<uint32_t> incoming_bitrate;

webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h

@@ -43,7 +43,7 @@ struct ReceiveBandwidthEstimatorStats {};
 
 class RemoteBitrateEstimator : public CallStatsObserver, public Module {
  public:
-  virtual ~RemoteBitrateEstimator() {}
+  ~RemoteBitrateEstimator() override {}
 
   // Called for each incoming packet. Updates the incoming payload bitrate
   // estimate and the over-use detector. If an over-use is detected the
@@ -64,9 +64,7 @@ class RemoteBitrateEstimator : public CallStatsObserver, public Module {
                               uint32_t* bitrate_bps) const = 0;
 
   // TODO(holmer): Remove when all implementations have been updated.
-  virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const {
-    return false;
-  }
+  virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const;
 
   virtual void SetMinBitrate(int min_bitrate_bps) = 0;
 
@@ -75,6 +73,11 @@ class RemoteBitrateEstimator : public CallStatsObserver, public Module {
   static const int64_t kStreamTimeOutMs = 2000;
 };
 
+inline bool RemoteBitrateEstimator::GetStats(
+    ReceiveBandwidthEstimatorStats* output) const {
+  return false;
+}
+
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_INCLUDE_REMOTE_BITRATE_ESTIMATOR_H_

webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h

@@ -384,32 +384,44 @@ class RtcpRttStats {
 // Null object version of RtpFeedback.
 class NullRtpFeedback : public RtpFeedback {
  public:
-  virtual ~NullRtpFeedback() {}
+  ~NullRtpFeedback() override {}
 
   int32_t OnInitializeDecoder(int8_t payload_type,
                               const char payloadName[RTP_PAYLOAD_NAME_SIZE],
                               int frequency,
                               size_t channels,
-                              uint32_t rate) override {
-    return 0;
-  }
+                              uint32_t rate) override;
 
   void OnIncomingSSRCChanged(uint32_t ssrc) override {}
   void OnIncomingCSRCChanged(uint32_t csrc, bool added) override {}
 };
 
+inline int32_t NullRtpFeedback::OnInitializeDecoder(
+    int8_t payload_type,
+    const char payloadName[RTP_PAYLOAD_NAME_SIZE],
+    int frequency,
+    size_t channels,
+    uint32_t rate) {
+  return 0;
+}
+
 // Null object version of RtpData.
 class NullRtpData : public RtpData {
  public:
-  virtual ~NullRtpData() {}
+  ~NullRtpData() override {}
 
   int32_t OnReceivedPayloadData(const uint8_t* payload_data,
                                 size_t payload_size,
-                                const WebRtcRTPHeader* rtp_header) override {
-    return 0;
-  }
+                                const WebRtcRTPHeader* rtp_header) override;
 };
 
+inline int32_t NullRtpData::OnReceivedPayloadData(
+    const uint8_t* payload_data,
+    size_t payload_size,
+    const WebRtcRTPHeader* rtp_header) {
+  return 0;
+}
+
 // Statistics about packet loss for a single directional connection. All values
 // are totals since the connection initiated.
 struct RtpPacketLossStats {

webrtc/modules/rtp_rtcp/source/rtp_packet.cc

@@ -62,6 +62,8 @@ Packet::Packet() : Packet(nullptr, kDefaultPacketSize) {}
 Packet::Packet(const ExtensionManager* extensions)
     : Packet(extensions, kDefaultPacketSize) {}
 
+Packet::Packet(const Packet&) = default;
+
 Packet::Packet(const ExtensionManager* extensions, size_t capacity)
     : buffer_(capacity) {
   RTC_DCHECK_GE(capacity, kFixedHeaderSize);

webrtc/modules/rtp_rtcp/source/rtp_packet.h

@@ -125,7 +125,7 @@ class Packet {
   // provided via constructor or IdentifyExtensions function.
   Packet();
   explicit Packet(const ExtensionManager* extensions);
-  Packet(const Packet&) = default;
+  Packet(const Packet&);
   Packet(const ExtensionManager* extensions, size_t capacity);
   virtual ~Packet();