Revert of Cast:Adding cast_transport_config and cleaning up

media/cast/test/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 <algorithm>
 #include <climits>
 #include <cstdarg>
 #include <cstdio>
 #include <string>
 
@@ skipping 94 matching lines @@
 
   GetSsrcs(&audio_config);
   GetPayloadtype(&audio_config);
 
   audio_config.rtcp_c_name = "audio_receiver@a.b.c.d";
 
   VLOG(1) << "Using OPUS 48Khz stereo";
   audio_config.use_external_decoder = false;
   audio_config.frequency = 48000;
   audio_config.channels = 2;
-  audio_config.codec = transport::kOpus;
+  audio_config.codec = kOpus;
   return audio_config;
 }
 
 void GetPayloadtype(VideoReceiverConfig* video_config) {
   test::InputBuilder input("Choose video receiver payload type.",
       DEFAULT_VIDEO_PAYLOAD_TYPE, 96, 127);
   video_config->rtp_payload_type = input.GetIntInput();
 }
 
 VideoReceiverConfig GetVideoReceiverConfig() {
   VideoReceiverConfig video_config;
 
   GetSsrcs(&video_config);
   GetPayloadtype(&video_config);
 
   video_config.rtcp_c_name = "video_receiver@a.b.c.d";
 
   video_config.use_external_decoder = false;
 
   VLOG(1) << "Using VP8";
-  video_config.codec = transport::kVp8;
+  video_config.codec = kVp8;
   return video_config;
 }
 
 
 class ReceiveProcess : public base::RefCountedThreadSafe<ReceiveProcess> {
  public:
   explicit ReceiveProcess(scoped_refptr<FrameReceiver> frame_receiver)
     : frame_receiver_(frame_receiver),
 #if defined(OS_LINUX)
       render_(0, 0, kVideoWindowWidth, kVideoWindowHeight, "Cast_receiver"),
@@ skipping 78 matching lines @@
 
   base::DefaultTickClock clock;
   // Enable receiver side threads, and disable logging.
   scoped_refptr<media::cast::CastEnvironment> cast_environment(new
       media::cast::CastEnvironment(&clock,
                                    main_thread.message_loop_proxy(),
                                    NULL,
                                    audio_thread.message_loop_proxy(),
                                    NULL,
                                    video_thread.message_loop_proxy(),
-                                   main_thread.message_loop_proxy(),
                                    media::cast::GetDefaultCastLoggingConfig()));
 
   media::cast::AudioReceiverConfig audio_config =
       media::cast::GetAudioReceiverConfig();
   media::cast::VideoReceiverConfig video_config =
       media::cast::GetVideoReceiverConfig();
 
   scoped_ptr<media::cast::transport::Transport> transport(
       new media::cast::transport::Transport(
       main_message_loop.message_loop_proxy()));
   scoped_ptr<media::cast::CastReceiver> cast_receiver(
       media::cast::CastReceiver::CreateCastReceiver(
       cast_environment,
       audio_config,
       video_config,
       transport->packet_sender()));
 
-  media::cast::transport::PacketReceiver* packet_receiver =
+  media::cast::PacketReceiver* packet_receiver =
       cast_receiver->packet_receiver();
 
   int send_to_port, receive_port;
   media::cast::GetPorts(&send_to_port, &receive_port);
   std::string ip_address = media::cast::GetIpAddress("Enter destination IP.");
   std::string local_ip_address = media::cast::GetIpAddress("Enter local IP.");
   transport->SetLocalReceiver(packet_receiver, ip_address, local_ip_address,
                               receive_port);
   transport->SetSendDestination(ip_address, send_to_port);
 
   scoped_refptr<media::cast::ReceiveProcess> receive_process(
       new media::cast::ReceiveProcess(cast_receiver->frame_receiver()));
   receive_process->Start();
   main_message_loop.Run();
   transport->StopReceiving();
   return 0;
 }