[rtp_rtcp] lint whitespace warning removed from most source/ files

webrtc/modules/rtp_rtcp/source/nack_rtx_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 17 matching lines @@
 
 const int kVideoNackListSize = 30;
 const uint32_t kTestSsrc = 3456;
 const uint16_t kTestSequenceNumber = 2345;
 const uint32_t kTestNumberOfPackets = 1350;
 const int kTestNumberOfRtxPackets = 149;
 const int kNumFrames = 30;
 const int kPayloadType = 123;
 const int kRtxPayloadType = 98;
 
-class VerifyingRtxReceiver : public NullRtpData
-{
+class VerifyingRtxReceiver : public NullRtpData {
  public:
   VerifyingRtxReceiver() {}
 
   int32_t OnReceivedPayloadData(
       const uint8_t* data,
       const size_t size,
       const webrtc::WebRtcRTPHeader* rtp_header) override {
     if (!sequence_numbers_.empty())
       EXPECT_EQ(kTestSsrc, rtp_header->header.ssrc);
     sequence_numbers_.push_back(rtp_header->header.sequenceNumber);
@@ skipping 29 matching lines @@
         module_(NULL) {}
 
   void SetSendModule(RtpRtcp* rtpRtcpModule,
                      RTPPayloadRegistry* rtp_payload_registry,
                      RtpReceiver* receiver) {
     module_ = rtpRtcpModule;
     rtp_payload_registry_ = rtp_payload_registry;
     rtp_receiver_ = receiver;
   }
 
-  void DropEveryNthPacket(int n) {
-    packet_loss_ = n;
-  }
+  void DropEveryNthPacket(int n) { packet_loss_ = n; }
 
   void DropConsecutivePackets(int start, int total) {
     consecutive_drop_start_ = start;
     consecutive_drop_end_ = start + total;
     packet_loss_ = 0;
   }
 
   bool SendRtp(const uint8_t* data,
                size_t len,
                const PacketOptions& options) override {
     count_++;
-    const unsigned char* ptr = static_cast<const unsigned  char*>(data);
+    const unsigned char* ptr = static_cast<const unsigned char*>(data);
     uint32_t ssrc = (ptr[8] << 24) + (ptr[9] << 16) + (ptr[10] << 8) + ptr[11];
-    if (ssrc == rtx_ssrc_) count_rtx_ssrc_++;
+    if (ssrc == rtx_ssrc_)
+      count_rtx_ssrc_++;
     uint16_t sequence_number = (ptr[2] << 8) + ptr[3];
     size_t packet_length = len;
     uint8_t restored_packet[1500];
     RTPHeader header;
     rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
     if (!parser->Parse(ptr, len, &header)) {
       return false;
     }
 
     if (!rtp_payload_registry_->IsRtx(header)) {
@@ skipping 66 matching lines @@
     configuration.audio = false;
     configuration.clock = &fake_clock;
     receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock));
     configuration.receive_statistics = receive_statistics_.get();
     configuration.outgoing_transport = &transport_;
     rtp_rtcp_module_ = RtpRtcp::CreateRtpRtcp(configuration);
 
     rtp_feedback_.reset(new TestRtpFeedback(rtp_rtcp_module_));
 
     rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
-        &fake_clock, &receiver_, rtp_feedback_.get(),
-        &rtp_payload_registry_));
+        &fake_clock, &receiver_, rtp_feedback_.get(), &rtp_payload_registry_));
 
     rtp_rtcp_module_->SetSSRC(kTestSsrc);
     rtp_rtcp_module_->SetRTCPStatus(RtcpMode::kCompound);
     rtp_receiver_->SetNACKStatus(kNackRtcp);
     rtp_rtcp_module_->SetStorePacketsStatus(true, 600);
     EXPECT_EQ(0, rtp_rtcp_module_->SetSendingStatus(true));
     rtp_rtcp_module_->SetSequenceNumber(kTestSequenceNumber);
     rtp_rtcp_module_->SetStartTimestamp(111111);
 
     transport_.SetSendModule(rtp_rtcp_module_, &rtp_payload_registry_,
                              rtp_receiver_.get());
 
     VideoCodec video_codec;
     memset(&video_codec, 0, sizeof(video_codec));
     video_codec.plType = kPayloadType;
     memcpy(video_codec.plName, "I420", 5);
 
     EXPECT_EQ(0, rtp_rtcp_module_->RegisterSendPayload(video_codec));
     rtp_rtcp_module_->SetRtxSendPayloadType(kRtxPayloadType, kPayloadType);
-    EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(video_codec.plName,
-                                                       video_codec.plType,
-                                                       90000,
-                                                       0,
-                                                       video_codec.maxBitrate));
+    EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(
+                     video_codec.plName, video_codec.plType, 90000, 0,
+                     video_codec.maxBitrate));
     rtp_payload_registry_.SetRtxPayloadType(kRtxPayloadType, kPayloadType);
 
     for (size_t n = 0; n < payload_data_length; n++) {
       payload_data[n] = n % 10;
     }
   }
 
   int BuildNackList(uint16_t* nack_list) {
     receiver_.sequence_numbers_.sort();
     std::list<uint16_t> missing_sequence_numbers;
-    std::list<uint16_t>::iterator it =
-        receiver_.sequence_numbers_.begin();
+    std::list<uint16_t>::iterator it = receiver_.sequence_numbers_.begin();
 
     while (it != receiver_.sequence_numbers_.end()) {
       uint16_t sequence_number_1 = *it;
       ++it;
       if (it != receiver_.sequence_numbers_.end()) {
         uint16_t sequence_number_2 = *it;
         // Add all missing sequence numbers to list
-        for (uint16_t i = sequence_number_1 + 1; i < sequence_number_2;
-            ++i) {
+        for (uint16_t i = sequence_number_1 + 1; i < sequence_number_2; ++i) {
           missing_sequence_numbers.push_back(i);
         }
       }
     }
     int n = 0;
     for (it = missing_sequence_numbers.begin();
-        it != missing_sequence_numbers.end(); ++it) {
+         it != missing_sequence_numbers.end(); ++it) {
       nack_list[n++] = (*it);
     }
     return n;
   }
 
   bool ExpectedPacketsReceived() {
     std::list<uint16_t> received_sorted;
     std::copy(receiver_.sequence_numbers_.begin(),
               receiver_.sequence_numbers_.end(),
               std::back_inserter(received_sorted));
@@ skipping 30 matching lines @@
 
   void TearDown() override { delete rtp_rtcp_module_; }
 
   rtc::scoped_ptr<ReceiveStatistics> receive_statistics_;
   RTPPayloadRegistry rtp_payload_registry_;
   rtc::scoped_ptr<RtpReceiver> rtp_receiver_;
   RtpRtcp* rtp_rtcp_module_;
   rtc::scoped_ptr<TestRtpFeedback> rtp_feedback_;
   RtxLoopBackTransport transport_;
   VerifyingRtxReceiver receiver_;
-  uint8_t  payload_data[65000];
+  uint8_t payload_data[65000];
   size_t payload_data_length;
   SimulatedClock fake_clock;
 };
 
 TEST_F(RtpRtcpRtxNackTest, LongNackList) {
   const int kNumPacketsToDrop = 900;
   const int kNumRequiredRtcp = 4;
   uint32_t timestamp = 3000;
   uint16_t nack_list[kNumPacketsToDrop];
   // Disable StorePackets to be able to set a larger packet history.
@@ skipping 26 matching lines @@
   }
   rtp_rtcp_module_->SendNACK(nack_list, length);
   EXPECT_GT(receiver_.sequence_numbers_.size(), last_receive_count);
   EXPECT_TRUE(ExpectedPacketsReceived());
 }
 
 TEST_F(RtpRtcpRtxNackTest, RtxNack) {
   RunRtxTest(kRtxRetransmitted, 10);
   EXPECT_EQ(kTestSequenceNumber, *(receiver_.sequence_numbers_.begin()));
   EXPECT_EQ(kTestSequenceNumber + kTestNumberOfPackets - 1,
-      *(receiver_.sequence_numbers_.rbegin()));
+            *(receiver_.sequence_numbers_.rbegin()));
   EXPECT_EQ(kTestNumberOfPackets, receiver_.sequence_numbers_.size());
   EXPECT_EQ(kTestNumberOfRtxPackets, transport_.count_rtx_ssrc_);
   EXPECT_TRUE(ExpectedPacketsReceived());
 }