Cast: Reshuffle files under media/cast

media/cast/sender/audio_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/audio_sender/audio_sender.h"
+#include "media/cast/sender/audio_sender.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
-#include "media/cast/audio_sender/audio_encoder.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/rtcp/rtcp_defines.h"
-#include "media/cast/transport/cast_transport_config.h"
+#include "media/cast/net/cast_transport_config.h"
+#include "media/cast/net/rtcp/rtcp_defines.h"
+#include "media/cast/sender/audio_encoder.h"
 
 namespace media {
 namespace cast {
 namespace {
 
 const int kNumAggressiveReportsSentAtStart = 100;
 const int kMinSchedulingDelayMs = 1;
 
 // TODO(miu): This should be specified in AudioSenderConfig, but currently it is
 // fixed to 100 FPS (i.e., 10 ms per frame), and AudioEncoder assumes this as
 // well.
 const int kAudioFrameRate = 100;
 
 // Helper function to compute the maximum unacked audio frames that is sent.
 int GetMaxUnackedFrames(base::TimeDelta target_delay) {
   // As long as it doesn't go over |kMaxUnackedFrames|, it is okay to send more
   // audio data than the target delay would suggest. Audio packets are tiny and
   // receiver has the ability to drop any one of the packets.
   // We send up to three times of the target delay of audio frames.
   int frames =
       1 + 3 * target_delay * kAudioFrameRate / base::TimeDelta::FromSeconds(1);
   return std::min(kMaxUnackedFrames, frames);
 }
 }  // namespace
 
 AudioSender::AudioSender(scoped_refptr<CastEnvironment> cast_environment,
                          const AudioSenderConfig& audio_config,
-                         transport::CastTransportSender* const transport_sender)
+                         CastTransportSender* const transport_sender)
     : cast_environment_(cast_environment),
       target_playout_delay_(audio_config.target_playout_delay),
       transport_sender_(transport_sender),
       max_unacked_frames_(GetMaxUnackedFrames(target_playout_delay_)),
       configured_encoder_bitrate_(audio_config.bitrate),
       rtcp_(cast_environment,
             this,
             transport_sender_,
             NULL,  // paced sender.
             NULL,
@@ skipping 21 matching lines @@
                          audio_config.bitrate,
                          audio_config.codec,
                          base::Bind(&AudioSender::SendEncodedAudioFrame,
                                     weak_factory_.GetWeakPtr())));
     cast_initialization_status_ = audio_encoder_->InitializationResult();
   } else {
     NOTREACHED();  // No support for external audio encoding.
     cast_initialization_status_ = STATUS_AUDIO_UNINITIALIZED;
   }
 
-  media::cast::transport::CastTransportRtpConfig transport_config;
+  media::cast::CastTransportRtpConfig transport_config;
   transport_config.ssrc = audio_config.ssrc;
   transport_config.rtp_payload_type = audio_config.rtp_payload_type;
   // TODO(miu): AudioSender needs to be like VideoSender in providing an upper
   // limit on the number of in-flight frames.
   transport_config.stored_frames = max_unacked_frames_;
   transport_config.aes_key = audio_config.aes_key;
   transport_config.aes_iv_mask = audio_config.aes_iv_mask;
   transport_sender_->InitializeAudio(transport_config);
 
   rtcp_.SetCastReceiverEventHistorySize(kReceiverRtcpEventHistorySize);
@@ skipping 14 matching lines @@
 
   if (AreTooManyFramesInFlight()) {
     VLOG(1) << "Dropping frame due to too many frames currently in-flight.";
     return;
   }
 
   audio_encoder_->InsertAudio(audio_bus.Pass(), recorded_time);
 }
 
 void AudioSender::SendEncodedAudioFrame(
-    scoped_ptr<transport::EncodedFrame> encoded_frame) {
+    scoped_ptr<EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   const uint32 frame_id = encoded_frame->frame_id;
 
   const bool is_first_frame_to_be_sent = last_send_time_.is_null();
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   last_sent_frame_id_ = frame_id;
   // If this is the first frame about to be sent, fake the value of
   // |latest_acked_frame_id_| to indicate the receiver starts out all caught up.
   // Also, schedule the periodic frame re-send checks.
   if (is_first_frame_to_be_sent) {
     latest_acked_frame_id_ = frame_id - 1;
     ScheduleNextResendCheck();
   }
 
   cast_environment_->Logging()->InsertEncodedFrameEvent(
       last_send_time_, FRAME_ENCODED, AUDIO_EVENT, encoded_frame->rtp_timestamp,
       frame_id, static_cast<int>(encoded_frame->data.size()),
-      encoded_frame->dependency == transport::EncodedFrame::KEY,
+      encoded_frame->dependency == EncodedFrame::KEY,
       configured_encoder_bitrate_);
   // Only use lowest 8 bits as key.
   frame_id_to_rtp_timestamp_[frame_id & 0xff] = encoded_frame->rtp_timestamp;
 
   DCHECK(!encoded_frame->reference_time.is_null());
   rtp_timestamp_helper_.StoreLatestTime(encoded_frame->reference_time,
                                         encoded_frame->rtp_timestamp);
 
   // At the start of the session, it's important to send reports before each
   // frame so that the receiver can properly compute playout times.  The reason
@@ skipping 192 matching lines @@
   rtcp_.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt);
 
   // Sending this extra packet is to kick-start the session. There is
   // no need to optimize re-transmission for this case.
   transport_sender_->ResendPackets(
       true, missing_frames_and_packets, false, min_rtt);
 }
 
 }  // namespace cast
 }  // namespace media