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

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_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 55 matching lines @@
       }
       last_time = time;
     }
     expected_seq_.insert(expected_seq_.begin(), &received_seq[0],
                          &received_seq[length]);
   }
 
   void VerifyPacket() {
     serialized_ = feedback_->Build();
     VerifyInternal();
-    feedback_ = TransportFeedback::ParseFrom(serialized_->Buffer(),
-                                             serialized_->Length());
+    feedback_ = TransportFeedback::ParseFrom(serialized_.data(),
+                                             serialized_.size());
     ASSERT_NE(nullptr, feedback_.get());
     VerifyInternal();
   }
 
   static const size_t kAnySize = static_cast<size_t>(0) - 1;
 
  private:
   void VerifyInternal() {
     if (expected_size_ != kAnySize) {
       // Round up to whole 32-bit words.
       size_t expected_size_words = (expected_size_ + 3) / 4;
       size_t expected_size_bytes = expected_size_words * 4;
-      EXPECT_EQ(expected_size_bytes, serialized_->Length());
+      EXPECT_EQ(expected_size_bytes, serialized_.size());
     }
 
     std::vector<TransportFeedback::StatusSymbol> symbols =
         feedback_->GetStatusVector();
     uint16_t seq = feedback_->GetBaseSequence();
     auto seq_it = expected_seq_.begin();
     for (TransportFeedback::StatusSymbol symbol : symbols) {
       bool received =
           (symbol == TransportFeedback::StatusSymbol::kReceivedSmallDelta ||
            symbol == TransportFeedback::StatusSymbol::kReceivedLargeDelta);
@@ skipping 29 matching lines @@
 
       deltas[i] = offset + (last_seq * default_delta_);
     }
   }
 
   std::vector<uint16_t> expected_seq_;
   std::vector<int64_t> expected_deltas_;
   size_t expected_size_;
   int64_t default_delta_;
   rtc::scoped_ptr<TransportFeedback> feedback_;
-  rtc::scoped_ptr<rtcp::RawPacket> serialized_;
+  rtc::Buffer serialized_;
 };
 
 TEST(RtcpPacketTest, TransportFeedback_OneBitVector) {
   const uint16_t kReceived[] = {1, 2, 7, 8, 9, 10, 13};
   const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
   const size_t kExpectedSizeBytes =
       kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);
 
   FeedbackTester test;
   test.WithExpectedSize(kExpectedSizeBytes);
@@ skipping 239 matching lines @@
   EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxNegativeTimeDelta));
 
   // Base time at maximum value.
   int64_t kMaxBaseTime =
       static_cast<int64_t>(TransportFeedback::kDeltaScaleFactor) * (1L << 8) *
       ((1L << 23) - 1);
   packet.reset(new TransportFeedback());
   packet->WithBase(0, kMaxBaseTime);
   packet->WithReceivedPacket(0, kMaxBaseTime);
   // Serialize and de-serialize (verify 24bit parsing).
-  rtc::scoped_ptr<rtcp::RawPacket> raw_packet = packet->Build();
-  packet =
-      TransportFeedback::ParseFrom(raw_packet->Buffer(), raw_packet->Length());
+  rtc::Buffer raw_packet = packet->Build();
+  packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
   EXPECT_EQ(kMaxBaseTime, packet->GetBaseTimeUs());
 
   // Base time above maximum value.
   int64_t kTooLargeBaseTime =
       kMaxBaseTime + (TransportFeedback::kDeltaScaleFactor * (1L << 8));
   packet.reset(new TransportFeedback());
   packet->WithBase(0, kTooLargeBaseTime);
   packet->WithReceivedPacket(0, kTooLargeBaseTime);
   raw_packet = packet->Build();
-  packet =
-      TransportFeedback::ParseFrom(raw_packet->Buffer(), raw_packet->Length());
+  packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
   EXPECT_NE(kTooLargeBaseTime, packet->GetBaseTimeUs());
 
   // TODO(sprang): Once we support max length lower than RTCP length limit,
   // add back test for max size in bytes.
 }
 
 TEST(RtcpPacketTest, TransportFeedback_Padding) {
   const size_t kExpectedSizeBytes =
       kHeaderSize + kStatusChunkSize + kSmallDeltaSize;
   const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4;
 
   TransportFeedback feedback;
   feedback.WithBase(0, 0);
   EXPECT_TRUE(feedback.WithReceivedPacket(0, 0));
 
-  rtc::scoped_ptr<rtcp::RawPacket> packet(feedback.Build());
-  EXPECT_EQ(kExpectedSizeWords * 4, packet->Length());
+  rtc::Buffer packet = feedback.Build();
+  EXPECT_EQ(kExpectedSizeWords * 4, packet.size());
   ASSERT_GT(kExpectedSizeWords * 4, kExpectedSizeBytes);
   for (size_t i = kExpectedSizeBytes; i < kExpectedSizeWords * 4; ++i)
-    EXPECT_EQ(0u, packet->Buffer()[i]);
+    EXPECT_EQ(0u, packet.data()[i]);
 
   // Modify packet by adding 4 bytes of padding at the end. Not currently used
   // when we're sending, but need to be able to handle it when receiving.
 
   const int kPaddingBytes = 4;
   const size_t kExpectedSizeWithPadding =
       (kExpectedSizeWords * 4) + kPaddingBytes;
   uint8_t mod_buffer[kExpectedSizeWithPadding];
-  memcpy(mod_buffer, packet->Buffer(), kExpectedSizeWords * 4);
+  memcpy(mod_buffer, packet.data(), kExpectedSizeWords * 4);
   memset(&mod_buffer[kExpectedSizeWords * 4], 0, kPaddingBytes - 1);
   mod_buffer[kExpectedSizeWithPadding - 1] = kPaddingBytes;
   const uint8_t padding_flag = 1 << 5;
   mod_buffer[0] |= padding_flag;
   ByteWriter<uint16_t>::WriteBigEndian(
       &mod_buffer[2], ByteReader<uint16_t>::ReadBigEndian(&mod_buffer[2]) +
                           ((kPaddingBytes + 3) / 4));
 
   rtc::scoped_ptr<TransportFeedback> parsed_packet(
       TransportFeedback::ParseFrom(mod_buffer, kExpectedSizeWithPadding));
   ASSERT_TRUE(parsed_packet.get() != nullptr);
-  EXPECT_EQ(kExpectedSizeWords * 4, packet->Length());  // Padding not included.
+  EXPECT_EQ(kExpectedSizeWords * 4, packet.size());  // Padding not included.
 }
 
 TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) {
   const int kOneBitVectorCapacity = 14;
   const int64_t kLargeTimeDelta =
       TransportFeedback::kDeltaScaleFactor * (1 << 8);
 
   // Test that a number of small deltas followed by a large delta results in a
   // correct split into multiple chunks, as needed.
 
   for (int deltas = 0; deltas <= kOneBitVectorCapacity + 1; ++deltas) {
     TransportFeedback feedback;
     feedback.WithBase(0, 0);
     for (int i = 0; i < deltas; ++i)
       feedback.WithReceivedPacket(i, i * 1000);
     feedback.WithReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta);
 
-    rtc::scoped_ptr<rtcp::RawPacket> serialized_packet = feedback.Build();
-    EXPECT_TRUE(serialized_packet.get() != nullptr);
+    rtc::Buffer serialized_packet = feedback.Build();
     rtc::scoped_ptr<TransportFeedback> deserialized_packet =
-        TransportFeedback::ParseFrom(serialized_packet->Buffer(),
-                                     serialized_packet->Length());
+        TransportFeedback::ParseFrom(serialized_packet.data(),
+                                     serialized_packet.size());
     EXPECT_TRUE(deserialized_packet.get() != nullptr);
   }
 }
 
 }  // namespace
 }  // namespace webrtc