Revert of Cast:Adding cast_transport_config and cleaning up

media/cast/audio_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 "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "crypto/encryptor.h"
 #include "crypto/symmetric_key.h"
 #include "media/cast/audio_sender/audio_encoder.h"
+#include "media/cast/cast_environment.h"
 #include "media/cast/rtcp/rtcp.h"
 #include "media/cast/transport/rtp_sender/rtp_sender.h"
 
 namespace media {
 namespace cast {
 
 const int64 kMinSchedulingDelayMs = 1;
 
 class LocalRtcpAudioSenderFeedback : public RtcpSenderFeedback {
  public:
@@ skipping 27 matching lines @@
 
  private:
   transport::RtpSender* rtp_sender_;
 };
 
 AudioSender::AudioSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const AudioSenderConfig& audio_config,
     transport::PacedPacketSender* const paced_packet_sender)
       : cast_environment_(cast_environment),
-        rtp_sender_(cast_environment->Clock(), &audio_config, NULL,
+        rtp_sender_(cast_environment, &audio_config, NULL,
                     paced_packet_sender),
         rtcp_feedback_(new LocalRtcpAudioSenderFeedback(this)),
         rtp_audio_sender_statistics_(
             new LocalRtpSenderStatistics(&rtp_sender_)),
         rtcp_(cast_environment,
               rtcp_feedback_.get(),
               paced_packet_sender,
               rtp_audio_sender_statistics_.get(),
               NULL,
               audio_config.rtcp_mode,
@@ skipping 40 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_encoder_.get()) << "Invalid internal state";
   // TODO(mikhal): Resolve calculation of the audio rtp_timestamp for logging.
   // This is a tmp solution to allow the code to build.
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   cast_environment_->Logging()->InsertFrameEvent(now, kAudioFrameReceived,
       GetVideoRtpTimestamp(recorded_time), kFrameIdUnknown);
   audio_encoder_->InsertAudio(audio_bus, recorded_time, done_callback);
 }
 
-void AudioSender::InsertCodedAudioFrame(
-    const transport::EncodedAudioFrame* audio_frame,
-    const base::TimeTicks& recorded_time,
-    const base::Closure callback) {
+void AudioSender::InsertCodedAudioFrame(const EncodedAudioFrame* audio_frame,
+                                        const base::TimeTicks& recorded_time,
+                                        const base::Closure callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_encoder_.get() == NULL) << "Invalid internal state";
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   cast_environment_->Logging()->InsertFrameEvent(now, kAudioFrameReceived,
       GetVideoRtpTimestamp(recorded_time), kFrameIdUnknown);
 
   if (encryptor_) {
-    transport::EncodedAudioFrame encrypted_frame;
+    EncodedAudioFrame encrypted_frame;
     if (!EncryptAudioFrame(*audio_frame, &encrypted_frame)) {
       // Logging already done.
       return;
     }
     rtp_sender_.IncomingEncodedAudioFrame(&encrypted_frame, recorded_time);
   } else {
     rtp_sender_.IncomingEncodedAudioFrame(audio_frame, recorded_time);
   }
   callback.Run();
 }
 
 void AudioSender::SendEncodedAudioFrame(
-    scoped_ptr<transport::EncodedAudioFrame> audio_frame,
+    scoped_ptr<EncodedAudioFrame> audio_frame,
     const base::TimeTicks& recorded_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   InitializeTimers();
   if (encryptor_) {
-    transport::EncodedAudioFrame encrypted_frame;
+    EncodedAudioFrame encrypted_frame;
     if (!EncryptAudioFrame(*audio_frame.get(), &encrypted_frame)) {
       // Logging already done.
       return;
     }
     rtp_sender_.IncomingEncodedAudioFrame(&encrypted_frame, recorded_time);
   } else {
     rtp_sender_.IncomingEncodedAudioFrame(audio_frame.get(), recorded_time);
   }
 }
 
-bool AudioSender::EncryptAudioFrame(
-    const transport::EncodedAudioFrame& audio_frame,
-    transport::EncodedAudioFrame* encrypted_frame) {
+bool AudioSender::EncryptAudioFrame(const EncodedAudioFrame& audio_frame,
+                                    EncodedAudioFrame* encrypted_frame) {
   DCHECK(encryptor_) << "Invalid state";
 
   if (!encryptor_->SetCounter(GetAesNonce(audio_frame.frame_id, iv_mask_))) {
     NOTREACHED() << "Failed to set counter";
     return false;
   }
   if (!encryptor_->Encrypt(audio_frame.data, &encrypted_frame->data)) {
     NOTREACHED() << "Encrypt error";
     return false;
   }
@@ skipping 32 matching lines @@
 void AudioSender::SendRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // We don't send audio logging messages since all captured audio frames will
   // be sent.
   rtcp_.SendRtcpFromRtpSender(NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media