Use RtcpPacket classes for SenderReport/ReceiveReport in RTCPSender

webrtc/modules/rtp_rtcp/source/rtcp_sender.h

 /*
  *  Copyright (c) 2012 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_SENDER_H_
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_
 
 #include <map>
 #include <set>
 #include <sstream>
 #include <string>
 
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 class ModuleRtpRtcpImpl;
 class RTCPReceiver;
 
@@ skipping 134 matching lines @@
  //   (IP packet is full). Proceed to the next packet type, and call this
  //   method again when a new buffer has been allocated.
  // TODO(sprang): Actually allocate multiple packets if needed.
  // kSuccess
  //   Data has been successfully placed in the buffer.
 
  enum class BuildResult { kError, kAborted, kTruncated, kSuccess };
 
  int32_t SendToNetwork(const uint8_t* dataBuffer, size_t length);
 
- RTCPSender::BuildResult WriteAllReportBlocksToBuffer(
-     RtcpContext* context,
-     uint8_t* numberOfReportBlocks)
+ int32_t AddReportBlock(const RTCPReportBlock& report_block)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
 
- void WriteReportBlocksToBuffer(
-     RtcpContext* context,
-     const std::map<uint32_t, RTCPReportBlock*>& report_blocks);
-
- int32_t AddReportBlock(uint32_t SSRC,
-                        std::map<uint32_t, RTCPReportBlock*>* report_blocks,
-                        const RTCPReportBlock* receiveBlock);
-
  bool PrepareReport(const FeedbackState& feedback_state,
+                    uint32_t ssrc,
                     StreamStatistician* statistician,
-                    RTCPReportBlock* report_block,
-                    uint32_t* ntp_secs,
-                    uint32_t* ntp_frac);
+                    RTCPReportBlock* report_block);
 
  int PrepareRTCP(const FeedbackState& feedback_state,
                  const std::set<RTCPPacketType>& packetTypes,
                  int32_t nackSize,
                  const uint16_t* nackList,
                  bool repeat,
                  uint64_t pictureID,
                  uint8_t* rtcp_buffer,
                  int buffer_size);
 
@@ skipping 52 matching lines @@
  uint32_t start_timestamp_ GUARDED_BY(critical_section_rtcp_sender_);
  uint32_t last_rtp_timestamp_ GUARDED_BY(critical_section_rtcp_sender_);
  int64_t last_frame_capture_time_ms_ GUARDED_BY(critical_section_rtcp_sender_);
  uint32_t ssrc_ GUARDED_BY(critical_section_rtcp_sender_);
  // SSRC that we receive on our RTP channel
  uint32_t remote_ssrc_ GUARDED_BY(critical_section_rtcp_sender_);
  char cname_[RTCP_CNAME_SIZE] GUARDED_BY(critical_section_rtcp_sender_);
 
  ReceiveStatistics* receive_statistics_
      GUARDED_BY(critical_section_rtcp_sender_);
- std::map<uint32_t, RTCPReportBlock*> internal_report_blocks_
+ std::map<uint32_t, rtcp::ReportBlock> report_blocks_
      GUARDED_BY(critical_section_rtcp_sender_);
+ // TODO(sprang): Can we avoid pointers here?
  std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> csrc_cnames_
      GUARDED_BY(critical_section_rtcp_sender_);
 
  // Sent
  uint32_t last_send_report_[RTCP_NUMBER_OF_SR] GUARDED_BY(
      critical_section_rtcp_sender_);  // allow packet loss and RTT above 1 sec
  int64_t last_rtcp_time_[RTCP_NUMBER_OF_SR] GUARDED_BY(
      critical_section_rtcp_sender_);
 
  // Sent XR receiver reference time report.
@@ skipping 50 matching lines @@
    bool operator<(const ReportFlag& flag) const { return type < flag.type; }
    bool operator==(const ReportFlag& flag) const { return type == flag.type; }
    const RTCPPacketType type;
    const bool is_volatile;
  };
 
  std::set<ReportFlag> report_flags_ GUARDED_BY(critical_section_rtcp_sender_);
 
  typedef BuildResult (RTCPSender::*Builder)(RtcpContext*);
  std::map<RTCPPacketType, Builder> builders_;
+
+ class PacketBuiltCallback;
 };
 }  // namespace webrtc
 
 #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_