Cast:Adding cast_transport_config and cleaning up

media/cast/audio_receiver/audio_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/audio_receiver/audio_receiver.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "crypto/encryptor.h"
@@ skipping 264 matching lines @@
 
 void AudioReceiver::PlayoutTimeout() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_buffer_) << "Invalid function call in this configuration";
   if (queued_encoded_callbacks_.empty()) {
     // Already released by incoming packet.
     return;
   }
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
-  scoped_ptr<EncodedAudioFrame> encoded_frame(new EncodedAudioFrame());
+  scoped_ptr<transport::EncodedAudioFrame> encoded_frame(
+      new transport::EncodedAudioFrame());
 
   if (!audio_buffer_->GetEncodedAudioFrame(encoded_frame.get(),
                                            &rtp_timestamp, &next_frame)) {
     // We have no audio frames. Wait for new packet(s).
     // Since the application can post multiple AudioFrameEncodedCallback and
     // we only check the next frame to play out we might have multiple timeout
     // events firing after each other; however this should be a rare event.
     VLOG(1) << "Failed to retrieved a complete frame at this point in time";
     return;
   }
@@ skipping 10 matching lines @@
   }
 }
 
 void AudioReceiver::GetEncodedAudioFrame(
     const AudioFrameEncodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_buffer_) << "Invalid function call in this configuration";
 
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
-  scoped_ptr<EncodedAudioFrame> encoded_frame(new EncodedAudioFrame());
+  scoped_ptr<transport::EncodedAudioFrame> encoded_frame(
+      new transport::EncodedAudioFrame());
 
   if (!audio_buffer_->GetEncodedAudioFrame(encoded_frame.get(),
                                            &rtp_timestamp, &next_frame)) {
     // We have no audio frames. Wait for new packet(s).
     VLOG(1) << "Wait for more audio packets in frame";
     queued_encoded_callbacks_.push_back(callback);
     return;
   }
   if (decryptor_ && !DecryptAudioFrame(&encoded_frame)) {
     // Logging already done.
     queued_encoded_callbacks_.push_back(callback);
     return;
   }
   if (!PostEncodedAudioFrame(callback, rtp_timestamp, next_frame,
                              &encoded_frame)) {
     // We have an audio frame; however we are missing packets and we have time
     // to wait for new packet(s).
     queued_encoded_callbacks_.push_back(callback);
   }
 }
 
 bool AudioReceiver::PostEncodedAudioFrame(
     const AudioFrameEncodedCallback& callback,
     uint32 rtp_timestamp,
     bool next_frame,
-    scoped_ptr<EncodedAudioFrame>* encoded_frame) {
+    scoped_ptr<transport::EncodedAudioFrame>* encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(audio_buffer_) << "Invalid function call in this configuration";
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   base::TimeTicks playout_time = GetPlayoutTime(now, rtp_timestamp);
   base::TimeDelta time_until_playout = playout_time - now;
   base::TimeDelta min_wait_delta =
       base::TimeDelta::FromMilliseconds(kMaxAudioFrameWaitMs);
 
   if (!next_frame && (time_until_playout  > min_wait_delta)) {
@@ skipping 63 matching lines @@
         rtp_timestamp_in_ticks + time_offset_ + target_delay_delta_ : now;
   }
   // Don't allow the playout time to go backwards.
   if (last_playout_time_ > playout_time)
      playout_time = last_playout_time_;
   last_playout_time_ = playout_time;
   return playout_time;
 }
 
 bool AudioReceiver::DecryptAudioFrame(
-    scoped_ptr<EncodedAudioFrame>* audio_frame) {
+    scoped_ptr<transport::EncodedAudioFrame>* audio_frame) {
   DCHECK(decryptor_) << "Invalid state";
 
   if (!decryptor_->SetCounter(GetAesNonce((*audio_frame)->frame_id,
                                           iv_mask_))) {
     NOTREACHED() << "Failed to set counter";
     return false;
   }
   std::string decrypted_audio_data;
   if (!decryptor_->Decrypt((*audio_frame)->data, &decrypted_audio_data)) {
     VLOG(0) << "Decryption error";
@@ skipping 55 matching lines @@
   }
   if (audio_decoder_) {
     // Will only send a message if it is time.
     audio_decoder_->SendCastMessage();
   }
   ScheduleNextCastMessage();
 }
 
 }  // namespace cast
 }  // namespace media