Cast:Adding cast_transport_config and cleaning up

media/cast/test/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.
 
 // Test application that simulates a cast sender - Data can be either generated
 // or read from a file.
 
 #include "base/at_exit.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 110 matching lines @@
   GetSsrcs(&audio_config);
   GetPayloadtype(&audio_config);
 
   audio_config.rtcp_c_name = "audio_sender@a.b.c.d";
 
   VLOG(0) << "Using OPUS 48Khz stereo at 64kbit/s";
   audio_config.use_external_encoder = false;
   audio_config.frequency = kAudioSamplingFrequency;
   audio_config.channels = kAudioChannels;
   audio_config.bitrate = 64000;
-  audio_config.codec = kOpus;
+  audio_config.codec = transport::kOpus;
   return audio_config;
 }
 
 void GetPayloadtype(VideoSenderConfig* video_config) {
   test::InputBuilder input("Choose video sender payload type.",
       DEFAULT_VIDEO_PAYLOAD_TYPE, 96, 127);
   video_config->rtp_payload_type = input.GetIntInput();
 }
 
 void GetVideoCodecSize(VideoSenderConfig* video_config) {
@@ skipping 29 matching lines @@
   GetVideoBitrates(&video_config);
 
   video_config.rtcp_c_name = "video_sender@a.b.c.d";
 
   video_config.use_external_encoder = false;
 
   VLOG(0) << "Using VP8 at 30 fps";
   video_config.min_qp = 4;
   video_config.max_qp = 40;
   video_config.max_frame_rate = 30;
-  video_config.codec = kVp8;
+  video_config.codec = transport::kVp8;
   video_config.max_number_of_video_buffers_used = 1;
   video_config.number_of_cores = 1;
   return video_config;
 }
 
 class SendProcess {
  public:
   SendProcess(scoped_refptr<base::TaskRunner> thread_proxy,
               base::TickClock* clock,
               const VideoSenderConfig& video_config,
@@ skipping 116 matching lines @@
 
   // Enable main and send side threads only. Disable logging.
   scoped_refptr<media::cast::CastEnvironment> cast_environment(new
       media::cast::CastEnvironment(
       &clock,
       main_thread.message_loop_proxy(),
       audio_thread.message_loop_proxy(),
       NULL,
       video_thread.message_loop_proxy(),
       NULL,
+      main_thread.message_loop_proxy(),
       media::cast::GetDefaultCastLoggingConfig()));
 
   media::cast::AudioSenderConfig audio_config =
       media::cast::GetAudioSenderConfig();
   media::cast::VideoSenderConfig video_config =
       media::cast::GetVideoSenderConfig();
 
   scoped_ptr<media::cast::transport::Transport> transport(
       new media::cast::transport::Transport(
       io_message_loop.message_loop_proxy()));
   scoped_ptr<media::cast::CastSender> cast_sender(
       media::cast::CastSender::CreateCastSender(cast_environment,
       audio_config,
       video_config,
       NULL,  // VideoEncoderController.
       transport->packet_sender()));
 
-  media::cast::PacketReceiver* packet_receiver = cast_sender->packet_receiver();
+  media::cast::transport::PacketReceiver* packet_receiver =
+      cast_sender->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);
 
   media::cast::FrameInput* frame_input = cast_sender->frame_input();
   scoped_ptr<media::cast::SendProcess> send_process(new
       media::cast::SendProcess(test_thread.message_loop_proxy(),
                                cast_environment->Clock(),
                                video_config,
                                frame_input));
 
   send_process->SendFrame();
   io_message_loop.Run();
   transport->StopReceiving();
   return 0;
 }