Cast: move net->transport

media/cast/rtcp/rtcp_receiver.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_receiver.h"
 
 #include "base/logging.h"
 #include "media/cast/rtcp/rtcp_utility.h"
+#include "media/cast/transport/cast_transport_defines.h"
 
 namespace {
 
 media::cast::CastLoggingEvent TranslateToLogEventFromWireFormat(uint8 event) {
   switch (event) {
     case 1:
       return media::cast::kAckSent;
     case 2:
       return media::cast::kAudioPlayoutDelay;
     case 3:
       return media::cast::kAudioFrameDecoded;
     case 4:
       return media::cast::kVideoFrameDecoded;
     case 5:
       return media::cast::kVideoRenderDelay;
     case 6:
       return media::cast::kPacketReceived;
     default:
       // 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 media::cast::kUnknown;
   }
 }
 
-media::cast::RtcpSenderFrameStatus TranslateToFrameStatusFromWireFormat(
-    uint8 status) {
+media::cast::transport::RtcpSenderFrameStatus
+    TranslateToFrameStatusFromWireFormat(uint8 status) {
   switch (status) {
     case 0:
-      return media::cast::kRtcpSenderFrameStatusUnknown;
+      return media::cast::transport::kRtcpSenderFrameStatusUnknown;
     case 1:
-      return media::cast::kRtcpSenderFrameStatusDroppedByEncoder;
+      return media::cast::transport::kRtcpSenderFrameStatusDroppedByEncoder;
     case 2:
-      return media::cast::kRtcpSenderFrameStatusDroppedByFlowControl;
+      return media::cast::transport::kRtcpSenderFrameStatusDroppedByFlowControl;
     case 3:
-      return media::cast::kRtcpSenderFrameStatusSentToNetwork;
+      return media::cast::transport::kRtcpSenderFrameStatusSentToNetwork;
     default:
       // If the sender adds new log messages we will end up here until we add
       // the new messages in the receiver.
       NOTREACHED();
       VLOG(1) << "Unexpected status received: " << static_cast<int>(status);
-      return media::cast::kRtcpSenderFrameStatusUnknown;
+      return media::cast::transport::kRtcpSenderFrameStatusUnknown;
   }
 }
 
 }  // namespace
 
 namespace media {
 namespace cast {
 
 RtcpReceiver::RtcpReceiver(scoped_refptr<CastEnvironment> cast_environment,
                            RtcpSenderFeedback* sender_feedback,
@@ skipping 85 matching lines @@
   const RtcpField& rtcp_field = rtcp_parser->Field();
 
   DCHECK(rtcp_field_type == kRtcpSrCode) << "Invalid state";
 
   // Synchronization source identifier for the originator of this SR packet.
   uint32 remote_ssrc = rtcp_field.sender_report.sender_ssrc;
 
   VLOG(1) << "Cast RTCP received SR from SSRC " << remote_ssrc;
 
   if (remote_ssrc_ == remote_ssrc) {
-    RtcpSenderInfo remote_sender_info;
+    transport::RtcpSenderInfo remote_sender_info;
     remote_sender_info.ntp_seconds =
         rtcp_field.sender_report.ntp_most_significant;
     remote_sender_info.ntp_fraction =
         rtcp_field.sender_report.ntp_least_significant;
     remote_sender_info.rtp_timestamp =
         rtcp_field.sender_report.rtp_timestamp;
     remote_sender_info.send_packet_count =
         rtcp_field.sender_report.sender_packet_count;
     remote_sender_info.send_octet_count =
         rtcp_field.sender_report.sender_octet_count;
@@ skipping 43 matching lines @@
     // This block is not for us ignore it.
     return;
   }
   VLOG(1) << "Cast RTCP received RB from SSRC " << remote_ssrc;
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   cast_environment_->Logging()->InsertGenericEvent(now, kPacketLoss,
                                                    rb.fraction_lost);
   cast_environment_->Logging()->InsertGenericEvent(now, kJitterMs,
                                                    rb.jitter);
 
-  RtcpReportBlock report_block;
+  transport::RtcpReportBlock report_block;
   report_block.remote_ssrc = remote_ssrc;
   report_block.media_ssrc = rb.ssrc;
   report_block.fraction_lost = rb.fraction_lost;
   report_block.cumulative_lost = rb.cumulative_number_of_packets_lost;
   report_block.extended_high_sequence_number =
       rb.extended_highest_sequence_number;
   report_block.jitter = rb.jitter;
   report_block.last_sr = rb.last_sender_report;
   report_block.delay_since_last_sr = rb.delay_last_sender_report;
 
@@ skipping 256 matching lines @@
   uint32 remote_ssrc = rtcp_field.cast_sender_log.sender_ssrc;
 
   if (remote_ssrc_ != remote_ssrc) {
     RtcpFieldTypes field_type;
     // Message not to us. Iterate until we have passed this message.
     do {
       field_type = rtcp_parser->Iterate();
     } while (field_type == kRtcpApplicationSpecificCastSenderLogCode);
     return;
   }
-  RtcpSenderLogMessage sender_log;
+  transport::RtcpSenderLogMessage sender_log;
 
   RtcpFieldTypes field_type = rtcp_parser->Iterate();
   while (field_type == kRtcpApplicationSpecificCastSenderLogCode) {
     const RtcpField& rtcp_field = rtcp_parser->Field();
-    RtcpSenderFrameLogMessage frame_log;
+    transport::RtcpSenderFrameLogMessage frame_log;
     frame_log.frame_status =
         TranslateToFrameStatusFromWireFormat(rtcp_field.cast_sender_log.status);
     frame_log.rtp_timestamp = rtcp_field.cast_sender_log.rtp_timestamp;
     sender_log.push_back(frame_log);
     field_type = rtcp_parser->Iterate();
   }
   if (receiver_feedback_) {
     receiver_feedback_->OnReceivedSenderLog(sender_log);
   }
 }
@@ skipping 63 matching lines @@
 
 void RtcpReceiver::HandleFIRItem(const RtcpField* rtcp_field) {
   // Is it our sender that is requested to generate a new keyframe.
   if (ssrc_ != rtcp_field->fir_item.ssrc) return;
 
   VLOG(1) << "Cast RTCP received FIR on our SSRC " << ssrc_;
 }
 
 }  // namespace cast
 }  // namespace media