Revert of Cast:Adding cast_transport_config and cleaning up

media/cast/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 "base/logging.h"
-#include "media/cast/transport/cast_transport_defines.h"
 #include "net/base/big_endian.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),
@@ skipping 84 matching lines @@
     RtcpCommonHeader header;
 
     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 449 matching lines @@
   rtcp_data_ += 4;
 
   field_.cast_sender_log.status = static_cast<uint8>(data >> 24);
   // We have 24 LSB of the RTP timestamp on the wire.
   field_.cast_sender_log.rtp_timestamp = data & 0xffffff;
   field_type_ = kRtcpApplicationSpecificCastSenderLogCode;
   return true;
 }
 
 bool RtcpParser::ParseFeedBackCommon(const RtcpCommonHeader& header) {
-  DCHECK((header.PT == transport::kPacketTypeGenericRtpFeedback) ||
-         (header.PT == transport::kPacketTypePayloadSpecific)) <<
-          "Invalid state";
+  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;
   net::BigEndianReader big_endian_reader(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 319 matching lines @@
 
   rtcp_data_ += 12;
 
   number_of_blocks_--;
   field_type_ = kRtcpXrDlrrCode;
   return true;
 }
 
 }  // namespace cast
 }  // namespace media