[rtp_rtcp] RtcpPacket::Buffer() returns rtc::Buffer instead of scoped_ptr<RawPacket>

webrtc/modules/rtp_rtcp/source/rtcp_packet.h

 /*
  *  Copyright (c) 2014 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.
  *
  */
 
 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_H_
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_H_
 
 #include <vector>
 
+#include "webrtc/base/buffer.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 namespace rtcp {
+// TODO(danilchap): Remove RawPacket when all tests will be updated
+// to use rtc::Buffer directly
+class RawPacket : rtc::Buffer {
+ public:
+  RawPacket() {}
+  RawPacket(rtc::Buffer&& buffer) : rtc::Buffer(buffer) {}  // NOLINT
+  const uint8_t* Buffer() const { return data(); }
+  uint8_t* MutableBuffer() { return data(); }
+  size_t Length() const { return size(); }
+};
+}  // namespace rtcp
+}  // namespace webrtc
 
-static const int kCommonFbFmtLength = 12;
+// TODO(danilchap): Remove this horrible template specialization when all tests
+// will be updated to use rtc::Buffer directly.
+// Template is specialized to make current code compile and work like before,
+// it is not designed to match what proper scoped_ptr do.
+template<>
+class ::rtc::scoped_ptr<webrtc::rtcp::RawPacket> : webrtc::rtcp::RawPacket {
+ public:
+  scoped_ptr() {}
+  scoped_ptr(rtc::Buffer&& buffer) : RawPacket(std::move(buffer)) {}  // NOLINT
+  webrtc::rtcp::RawPacket* get() { return this; }
+  webrtc::rtcp::RawPacket& operator*() { return *this; }
+  webrtc::rtcp::RawPacket* operator->() { return this; }
+};
 
-class RawPacket;
-
+namespace webrtc {
+namespace rtcp {
 // Class for building RTCP packets.
 //
 //  Example:
 //  ReportBlock report_block;
 //  report_block.To(234)
 //  report_block.FractionLost(10);
 //
 //  ReceiverReport rr;
 //  rr.From(123);
 //  rr.WithReportBlock(&report_block)
 //
 //  Fir fir;
 //  fir.From(123);
 //  fir.WithRequestTo(234, 56);
 //
 //  size_t length = 0;                     // Builds an intra frame request
 //  uint8_t packet[kPacketSize];           // with sequence number 56.
 //  fir.Build(packet, &length, kPacketSize);
 //
-//  RawPacket packet = fir.Build();        // Returns a RawPacket holding
+//  rtc::Buffer packet = fir.Build();      // Returns a RawPacket holding
 //                                         // the built rtcp packet.
 //
 //  rr.Append(&fir)                        // Builds a compound RTCP packet with
-//  RawPacket packet = rr.Build();         // a receiver report, report block
+//  rtc::Buffer packet = rr.Build();       // a receiver report, report block
 //                                         // and fir message.
 
 class RtcpPacket {
  public:
   virtual ~RtcpPacket() {}
 
   void Append(RtcpPacket* packet);
 
   // Callback used to signal that an RTCP packet is ready. Note that this may
   // not contain all data in this RtcpPacket; if a packet cannot fit in
   // max_length bytes, it will be fragmented and multiple calls to this
   // callback will be made.
   class PacketReadyCallback {
    public:
     PacketReadyCallback() {}
     virtual ~PacketReadyCallback() {}
 
     virtual void OnPacketReady(uint8_t* data, size_t length) = 0;
   };
 
   // Convenience method mostly used for test. Max length of IP_PACKET_SIZE is
   // used, will cause assertion error if fragmentation occurs.
-  rtc::scoped_ptr<RawPacket> Build() const;
+  rtc::Buffer Build() const;
 
   // Returns true if all calls to Create succeeded. A buffer of size
   // IP_PACKET_SIZE will be allocated and reused between calls to callback.
   bool Build(PacketReadyCallback* callback) const;
 
   // Returns true if all calls to Create succeeded. Provided buffer reference
   // will be used for all calls to callback.
   bool BuildExternalBuffer(uint8_t* buffer,
                            size_t max_length,
                            PacketReadyCallback* callback) const;
@@ skipping 23 matching lines @@
 
   static const size_t kHeaderLength = 4;
   std::vector<RtcpPacket*> appended_packets_;
 
  private:
   bool CreateAndAddAppended(uint8_t* packet,
                             size_t* index,
                             size_t max_length,
                             PacketReadyCallback* callback) const;
 };
-
-// Class holding a RTCP packet.
-//
-// Takes a built rtcp packet.
-//  RawPacket raw_packet(buffer, length);
-//
-// To access the raw packet:
-//  raw_packet.Buffer();         - pointer to the raw packet
-//  raw_packet.BufferLength();   - the length of the raw packet
-
-class RawPacket {
- public:
-  explicit RawPacket(size_t buffer_length);
-  RawPacket(const uint8_t* packet, size_t packet_length);
-
-  const uint8_t* Buffer() const;
-  uint8_t* MutableBuffer();
-  size_t BufferLength() const;
-  size_t Length() const;
-  void SetLength(size_t length);
-
- private:
-  const size_t buffer_length_;
-  size_t length_;
-  rtc::scoped_ptr<uint8_t[]> buffer_;
-};
-
 }  // namespace rtcp
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_PACKET_H_