Cast: Reshuffle files under media/cast

media/cast/net/rtcp/rtcp_sender.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "media/cast/rtcp/rtcp_sender.h"
+#include "media/cast/net/rtcp/rtcp_sender.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/logging.h"
 #include "media/cast/cast_environment.h"
-#include "media/cast/rtcp/rtcp_defines.h"
-#include "media/cast/rtcp/rtcp_utility.h"
-#include "media/cast/transport/cast_transport_defines.h"
-#include "media/cast/transport/pacing/paced_sender.h"
+#include "media/cast/net/cast_transport_defines.h"
+#include "media/cast/net/pacing/paced_sender.h"
+#include "media/cast/net/rtcp/rtcp_defines.h"
+#include "media/cast/net/rtcp/rtcp_utility.h"
 
 namespace media {
 namespace cast {
 namespace {
 
 // Max delta is 4095 milliseconds because we need to be able to encode it in
 // 12 bits.
 const int64 kMaxWireFormatTimeDeltaMs = INT64_C(0xfff);
 
 uint16 MergeEventTypeAndTimestampForWireFormat(
@@ skipping 112 matching lines @@
   int frame_count_;
   int packet_count_;
   int last_frame_id_;
   int last_packet_id_;
   bool contiguous_sequence_;
 };
 }  // namespace
 
 // TODO(mikhal): This is only used by the receiver. Consider renaming.
 RtcpSender::RtcpSender(scoped_refptr<CastEnvironment> cast_environment,
-                       transport::PacedPacketSender* outgoing_transport,
+                       PacedPacketSender* outgoing_transport,
                        uint32 sending_ssrc,
                        const std::string& c_name)
     : ssrc_(sending_ssrc),
       c_name_(c_name),
       transport_(outgoing_transport),
       cast_environment_(cast_environment) {
   DCHECK_LT(c_name_.length(), kRtcpCnameSize) << "Invalid config";
 }
 
 RtcpSender::~RtcpSender() {}
 
 void RtcpSender::SendRtcpFromRtpReceiver(
     uint32 packet_type_flags,
-    const transport::RtcpReportBlock* report_block,
+    const RtcpReportBlock* report_block,
     const RtcpReceiverReferenceTimeReport* rrtr,
     const RtcpCastMessage* cast_message,
     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events,
     base::TimeDelta target_delay) {
-  if (packet_type_flags & transport::kRtcpSr ||
-      packet_type_flags & transport::kRtcpDlrr ||
-      packet_type_flags & transport::kRtcpSenderLog) {
+  if (packet_type_flags & kRtcpSr ||
+      packet_type_flags & kRtcpDlrr ||
+      packet_type_flags & kRtcpSenderLog) {
     NOTREACHED() << "Invalid argument";
   }
-  if (packet_type_flags & transport::kRtcpPli ||
-      packet_type_flags & transport::kRtcpRpsi ||
-      packet_type_flags & transport::kRtcpRemb ||
-      packet_type_flags & transport::kRtcpNack) {
+  if (packet_type_flags & kRtcpPli ||
+      packet_type_flags & kRtcpRpsi ||
+      packet_type_flags & kRtcpRemb ||
+      packet_type_flags & kRtcpNack) {
     // Implement these for webrtc interop.
     NOTIMPLEMENTED();
   }
-  transport::PacketRef packet(new base::RefCountedData<Packet>);
+  PacketRef packet(new base::RefCountedData<Packet>);
   packet->data.reserve(kMaxIpPacketSize);
 
-  if (packet_type_flags & transport::kRtcpRr) {
+  if (packet_type_flags & kRtcpRr) {
     BuildRR(report_block, &packet->data);
     if (!c_name_.empty()) {
       BuildSdec(&packet->data);
     }
   }
-  if (packet_type_flags & transport::kRtcpBye) {
+  if (packet_type_flags & kRtcpBye) {
     BuildBye(&packet->data);
   }
-  if (packet_type_flags & transport::kRtcpRrtr) {
+  if (packet_type_flags & kRtcpRrtr) {
     DCHECK(rrtr) << "Invalid argument";
     BuildRrtr(rrtr, &packet->data);
   }
-  if (packet_type_flags & transport::kRtcpCast) {
+  if (packet_type_flags & kRtcpCast) {
     DCHECK(cast_message) << "Invalid argument";
     BuildCast(cast_message, target_delay, &packet->data);
   }
-  if (packet_type_flags & transport::kRtcpReceiverLog) {
+  if (packet_type_flags & kRtcpReceiverLog) {
     DCHECK(rtcp_events) << "Invalid argument";
     BuildReceiverLog(*rtcp_events, &packet->data);
   }
 
   if (packet->data.empty())
     return;  // Sanity don't send empty packets.
 
   transport_->SendRtcpPacket(ssrc_, packet);
 }
 
-void RtcpSender::BuildRR(const transport::RtcpReportBlock* report_block,
+void RtcpSender::BuildRR(const RtcpReportBlock* report_block,
                          Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 32, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 32 > kMaxIpPacketSize)
     return;
 
   uint16 number_of_rows = (report_block) ? 7 : 1;
   packet->resize(start_size + 8);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 8);
   big_endian_writer.WriteU8(0x80 + (report_block ? 1 : 0));
-  big_endian_writer.WriteU8(transport::kPacketTypeReceiverReport);
+  big_endian_writer.WriteU8(kPacketTypeReceiverReport);
   big_endian_writer.WriteU16(number_of_rows);
   big_endian_writer.WriteU32(ssrc_);
 
   if (report_block) {
     AddReportBlocks(*report_block, packet);  // Adds 24 bytes.
   }
 }
 
-void RtcpSender::AddReportBlocks(const transport::RtcpReportBlock& report_block,
+void RtcpSender::AddReportBlocks(const RtcpReportBlock& report_block,
                                  Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 24 > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + 24);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 24);
@@ skipping 23 matching lines @@
   if (start_size + 12 > kMaxIpPacketSize)
     return;
 
   // SDES Source Description.
   packet->resize(start_size + 10);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 10);
   // We always need to add one SDES CNAME.
   big_endian_writer.WriteU8(0x80 + 1);
-  big_endian_writer.WriteU8(transport::kPacketTypeSdes);
+  big_endian_writer.WriteU8(kPacketTypeSdes);
 
   // Handle SDES length later on.
   uint32 sdes_length_position = static_cast<uint32>(start_size) + 3;
   big_endian_writer.WriteU16(0);
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(1);       // CNAME = 1
   big_endian_writer.WriteU8(static_cast<uint8>(c_name_.length()));
 
   size_t sdes_length = 10 + c_name_.length();
   packet->insert(
@@ skipping 22 matching lines @@
   DCHECK_LT(start_size + 12, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 12 > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + 12);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 12);
   uint8 FMT = 1;  // Picture loss indicator.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU16(2);            // Used fixed length of 2.
   big_endian_writer.WriteU32(ssrc_);        // Add our own SSRC.
   big_endian_writer.WriteU32(remote_ssrc);  // Add the remote SSRC.
 }
 
 /*
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |      PB       |0| Payload Type|    Native Rpsi bit string     |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |   defined per codec          ...                | Padding (0) |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 void RtcpSender::BuildRpsi(const RtcpRpsiMessage* rpsi, Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 24 > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + 24);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 24);
   uint8 FMT = 3;  // Reference Picture Selection Indication.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
 
   // Calculate length.
   uint32 bits_required = 7;
   uint8 bytes_required = 1;
   while ((rpsi->picture_id >> bits_required) > 0) {
     bits_required += 7;
     bytes_required++;
   }
   uint8 size = 3;
   if (bytes_required > 6) {
@@ skipping 37 matching lines @@
     return;
 
   packet->resize(start_size + remb_size);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), remb_size);
 
   // Add application layer feedback.
   uint8 FMT = 15;
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU8(0);
   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size() + 4));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(0);      // Remote SSRC must be 0.
   big_endian_writer.WriteU32(kRemb);
   big_endian_writer.WriteU8(static_cast<uint8>(remb->remb_ssrcs.size()));
 
   // 6 bit exponent and a 18 bit mantissa.
   uint8 bitrate_exponent;
   uint32 bitrate_mantissa;
@@ skipping 17 matching lines @@
   if (start_size + 16 > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + 16);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 16);
 
   uint8 FMT = 1;
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypeGenericRtpFeedback);
+  big_endian_writer.WriteU8(kPacketTypeGenericRtpFeedback);
   big_endian_writer.WriteU8(0);
   size_t nack_size_pos = start_size + 3;
   big_endian_writer.WriteU8(3);
   big_endian_writer.WriteU32(ssrc_);              // Add our own SSRC.
   big_endian_writer.WriteU32(nack->remote_ssrc);  // Add the remote SSRC.
 
   // Build NACK bitmasks and write them to the Rtcp message.
   // The nack list should be sorted and not contain duplicates.
   size_t number_of_nack_fields = 0;
   size_t max_number_of_nack_fields = std::min<size_t>(
@@ skipping 35 matching lines @@
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 8 > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + 8);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 8);
   big_endian_writer.WriteU8(0x80 + 1);
-  big_endian_writer.WriteU8(transport::kPacketTypeBye);
+  big_endian_writer.WriteU8(kPacketTypeBye);
   big_endian_writer.WriteU16(1);      // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
 }
 
 void RtcpSender::BuildRrtr(const RtcpReceiverReferenceTimeReport* rrtr,
                            Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 20 > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + 20);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 20);
 
   big_endian_writer.WriteU8(0x80);
-  big_endian_writer.WriteU8(transport::kPacketTypeXr);
+  big_endian_writer.WriteU8(kPacketTypeXr);
   big_endian_writer.WriteU16(4);      // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU8(4);       // Add block type.
   big_endian_writer.WriteU8(0);       // Add reserved.
   big_endian_writer.WriteU16(2);      // Block length.
 
   // Add the media (received RTP) SSRC.
   big_endian_writer.WriteU32(rrtr->ntp_seconds);
   big_endian_writer.WriteU32(rrtr->ntp_fraction);
 }
 
 void RtcpSender::BuildCast(const RtcpCastMessage* cast,
                            base::TimeDelta target_delay,
                            Packet* packet) const {
   size_t start_size = packet->size();
   DCHECK_LT(start_size + 20, kMaxIpPacketSize) << "Not enough buffer space";
   if (start_size + 20 > kMaxIpPacketSize)
     return;
 
   packet->resize(start_size + 20);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[start_size])), 20);
   uint8 FMT = 15;  // Application layer feedback.
   big_endian_writer.WriteU8(0x80 + FMT);
-  big_endian_writer.WriteU8(transport::kPacketTypePayloadSpecific);
+  big_endian_writer.WriteU8(kPacketTypePayloadSpecific);
   big_endian_writer.WriteU8(0);
   size_t cast_size_pos = start_size + 3;  // Save length position.
   big_endian_writer.WriteU8(4);
   big_endian_writer.WriteU32(ssrc_);              // Add our own SSRC.
   big_endian_writer.WriteU32(cast->media_ssrc_);  // Remote SSRC.
   big_endian_writer.WriteU32(kCast);
   big_endian_writer.WriteU8(static_cast<uint8>(cast->ack_frame_id_));
   size_t cast_loss_field_pos = start_size + 17;  // Save loss field position.
   big_endian_writer.WriteU8(0);  // Overwritten with number_of_loss_fields.
   DCHECK_LE(target_delay.InMilliseconds(),
@@ skipping 80 matching lines @@
                                    &number_of_frames,
                                    &total_number_of_messages_to_send,
                                    &rtcp_log_size)) {
     return;
   }
   packet->resize(packet_start_size + rtcp_log_size);
 
   base::BigEndianWriter big_endian_writer(
       reinterpret_cast<char*>(&((*packet)[packet_start_size])), rtcp_log_size);
   big_endian_writer.WriteU8(0x80 + kReceiverLogSubtype);
-  big_endian_writer.WriteU8(transport::kPacketTypeApplicationDefined);
+  big_endian_writer.WriteU8(kPacketTypeApplicationDefined);
   big_endian_writer.WriteU16(static_cast<uint16>(
       2 + 2 * number_of_frames + total_number_of_messages_to_send));
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(kCast);
 
   while (!receiver_log_message.empty() &&
          total_number_of_messages_to_send > 0) {
     RtcpReceiverFrameLogMessage& frame_log_messages(
         receiver_log_message.front());
 
@@ skipping 161 matching lines @@
       << "Not enough buffer space.";
 
   VLOG(3) << "number of frames: " << *number_of_frames;
   VLOG(3) << "total messages to send: " << *total_number_of_messages_to_send;
   VLOG(3) << "rtcp log size: " << *rtcp_log_size;
   return *number_of_frames > 0;
 }
 
 }  // namespace cast
 }  // namespace media