[rtp_rtcp] rtc::scoped_ptr<rtcp::RawPacket> replaced with rtc::Buffer

webrtc/call/rtc_event_log_unittest.cc

 /*
  *  Copyright (c) 2015 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 332 matching lines @@
       packet, payload_type, marker_bit, capture_timestamp, capture_time_ms,
       timestamp_provided, inc_sequence_number);
 
   for (size_t i = header_size; i < packet_size; i++) {
     packet[i] = prng->Rand<uint8_t>();
   }
 
   return header_size;
 }
 
-rtc::scoped_ptr<rtcp::RawPacket> GenerateRtcpPacket(Random* prng) {
+rtc::Buffer GenerateRtcpPacket(Random* prng) {
   rtcp::ReportBlock report_block;
   report_block.To(prng->Rand<uint32_t>());  // Remote SSRC.
   report_block.WithFractionLost(prng->Rand(50));
 
   rtcp::SenderReport sender_report;
   sender_report.From(prng->Rand<uint32_t>());  // Sender SSRC.
   sender_report.WithNtp(
       NtpTime(prng->Rand<uint32_t>(), prng->Rand<uint32_t>()));
   sender_report.WithPacketCount(prng->Rand<uint32_t>());
   sender_report.WithReportBlock(report_block);
@@ skipping 56 matching lines @@
                            size_t rtcp_count,
                            size_t playout_count,
                            size_t bwe_loss_count,
                            uint32_t extensions_bitvector,
                            uint32_t csrcs_count,
                            unsigned int random_seed) {
   ASSERT_LE(rtcp_count, rtp_count);
   ASSERT_LE(playout_count, rtp_count);
   ASSERT_LE(bwe_loss_count, rtp_count);
   std::vector<rtc::Buffer> rtp_packets;
-  std::vector<rtc::scoped_ptr<rtcp::RawPacket> > rtcp_packets;
+  std::vector<rtc::Buffer> rtcp_packets;
   std::vector<size_t> rtp_header_sizes;
   std::vector<uint32_t> playout_ssrcs;
   std::vector<std::pair<int32_t, uint8_t> > bwe_loss_updates;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
 
   Random prng(random_seed);
 
   // Create rtp_count RTP packets containing random data.
@@ skipping 40 matching lines @@
     size_t bwe_loss_index = 1;
     for (size_t i = 1; i <= rtp_count; i++) {
       log_dumper->LogRtpHeader(
           (i % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
           (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
           rtp_packets[i - 1].data(), rtp_packets[i - 1].size());
       if (i * rtcp_count >= rtcp_index * rtp_count) {
         log_dumper->LogRtcpPacket(
             (rtcp_index % 2 == 0) ? kIncomingPacket : kOutgoingPacket,
             rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
-            rtcp_packets[rtcp_index - 1]->Buffer(),
-            rtcp_packets[rtcp_index - 1]->Length());
+            rtcp_packets[rtcp_index - 1].data(),
+            rtcp_packets[rtcp_index - 1].size());
         rtcp_index++;
       }
       if (i * playout_count >= playout_index * rtp_count) {
         log_dumper->LogAudioPlayout(playout_ssrcs[playout_index - 1]);
         playout_index++;
       }
       if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
         log_dumper->LogBwePacketLossEvent(
             bwe_loss_updates[bwe_loss_index - 1].first,
             bwe_loss_updates[bwe_loss_index - 1].second, i);
@@ skipping 26 matching lines @@
     VerifyRtpEvent(parsed_stream.stream(event_index),
                    (i % 2 == 0),  // Every second packet is incoming.
                    (i % 3 == 0) ? MediaType::AUDIO : MediaType::VIDEO,
                    rtp_packets[i - 1].data(), rtp_header_sizes[i - 1],
                    rtp_packets[i - 1].size());
     event_index++;
     if (i * rtcp_count >= rtcp_index * rtp_count) {
       VerifyRtcpEvent(parsed_stream.stream(event_index),
                       rtcp_index % 2 == 0,  // Every second packet is incoming.
                       rtcp_index % 3 == 0 ? MediaType::AUDIO : MediaType::VIDEO,
-                      rtcp_packets[rtcp_index - 1]->Buffer(),
-                      rtcp_packets[rtcp_index - 1]->Length());
+                      rtcp_packets[rtcp_index - 1].data(),
+                      rtcp_packets[rtcp_index - 1].size());
       event_index++;
       rtcp_index++;
     }
     if (i * playout_count >= playout_index * rtp_count) {
       VerifyPlayoutEvent(parsed_stream.stream(event_index),
                          playout_ssrcs[playout_index - 1]);
       event_index++;
       playout_index++;
     }
     if (i * bwe_loss_count >= bwe_loss_index * rtp_count) {
@@ skipping 46 matching lines @@
   }
 }
 
 // Tests that the event queue works correctly, i.e. drops old RTP, RTCP and
 // debug events, but keeps config events even if they are older than the limit.
 void DropOldEvents(uint32_t extensions_bitvector,
                    uint32_t csrcs_count,
                    unsigned int random_seed) {
   rtc::Buffer old_rtp_packet;
   rtc::Buffer recent_rtp_packet;
-  rtc::scoped_ptr<rtcp::RawPacket> old_rtcp_packet;
-  rtc::scoped_ptr<rtcp::RawPacket> recent_rtcp_packet;
+  rtc::Buffer old_rtcp_packet;
+  rtc::Buffer recent_rtcp_packet;
 
   VideoReceiveStream::Config receiver_config(nullptr);
   VideoSendStream::Config sender_config(nullptr);
 
   Random prng(random_seed);
 
   // Create two RTP packets containing random data.
   size_t packet_size = prng.Rand(1000, 1100);
   old_rtp_packet.SetSize(packet_size);
   GenerateRtpPacket(extensions_bitvector, csrcs_count, old_rtp_packet.data(),
@@ skipping 21 matching lines @@
   // The log file will be flushed to disk when the log_dumper goes out of scope.
   {
     rtc::scoped_ptr<RtcEventLog> log_dumper(RtcEventLog::Create());
     // Reduce the time old events are stored to 50 ms.
     log_dumper->SetBufferDuration(50000);
     log_dumper->LogVideoReceiveStreamConfig(receiver_config);
     log_dumper->LogVideoSendStreamConfig(sender_config);
     log_dumper->LogRtpHeader(kOutgoingPacket, MediaType::AUDIO,
                              old_rtp_packet.data(), old_rtp_packet.size());
     log_dumper->LogRtcpPacket(kIncomingPacket, MediaType::AUDIO,
-                              old_rtcp_packet->Buffer(),
-                              old_rtcp_packet->Length());
+                              old_rtcp_packet.data(),
+                              old_rtcp_packet.size());
     // Sleep 55 ms to let old events be removed from the queue.
     rtc::Thread::SleepMs(55);
     log_dumper->StartLogging(temp_filename, 10000000);
     log_dumper->LogRtpHeader(kIncomingPacket, MediaType::VIDEO,
                              recent_rtp_packet.data(),
                              recent_rtp_packet.size());
     log_dumper->LogRtcpPacket(kOutgoingPacket, MediaType::VIDEO,
-                              recent_rtcp_packet->Buffer(),
-                              recent_rtcp_packet->Length());
+                              recent_rtcp_packet.data(),
+                              recent_rtcp_packet.size());
   }
 
   // Read the generated file from disk.
   rtclog::EventStream parsed_stream;
   ASSERT_TRUE(RtcEventLog::ParseRtcEventLog(temp_filename, &parsed_stream));
 
   // Verify that what we read back from the event log is the same as
   // what we wrote. Old RTP and RTCP events should have been discarded,
   // but old configuration events should still be available.
   EXPECT_EQ(5, parsed_stream.stream_size());
   VerifyReceiveStreamConfig(parsed_stream.stream(0), receiver_config);
   VerifySendStreamConfig(parsed_stream.stream(1), sender_config);
   VerifyLogStartEvent(parsed_stream.stream(2));
   VerifyRtpEvent(parsed_stream.stream(3), true, MediaType::VIDEO,
                  recent_rtp_packet.data(), recent_header_size,
                  recent_rtp_packet.size());
   VerifyRtcpEvent(parsed_stream.stream(4), false, MediaType::VIDEO,
-                  recent_rtcp_packet->Buffer(), recent_rtcp_packet->Length());
+                  recent_rtcp_packet.data(), recent_rtcp_packet.size());
 
   // Clean up temporary file - can be pretty slow.
   remove(temp_filename.c_str());
 }
 
 TEST(RtcEventLogTest, DropOldEvents) {
   // Enable all header extensions
   uint32_t extensions = (1u << kNumExtensions) - 1;
   uint32_t csrcs_count = 2;
   DropOldEvents(extensions, csrcs_count, 141421356);
   DropOldEvents(extensions, csrcs_count, 173205080);
 }
 
 }  // namespace webrtc
 
 #endif  // ENABLE_RTC_EVENT_LOG