Cast: Refactoring Cast API's

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 166 matching lines @@
   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::SingleThreadTaskRunner> thread_proxy,
               base::TickClock* clock,
               const VideoSenderConfig& video_config,
-              FrameInput* frame_input)
+              scoped_refptr<AudioFrameInput> audio_frame_input,
+              scoped_refptr<VideoFrameInput> video_frame_input)
       : test_app_thread_proxy_(thread_proxy),
         video_config_(video_config),
         audio_diff_(kFrameTimerMs),
-        frame_input_(frame_input),
+        audio_frame_input_(audio_frame_input),
+        video_frame_input_(video_frame_input),
         synthetic_count_(0),
         clock_(clock),
         start_time_(),
         send_time_(),
         weak_factory_(this) {
     audio_bus_factory_.reset(new TestAudioBusFactory(kAudioChannels,
                                                      kAudioSamplingFrequency,
                                                      kSoundFrequency,
                                                      kSoundVolume));
     if (ReadFromFile()) {
@@ skipping 15 matching lines @@
 
   void SendFrame() {
     // Make sure that we don't drift.
     int num_10ms_blocks = audio_diff_ / 10;
     // Avoid drift.
     audio_diff_ += kFrameTimerMs - num_10ms_blocks * 10;
 
     scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
         base::TimeDelta::FromMilliseconds(10) * num_10ms_blocks));
     AudioBus* const audio_bus_ptr = audio_bus.get();
-    frame_input_->InsertAudio(
+    audio_frame_input_->InsertAudio(
         audio_bus_ptr,
         clock_->NowTicks(),
         base::Bind(&OwnThatAudioBus, base::Passed(&audio_bus)));
 
     gfx::Size size(video_config_.width, video_config_.height);
     // TODO(mikhal): Use the provided timestamp.
     if (start_time_.is_null())
       start_time_ = clock_->NowTicks();
     base::TimeDelta time_diff = clock_->NowTicks() - start_time_;
     scoped_refptr<media::VideoFrame> video_frame =
@@ skipping 11 matching lines @@
     // Sleep if that time has yet to elapse.
     base::TimeTicks now = clock_->NowTicks();
     base::TimeDelta video_frame_time =
         base::TimeDelta::FromMilliseconds(kFrameTimerMs);
     base::TimeDelta elapsed_time = now - send_time_;
     if (elapsed_time < video_frame_time) {
       VLOG(1) << "Wait" << (video_frame_time - elapsed_time).InMilliseconds();
       test_app_thread_proxy_->PostDelayedTask(
           FROM_HERE,
           base::Bind(&SendProcess::SendVideoFrameOnTime,
-                     base::Unretained(this),
+                     weak_factory_.GetWeakPtr(),
                      video_frame),
           video_frame_time - elapsed_time);
     } else {
       test_app_thread_proxy_->PostTask(
           FROM_HERE,
           base::Bind(&SendProcess::SendVideoFrameOnTime,
-                     base::Unretained(this),
+                     weak_factory_.GetWeakPtr(),
                      video_frame));
     }
   }
 
   void SendVideoFrameOnTime(scoped_refptr<media::VideoFrame> video_frame) {
     send_time_ = clock_->NowTicks();
-    frame_input_->InsertRawVideoFrame(video_frame, send_time_);
+    video_frame_input_->InsertRawVideoFrame(video_frame, send_time_);
     test_app_thread_proxy_->PostTask(
         FROM_HERE, base::Bind(&SendProcess::SendFrame, base::Unretained(this)));
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> test_app_thread_proxy_;
   const VideoSenderConfig video_config_;
   int audio_diff_;
-  const scoped_refptr<FrameInput> frame_input_;
+  const scoped_refptr<AudioFrameInput> audio_frame_input_;
+  const scoped_refptr<VideoFrameInput> video_frame_input_;
   FILE* video_file_;
   uint8 synthetic_count_;
   base::TickClock* const clock_;  // Not owned by this class.
   base::TimeTicks start_time_;
   base::TimeTicks send_time_;
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
   base::WeakPtrFactory<SendProcess> weak_factory_;
 };
 
 }  // namespace cast
 }  // namespace media
 
 namespace {
 void UpdateCastTransportStatus(
     media::cast::transport::CastTransportStatus status) {}
 
 void InitializationResult(media::cast::CastInitializationStatus result) {
-  CHECK_EQ(result, media::cast::STATUS_INITIALIZED);
-  VLOG(1) << "Cast Sender initialized";
+  bool end_result = result == media::cast::STATUS_AUDIO_INITIALIZED ||
+                    result == media::cast::STATUS_VIDEO_INITIALIZED;
+  CHECK(end_result);
 }
 
 net::IPEndPoint CreateUDPAddress(std::string ip_str, int port) {
   net::IPAddressNumber ip_number;
   CHECK(net::ParseIPLiteralToNumber(ip_str, &ip_number));
   return net::IPEndPoint(ip_number, port);
 }
 
 }  // namespace
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
-  VLOG(1) << "Cast Sender";
   base::Thread test_thread("Cast sender test app thread");
   base::Thread audio_thread("Cast audio encoder thread");
   base::Thread video_thread("Cast video encoder thread");
   test_thread.Start();
   audio_thread.Start();
   video_thread.Start();
 
   scoped_ptr<base::TickClock> clock(new base::DefaultTickClock());
   base::MessageLoopForIO io_message_loop;
 
@@ skipping 10 matching lines @@
 
   // Setting up transport config.
   media::cast::transport::CastTransportConfig config;
   config.receiver_endpoint = CreateUDPAddress(remote_ip_address, remote_port);
   config.local_endpoint = CreateUDPAddress("0.0.0.0", 0);
   config.audio_ssrc = audio_config.sender_ssrc;
   config.video_ssrc = video_config.sender_ssrc;
   config.audio_rtp_config = audio_config.rtp_config;
   config.video_rtp_config = video_config.rtp_config;
 
-  scoped_ptr<media::cast::transport::CastTransportSender> transport_sender(
-      media::cast::transport::CastTransportSender::CreateCastTransportSender(
+  scoped_ptr<media::cast::transport::CastTransportSender> transport_sender =
+      media::cast::transport::CastTransportSender::Create(
           clock.get(),
           config,
           base::Bind(&UpdateCastTransportStatus),
-          io_message_loop.message_loop_proxy()));
+          io_message_loop.message_loop_proxy());
 
   // Enable main and send side threads only. Disable logging.
   // Running transport on the main thread.
   scoped_refptr<media::cast::CastEnvironment> cast_environment(
       new media::cast::CastEnvironment(
           clock.Pass(),
           io_message_loop.message_loop_proxy(),
           audio_thread.message_loop_proxy(),
           NULL,
           video_thread.message_loop_proxy(),
           NULL,
           io_message_loop.message_loop_proxy(),
           media::cast::GetDefaultCastSenderLoggingConfig()));
 
-  scoped_ptr<media::cast::CastSender> cast_sender(
-      media::cast::CastSender::CreateCastSender(
-          cast_environment,
-          &audio_config,
-          &video_config,
-          NULL,  // gpu_factories.
-          base::Bind(&InitializationResult),
-          transport_sender.get()));
+  scoped_ptr<media::cast::CastSender> cast_sender =
+      media::cast::CastSender::Create(cast_environment,
+                                      base::Bind(&InitializationResult),
+                                      transport_sender.get());
+
+  cast_sender->InitializeVideo(video_config, NULL);
+  cast_sender->InitializeAudio(audio_config);
 
   transport_sender->SetPacketReceiver(cast_sender->packet_receiver());
 
-  media::cast::FrameInput* frame_input = cast_sender->frame_input();
+  scoped_refptr<media::cast::AudioFrameInput> audio_frame_input =
+      cast_sender->audio_frame_input();
+  scoped_refptr<media::cast::VideoFrameInput> video_frame_input =
+      cast_sender->video_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));
+                                   audio_frame_input,
+                                   video_frame_input));
 
   test_thread.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&media::cast::SendProcess::SendFrame,
                  base::Unretained(send_process.get())));
 
   io_message_loop.Run();
   return 0;
 }