Cast: Reshuffle files under media/cast

media/cast/net/rtcp/rtcp.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.h"
+#include "media/cast/net/rtcp/rtcp.h"
 
 #include "base/big_endian.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
-#include "media/cast/rtcp/rtcp_defines.h"
-#include "media/cast/rtcp/rtcp_receiver.h"
-#include "media/cast/rtcp/rtcp_sender.h"
-#include "media/cast/rtcp/rtcp_utility.h"
-#include "media/cast/transport/cast_transport_defines.h"
+#include "media/cast/net/cast_transport_defines.h"
+#include "media/cast/net/rtcp/rtcp_defines.h"
+#include "media/cast/net/rtcp/rtcp_receiver.h"
+#include "media/cast/net/rtcp/rtcp_sender.h"
+#include "media/cast/net/rtcp/rtcp_utility.h"
 
 using base::TimeDelta;
 
 namespace media {
 namespace cast {
 
 static const int32 kMaxRttMs = 10000;  // 10 seconds.
 static const int32 kMaxDelayMs = 2000;  // 2 seconds.
 
 class LocalRtcpRttFeedback : public RtcpRttFeedback {
@@ skipping 11 matching lines @@
   Rtcp* rtcp_;
 };
 
 class LocalRtcpReceiverFeedback : public RtcpReceiverFeedback {
  public:
   LocalRtcpReceiverFeedback(Rtcp* rtcp,
                             scoped_refptr<CastEnvironment> cast_environment)
       : rtcp_(rtcp), cast_environment_(cast_environment) {}
 
   virtual void OnReceivedSenderReport(
-      const transport::RtcpSenderInfo& remote_sender_info) OVERRIDE {
+      const RtcpSenderInfo& remote_sender_info) OVERRIDE {
     rtcp_->OnReceivedNtp(remote_sender_info.ntp_seconds,
                          remote_sender_info.ntp_fraction);
     if (remote_sender_info.send_packet_count != 0) {
       rtcp_->OnReceivedLipSyncInfo(remote_sender_info.rtp_timestamp,
                                    remote_sender_info.ntp_seconds,
                                    remote_sender_info.ntp_fraction);
     }
   }
 
   virtual void OnReceiverReferenceTimeReport(
@@ skipping 11 matching lines @@
     rtcp_->OnReceivedReceiverLog(receiver_log);
   }
 
  private:
   Rtcp* rtcp_;
   scoped_refptr<CastEnvironment> cast_environment_;
 };
 
 Rtcp::Rtcp(scoped_refptr<CastEnvironment> cast_environment,
            RtcpSenderFeedback* sender_feedback,
-           transport::CastTransportSender* const transport_sender,
-           transport::PacedPacketSender* paced_packet_sender,
+           CastTransportSender* const transport_sender,
+           PacedPacketSender* paced_packet_sender,
            RtpReceiverStatistics* rtp_receiver_statistics, RtcpMode rtcp_mode,
            const base::TimeDelta& rtcp_interval, uint32 local_ssrc,
            uint32 remote_ssrc, const std::string& c_name,
            EventMediaType event_media_type)
     : cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       rtcp_interval_(rtcp_interval),
       rtcp_mode_(rtcp_mode),
       local_ssrc_(local_ssrc),
       remote_ssrc_(remote_ssrc),
@@ skipping 17 matching lines @@
 }
 
 Rtcp::~Rtcp() {}
 
 // static
 bool Rtcp::IsRtcpPacket(const uint8* packet, size_t length) {
   DCHECK_GE(length, kMinLengthOfRtcp) << "Invalid RTCP packet";
   if (length < kMinLengthOfRtcp) return false;
 
   uint8 packet_type = packet[1];
-  if (packet_type >= transport::kPacketTypeLow &&
-      packet_type <= transport::kPacketTypeHigh) {
+  if (packet_type >= kPacketTypeLow &&
+      packet_type <= kPacketTypeHigh) {
     return true;
   }
   return false;
 }
 
 // static
 uint32 Rtcp::GetSsrcOfSender(const uint8* rtcp_buffer, size_t length) {
   DCHECK_GE(length, kMinLengthOfRtcp) << "Invalid RTCP packet";
   uint32 ssrc_of_sender;
   base::BigEndianReader big_endian_reader(
@@ skipping 20 matching lines @@
   rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
 }
 
 void Rtcp::SendRtcpFromRtpReceiver(
     const RtcpCastMessage* cast_message,
     const ReceiverRtcpEventSubscriber::RtcpEventMultiMap* rtcp_events) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   uint32 packet_type_flags = 0;
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-  transport::RtcpReportBlock report_block;
+  RtcpReportBlock report_block;
   RtcpReceiverReferenceTimeReport rrtr;
 
   // Attach our NTP to all RTCP packets; with this information a "smart" sender
   // can make decisions based on how old the RTCP message is.
-  packet_type_flags |= transport::kRtcpRrtr;
+  packet_type_flags |= kRtcpRrtr;
   ConvertTimeTicksToNtp(now, &rrtr.ntp_seconds, &rrtr.ntp_fraction);
   SaveLastSentNtpTime(now, rrtr.ntp_seconds, rrtr.ntp_fraction);
 
   if (cast_message) {
-    packet_type_flags |= transport::kRtcpCast;
+    packet_type_flags |= kRtcpCast;
   }
   if (rtcp_events) {
-    packet_type_flags |= transport::kRtcpReceiverLog;
+    packet_type_flags |= kRtcpReceiverLog;
   }
   if (rtcp_mode_ == kRtcpCompound || now >= next_time_to_send_rtcp_) {
-    packet_type_flags |= transport::kRtcpRr;
+    packet_type_flags |= kRtcpRr;
 
     report_block.remote_ssrc = 0;            // Not needed to set send side.
     report_block.media_ssrc = remote_ssrc_;  // SSRC of the RTP packet sender.
     if (rtp_receiver_statistics_) {
       rtp_receiver_statistics_->GetStatistics(
           &report_block.fraction_lost, &report_block.cumulative_lost,
           &report_block.extended_high_sequence_number, &report_block.jitter);
     }
 
     report_block.last_sr = last_report_truncated_ntp_;
@@ skipping 14 matching lines @@
                                         &report_block,
                                         &rrtr,
                                         cast_message,
                                         rtcp_events,
                                         target_delay_);
 }
 
 void Rtcp::SendRtcpFromRtpSender(base::TimeTicks current_time,
                                  uint32 current_time_as_rtp_timestamp) {
   DCHECK(transport_sender_);
-  uint32 packet_type_flags = transport::kRtcpSr;
+  uint32 packet_type_flags = kRtcpSr;
   uint32 current_ntp_seconds = 0;
   uint32 current_ntp_fractions = 0;
   ConvertTimeTicksToNtp(current_time, &current_ntp_seconds,
                         &current_ntp_fractions);
   SaveLastSentNtpTime(current_time, current_ntp_seconds,
                       current_ntp_fractions);
 
-  transport::RtcpDlrrReportBlock dlrr;
+  RtcpDlrrReportBlock dlrr;
   if (!time_last_report_received_.is_null()) {
-    packet_type_flags |= transport::kRtcpDlrr;
+    packet_type_flags |= kRtcpDlrr;
     dlrr.last_rr = last_report_truncated_ntp_;
     uint32 delay_seconds = 0;
     uint32 delay_fraction = 0;
     base::TimeDelta delta = current_time - time_last_report_received_;
     ConvertTimeToFractions(delta.InMicroseconds(), &delay_seconds,
                            &delay_fraction);
 
     dlrr.delay_since_last_rr = ConvertToNtpDiff(delay_seconds, delay_fraction);
   }
 
@@ skipping 189 matching lines @@
           VLOG(2) << "Received log message via RTCP that we did not expect: "
                   << static_cast<int>(event_it->type);
           break;
       }
     }
   }
 }
 
 }  // namespace cast
 }  // namespace media