[Cast] Clean-up: Merge AudioReceiverConfig+VideoReceiverConfig-->FrameReceiverConfig.

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 <deque>
 #include <map>
@@ skipping 68 matching lines @@
   test::InputBuilder input(display_text, DEFAULT_SEND_IP, INT_MIN, INT_MAX);
   std::string ip_address = input.GetStringInput();
   // Ensure IP address is either the default value or in correct form.
   while (ip_address != DEFAULT_SEND_IP &&
          std::count(ip_address.begin(), ip_address.end(), '.') != 3) {
     ip_address = input.GetStringInput();
   }
   return ip_address;
 }
 
-void GetSsrcs(AudioReceiverConfig* audio_config) {
+void GetAudioSsrcs(FrameReceiverConfig* audio_config) {
   test::InputBuilder input_tx(
       "Choose audio sender SSRC.", DEFAULT_AUDIO_FEEDBACK_SSRC, 1, INT_MAX);
   audio_config->feedback_ssrc = input_tx.GetIntInput();
 
   test::InputBuilder input_rx(
       "Choose audio receiver SSRC.", DEFAULT_AUDIO_INCOMING_SSRC, 1, INT_MAX);
   audio_config->incoming_ssrc = input_rx.GetIntInput();
 }
 
-void GetSsrcs(VideoReceiverConfig* video_config) {
+void GetVideoSsrcs(FrameReceiverConfig* video_config) {
   test::InputBuilder input_tx(
       "Choose video sender SSRC.", DEFAULT_VIDEO_FEEDBACK_SSRC, 1, INT_MAX);
   video_config->feedback_ssrc = input_tx.GetIntInput();
 
   test::InputBuilder input_rx(
       "Choose video receiver SSRC.", DEFAULT_VIDEO_INCOMING_SSRC, 1, INT_MAX);
   video_config->incoming_ssrc = input_rx.GetIntInput();
 }
 
 #if defined(OS_LINUX)
 void GetWindowSize(int* width, int* height) {
   // Resolution values based on sender settings
   test::InputBuilder input_w(
       "Choose window width.", kVideoWindowWidth, 144, 1920);
   *width = input_w.GetIntInput();
 
   test::InputBuilder input_h(
       "Choose window height.", kVideoWindowHeight, 176, 1080);
   *height = input_h.GetIntInput();
 }
 #endif  // OS_LINUX
 
-void GetPayloadtype(AudioReceiverConfig* audio_config) {
+void GetAudioPayloadtype(FrameReceiverConfig* audio_config) {
   test::InputBuilder input("Choose audio receiver payload type.",
                            DEFAULT_AUDIO_PAYLOAD_TYPE,
                            96,
                            127);
   audio_config->rtp_payload_type = input.GetIntInput();
 }
 
-AudioReceiverConfig GetAudioReceiverConfig() {
-  AudioReceiverConfig audio_config = GetDefaultAudioReceiverConfig();
-  GetSsrcs(&audio_config);
-  GetPayloadtype(&audio_config);
+FrameReceiverConfig GetAudioReceiverConfig() {
+  FrameReceiverConfig audio_config = GetDefaultAudioReceiverConfig();
+  GetAudioSsrcs(&audio_config);
+  GetAudioPayloadtype(&audio_config);
   audio_config.rtp_max_delay_ms = 300;
   return audio_config;
 }
 
-void GetPayloadtype(VideoReceiverConfig* video_config) {
+void GetVideoPayloadtype(FrameReceiverConfig* 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 = GetDefaultVideoReceiverConfig();
-  GetSsrcs(&video_config);
-  GetPayloadtype(&video_config);
+FrameReceiverConfig GetVideoReceiverConfig() {
+  FrameReceiverConfig video_config = GetDefaultVideoReceiverConfig();
+  GetVideoSsrcs(&video_config);
+  GetVideoPayloadtype(&video_config);
   video_config.rtp_max_delay_ms = 300;
   return video_config;
 }
 
-AudioParameters ToAudioParameters(const AudioReceiverConfig& config) {
+AudioParameters ToAudioParameters(const FrameReceiverConfig& config) {
   const int samples_in_10ms = config.frequency / 100;
   return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                          GuessChannelLayout(config.channels),
                          config.frequency, 32, samples_in_10ms);
 }
 
 // An InProcessReceiver that renders video frames to a LinuxOutputWindow and
 // audio frames via Chromium's audio stack.
 //
 // InProcessReceiver pushes audio and video frames to this subclass, and these
@@ skipping 10 matching lines @@
 // 2. It makes no attempt to synchronize the timing of playout of the video
 //    frames with the audio frames.
 // 3. It does nothing to smooth or hide discontinuities in playback due to
 //    timing issues or missing frames.
 class NaivePlayer : public InProcessReceiver,
                     public AudioOutputStream::AudioSourceCallback {
  public:
   NaivePlayer(const scoped_refptr<CastEnvironment>& cast_environment,
               const net::IPEndPoint& local_end_point,
               const net::IPEndPoint& remote_end_point,
-              const AudioReceiverConfig& audio_config,
-              const VideoReceiverConfig& video_config,
+              const FrameReceiverConfig& audio_config,
+              const FrameReceiverConfig& video_config,
               int window_width,
               int window_height)
       : InProcessReceiver(cast_environment,
                           local_end_point,
                           remote_end_point,
                           audio_config,
                           video_config),
         // Maximum age is the duration of 3 video frames.  3 was chosen
         // arbitrarily, but seems to work well.
         max_frame_age_(base::TimeDelta::FromSeconds(1) * 3 /
@@ skipping 349 matching lines @@
 
   scoped_refptr<media::cast::CastEnvironment> cast_environment(
       new media::cast::StandaloneCastEnvironment);
 
   // Start up Chromium audio system.
   media::FakeAudioLogFactory fake_audio_log_factory_;
   const scoped_ptr<media::AudioManager> audio_manager(
       media::AudioManager::Create(&fake_audio_log_factory_));
   CHECK(media::AudioManager::Get());
 
-  media::cast::AudioReceiverConfig audio_config =
+  media::cast::FrameReceiverConfig audio_config =
       media::cast::GetAudioReceiverConfig();
-  media::cast::VideoReceiverConfig video_config =
+  media::cast::FrameReceiverConfig video_config =
       media::cast::GetVideoReceiverConfig();
 
   // Determine local and remote endpoints.
   int remote_port, local_port;
   media::cast::GetPorts(&remote_port, &local_port);
   if (!local_port) {
     LOG(ERROR) << "Invalid local port.";
     return 1;
   }
   std::string remote_ip_address = media::cast::GetIpAddress("Enter remote IP.");
@@ skipping 23 matching lines @@
                                   audio_config,
                                   video_config,
                                   window_width,
                                   window_height);
   player.Start();
 
   base::MessageLoop().Run();  // Run forever (i.e., until SIGTERM).
   NOTREACHED();
   return 0;
 }