Cast: Reshuffle files under media/cast

media/cast/net/rtcp/rtcp_utility.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_utility.h"
+#include "media/cast/net/rtcp/rtcp_utility.h"
 
 #include "base/big_endian.h"
 #include "base/logging.h"
-#include "media/cast/transport/cast_transport_defines.h"
+#include "media/cast/net/cast_transport_defines.h"
 
 namespace media {
 namespace cast {
 
 RtcpParser::RtcpParser(const uint8* rtcpData, size_t rtcpDataLength)
     : rtcp_data_begin_(rtcpData),
       rtcp_data_end_(rtcpData + rtcpDataLength),
       valid_packet_(false),
       rtcp_data_(rtcpData),
       rtcp_block_end_(NULL),
@@ skipping 79 matching lines @@
     bool success = RtcpParseCommonHeader(rtcp_data_, rtcp_data_end_, &header);
     if (!success)
       return;
 
     rtcp_block_end_ = rtcp_data_ + header.length_in_octets;
 
     if (rtcp_block_end_ > rtcp_data_end_)
       return;  // Bad block!
 
     switch (header.PT) {
-      case transport::kPacketTypeSenderReport:
+      case kPacketTypeSenderReport:
         // number of Report blocks
         number_of_blocks_ = header.IC;
         ParseSR();
         return;
-      case transport::kPacketTypeReceiverReport:
+      case kPacketTypeReceiverReport:
         // number of Report blocks
         number_of_blocks_ = header.IC;
         ParseRR();
         return;
-      case transport::kPacketTypeSdes:
+      case kPacketTypeSdes:
         // number of Sdes blocks
         number_of_blocks_ = header.IC;
         if (!ParseSdes()) {
           break;  // Nothing supported found, continue to next block!
         }
         return;
-      case transport::kPacketTypeBye:
+      case kPacketTypeBye:
         number_of_blocks_ = header.IC;
         if (!ParseBye()) {
           // Nothing supported found, continue to next block!
           break;
         }
         return;
-      case transport::kPacketTypeApplicationDefined:
+      case kPacketTypeApplicationDefined:
         if (!ParseApplicationDefined(header.IC)) {
           // Nothing supported found, continue to next block!
           break;
         }
         return;
-      case transport::kPacketTypeGenericRtpFeedback:  // Fall through!
-      case transport::kPacketTypePayloadSpecific:
+      case kPacketTypeGenericRtpFeedback:  // Fall through!
+      case kPacketTypePayloadSpecific:
         if (!ParseFeedBackCommon(header)) {
           // Nothing supported found, continue to next block!
           break;
         }
         return;
-      case transport::kPacketTypeXr:
+      case kPacketTypeXr:
         if (!ParseExtendedReport()) {
           break;  // Nothing supported found, continue to next block!
         }
         return;
       default:
         // Not supported! Skip!
         EndCurrentBlock();
         break;
     }
   }
@@ skipping 445 matching lines @@
   field_.cast_receiver_log.delay_delta_or_packet_id.packet_id =
       delay_delta_or_packet_id;
   field_.cast_receiver_log.event_timestamp_delta =
       event_type_and_timestamp_delta & 0xfff;
 
   field_type_ = kRtcpApplicationSpecificCastReceiverLogEventCode;
   return true;
 }
 
 bool RtcpParser::ParseFeedBackCommon(const RtcpCommonHeader& header) {
-  DCHECK((header.PT == transport::kPacketTypeGenericRtpFeedback) ||
-         (header.PT == transport::kPacketTypePayloadSpecific))
+  DCHECK((header.PT == kPacketTypeGenericRtpFeedback) ||
+         (header.PT == kPacketTypePayloadSpecific))
       << "Invalid state";
 
   ptrdiff_t length = rtcp_block_end_ - rtcp_data_;
 
   if (length < 12) {  // 4 * 3, RFC4585 section 6.1
     EndCurrentBlock();
     return false;
   }
 
   uint32 sender_ssrc;
   uint32 media_ssrc;
   base::BigEndianReader big_endian_reader(
       reinterpret_cast<const char*>(rtcp_data_), length);
   big_endian_reader.Skip(4);  // Skip header.
   big_endian_reader.ReadU32(&sender_ssrc);
   big_endian_reader.ReadU32(&media_ssrc);
 
   rtcp_data_ += 12;
 
-  if (header.PT == transport::kPacketTypeGenericRtpFeedback) {
+  if (header.PT == kPacketTypeGenericRtpFeedback) {
     // Transport layer feedback
     switch (header.IC) {
       case 1:
         // Nack
         field_type_ = kRtcpGenericRtpFeedbackNackCode;
         field_.nack.sender_ssrc = sender_ssrc;
         field_.nack.media_ssrc = media_ssrc;
         state_ = kStateGenericRtpFeedbackNack;
         return true;
       case 2:
@@ skipping 12 matching lines @@
         field_type_ = kRtcpGenericRtpFeedbackSrReqCode;
 
         // Note: No state transition, sender report REQ is empty!
         return true;
       default:
         break;
     }
     EndCurrentBlock();
     return false;
 
-  } else if (header.PT == transport::kPacketTypePayloadSpecific) {
+  } else if (header.PT == kPacketTypePayloadSpecific) {
     // Payload specific feedback
     switch (header.IC) {
       case 1:
         // PLI
         field_type_ = kRtcpPayloadSpecificPliCode;
         field_.pli.sender_ssrc = sender_ssrc;
         field_.pli.media_ssrc = media_ssrc;
 
         // Note: No state transition, PLI FCI is empty!
         return true;
@@ skipping 380 matching lines @@
       // If the sender adds new log messages we will end up here until we add
       // the new messages in the receiver.
       VLOG(1) << "Unexpected log message received: " << static_cast<int>(event);
       NOTREACHED();
       return UNKNOWN;
   }
 }
 
 }  // namespace cast
 }  // namespace media