Revert of Cast:Adding cast_transport_config and cleaning up

media/cast/audio_receiver/audio_decoder.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 "base/logging.h"
 #include "media/cast/audio_receiver/audio_decoder.h"
 
 #include "third_party/webrtc/modules/audio_coding/main/interface/audio_coding_module.h"
 #include "third_party/webrtc/modules/interface/module_common_types.h"
 
 namespace media {
 namespace cast {
 
 AudioDecoder::AudioDecoder(scoped_refptr<CastEnvironment> cast_environment,
                            const AudioReceiverConfig& audio_config,
                            RtpPayloadFeedback* incoming_payload_feedback)
     : cast_environment_(cast_environment),
       audio_decoder_(webrtc::AudioCodingModule::Create(0)),
       cast_message_builder_(cast_environment->Clock(),
           incoming_payload_feedback, &frame_id_map_, audio_config.incoming_ssrc,
           true, 0),
       have_received_packets_(false),
       last_played_out_timestamp_(0) {
   audio_decoder_->InitializeReceiver();
 
   webrtc::CodecInst receive_codec;
   switch (audio_config.codec) {
-    case transport::kPcm16:
+    case kPcm16:
       receive_codec.pltype = audio_config.rtp_payload_type;
       strncpy(receive_codec.plname, "L16", 4);
       receive_codec.plfreq = audio_config.frequency;
       receive_codec.pacsize = -1;
       receive_codec.channels = audio_config.channels;
       receive_codec.rate = -1;
       break;
-    case transport::kOpus:
+    case kOpus:
       receive_codec.pltype = audio_config.rtp_payload_type;
       strncpy(receive_codec.plname, "opus", 5);
       receive_codec.plfreq = audio_config.frequency;
       receive_codec.pacsize = -1;
       receive_codec.channels = audio_config.channels;
       receive_codec.rate = -1;
       break;
-    case transport::kExternalAudio:
+    case kExternalAudio:
       NOTREACHED() << "Codec must be specified for audio decoder";
       break;
   }
   if (audio_decoder_->RegisterReceiveCodec(receive_codec) != 0) {
     NOTREACHED() << "Failed to register receive codec";
   }
 
   audio_decoder_->SetMaximumPlayoutDelay(audio_config.rtp_max_delay_ms);
   audio_decoder_->SetPlayoutMode(webrtc::streaming);
 }
@@ skipping 47 matching lines @@
         &webrtc_audio_frame.data_[0],
         &webrtc_audio_frame.data_[samples_per_10ms * audio_frame->channels]);
   }
   return true;
 }
 
 void AudioDecoder::IncomingParsedRtpPacket(const uint8* payload_data,
                                            size_t payload_size,
                                            const RtpCastHeader& rtp_header) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  DCHECK_LE(payload_size, kMaxIpPacketSize);
+  DCHECK_LE(payload_size, kIpPacketSize);
   audio_decoder_->IncomingPacket(payload_data, static_cast<int32>(payload_size),
                                  rtp_header.webrtc);
   lock_.Acquire();
   have_received_packets_ = true;
   uint32 last_played_out_timestamp = last_played_out_timestamp_;
   lock_.Release();
 
   PacketType packet_type = frame_id_map_.InsertPacket(rtp_header);
   if (packet_type != kNewPacketCompletingFrame) return;
 
@@ skipping 28 matching lines @@
   return cast_message_builder_.TimeToSendNextCastMessage(time_to_send);
 }
 
 void AudioDecoder::SendCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   cast_message_builder_.UpdateCastMessage();
 }
 
 }  // namespace cast
 }  // namespace media