Simplify interface for media/cast: CastTransportSenderImpl

media/cast/test/cast_benchmarks.cc

 // Copyright 2014 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.
 //
 // This program benchmarks the theoretical throughput of the cast library.
 // It runs using a fake clock, simulated network and fake codecs. This allows
 // tests to run much faster than real time.
 // To run the program, run:
 // $ ./out/Release/cast_benchmarks | tee benchmarkoutput.asc
 // This may take a while, when it is done, you can view the data with
@@ skipping 53 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 static const int64_t kStartMillisecond = INT64_C(1245);
 static const int kTargetPlayoutDelayMs = 400;
 
-void UpdateCastTransportStatus(CastTransportStatus status) {
-  bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
-                 status == TRANSPORT_VIDEO_INITIALIZED);
-  EXPECT_TRUE(result);
-}
-
 void ExpectVideoSuccess(OperationalStatus status) {
   EXPECT_EQ(STATUS_INITIALIZED, status);
 }
 
 void ExpectAudioSuccess(OperationalStatus status) {
   EXPECT_EQ(STATUS_INITIALIZED, status);
 }
 
-void IgnoreRawEvents(scoped_ptr<std::vector<FrameEvent>> frame_events,
-                     scoped_ptr<std::vector<PacketEvent>> packet_events) {}
-
 }  // namespace
 
 // Wraps a CastTransportSender and records some statistics about
 // the data that goes through it.
 class CastTransportSenderWrapper : public CastTransportSender {
  public:
   // Takes ownership of |transport|.
   void Init(CastTransportSender* transport,
             uint64_t* encoded_video_bytes,
             uint64_t* encoded_audio_bytes) {
@@ skipping 60 matching lines @@
       const RtpReceiverStatistics* rtp_receiver_statistics) final {
     return transport_->SendRtcpFromRtpReceiver(ssrc,
                                                sender_ssrc,
                                                time_data,
                                                cast_message,
                                                target_delay,
                                                rtcp_events,
                                                rtp_receiver_statistics);
   }
 
+  void SetOptions(const base::DictionaryValue& options) final {}
+
  private:
   scoped_ptr<CastTransportSender> transport_;
   uint32_t audio_ssrc_, video_ssrc_;
   uint64_t* encoded_video_bytes_;
   uint64_t* encoded_audio_bytes_;
 };
 
 struct MeasuringPoint {
   MeasuringPoint(double bitrate_, double latency_, double percent_packet_drop_)
       : bitrate(bitrate_),
@@ skipping 32 matching lines @@
         cast_environment_sender_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_sender_),
             task_runner_sender_,
             task_runner_sender_,
             task_runner_sender_)),
         cast_environment_receiver_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_receiver_),
             task_runner_receiver_,
             task_runner_receiver_,
             task_runner_receiver_)),
-        receiver_to_sender_(cast_environment_receiver_),
-        sender_to_receiver_(cast_environment_sender_),
         video_bytes_encoded_(0),
         audio_bytes_encoded_(0),
         frames_sent_(0) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
   void Configure(Codec video_codec,
                  Codec audio_codec) {
     audio_sender_config_ = GetDefaultAudioSenderConfig();
@@ skipping 27 matching lines @@
   void SetSenderClockSkew(double skew, base::TimeDelta offset) {
     testing_clock_sender_->SetSkew(skew, offset);
     task_runner_sender_->SetSkew(1.0 / skew);
   }
 
   void SetReceiverClockSkew(double skew, base::TimeDelta offset) {
     testing_clock_receiver_->SetSkew(skew, offset);
     task_runner_receiver_->SetSkew(1.0 / skew);
   }
 
-  void Create(const MeasuringPoint& p) {
-    net::IPEndPoint dummy_endpoint;
-    transport_sender_.Init(
-        new CastTransportSenderImpl(
-            NULL,
-            testing_clock_sender_,
-            dummy_endpoint,
-            dummy_endpoint,
-            make_scoped_ptr(new base::DictionaryValue),
-            base::Bind(&UpdateCastTransportStatus),
-            base::Bind(&IgnoreRawEvents),
-            base::TimeDelta::FromSeconds(1),
-            task_runner_sender_,
-            PacketReceiverCallback(),
-            &sender_to_receiver_),
-        &video_bytes_encoded_,
-        &audio_bytes_encoded_);
-
-    transport_receiver_.reset(
-        new CastTransportSenderImpl(
-            NULL,
-            testing_clock_receiver_,
-            dummy_endpoint,
-            dummy_endpoint,
-            make_scoped_ptr(new base::DictionaryValue),
-            base::Bind(&UpdateCastTransportStatus),
-            base::Bind(&IgnoreRawEvents),
-            base::TimeDelta::FromSeconds(1),
-            task_runner_receiver_,
-            base::Bind(&RunOneBenchmark::ReceivePacket, base::Unretained(this)),
-            &receiver_to_sender_));
-
-    cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
-                                          audio_receiver_config_,
-                                          video_receiver_config_,
-                                          transport_receiver_.get());
-
-    cast_sender_ =
-        CastSender::Create(cast_environment_sender_, &transport_sender_);
-
-    cast_sender_->InitializeAudio(
-        audio_sender_config_,
-        base::Bind(&ExpectAudioSuccess));
-    cast_sender_->InitializeVideo(
-        video_sender_config_,
-        base::Bind(&ExpectVideoSuccess),
-        CreateDefaultVideoEncodeAcceleratorCallback(),
-        CreateDefaultVideoEncodeMemoryCallback());
-
-    receiver_to_sender_.Initialize(CreateSimplePipe(p),
-                                   transport_sender_.PacketReceiverForTesting(),
-                                   task_runner_, &testing_clock_);
-    sender_to_receiver_.Initialize(
-        CreateSimplePipe(p), transport_receiver_->PacketReceiverForTesting(),
-        task_runner_, &testing_clock_);
-
-    task_runner_->RunTasks();
-  }
+  void Create(const MeasuringPoint& p);
 
   void ReceivePacket(scoped_ptr<Packet> packet) {
     cast_receiver_->ReceivePacket(std::move(packet));
   }
 
   virtual ~RunOneBenchmark() {
     cast_sender_.reset();
     cast_receiver_.reset();
     task_runner_->RunTasks();
   }
@@ skipping 137 matching lines @@
   test::SkewedTickClock* testing_clock_sender_;
   scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_sender_;
 
   // These run on the receiver timeline.
   test::SkewedTickClock* testing_clock_receiver_;
   scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_receiver_;
 
   scoped_refptr<CastEnvironment> cast_environment_sender_;
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
-  LoopBackTransport receiver_to_sender_;
-  LoopBackTransport sender_to_receiver_;
+  LoopBackTransport* receiver_to_sender_;  // Owned by CastTransportSenderImpl.
+  LoopBackTransport* sender_to_receiver_;  // Owned by CastTransportSenderImpl.
   CastTransportSenderWrapper transport_sender_;
   scoped_ptr<CastTransportSender> transport_receiver_;
   uint64_t video_bytes_encoded_;
   uint64_t audio_bytes_encoded_;
 
   scoped_ptr<CastReceiver> cast_receiver_;
   scoped_ptr<CastSender> cast_sender_;
 
   int frames_sent_;
   base::TimeDelta frame_duration_;
   double available_bitrate_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_;
 };
 
+namespace {
+
+class TransportClient : public CastTransportSender::Client {
+ public:
+  explicit TransportClient(RunOneBenchmark* run_one_benchmark)
+      : run_one_benchmark_(run_one_benchmark) {}
+
+  void OnStatusChanged(CastTransportStatus status) final {
+    bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
+                   status == TRANSPORT_VIDEO_INITIALIZED);
+    EXPECT_TRUE(result);
+  };
+  void OnLoggingEventsReceived(
+      scoped_ptr<std::vector<FrameEvent>> frame_events,
+      scoped_ptr<std::vector<PacketEvent>> packet_events) final{};
+  void ProcessRtpPacket(scoped_ptr<Packet> packet) final {
+    if (run_one_benchmark_)
+      run_one_benchmark_->ReceivePacket(std::move(packet));
+  };
+
+ private:
+  RunOneBenchmark* const run_one_benchmark_;
+
+  DISALLOW_COPY_AND_ASSIGN(TransportClient);
+};
+
+}  // namepspace
+
+void RunOneBenchmark::Create(const MeasuringPoint& p) {
+  sender_to_receiver_ = new LoopBackTransport(cast_environment_sender_);
+  transport_sender_.Init(
+      new CastTransportSenderImpl(
+          testing_clock_sender_, base::TimeDelta::FromSeconds(1),
+          make_scoped_ptr(new TransportClient(nullptr)),
+          make_scoped_ptr(sender_to_receiver_), task_runner_sender_),
+      &video_bytes_encoded_, &audio_bytes_encoded_);
+
+  receiver_to_sender_ = new LoopBackTransport(cast_environment_receiver_);
+  transport_receiver_.reset(new CastTransportSenderImpl(
+      testing_clock_receiver_, base::TimeDelta::FromSeconds(1),
+      make_scoped_ptr(new TransportClient(this)),
+      make_scoped_ptr(receiver_to_sender_), task_runner_receiver_));
+
+  cast_receiver_ =
+      CastReceiver::Create(cast_environment_receiver_, audio_receiver_config_,
+                           video_receiver_config_, transport_receiver_.get());
+
+  cast_sender_ =
+      CastSender::Create(cast_environment_sender_, &transport_sender_);
+
+  cast_sender_->InitializeAudio(audio_sender_config_,
+                                base::Bind(&ExpectAudioSuccess));
+  cast_sender_->InitializeVideo(video_sender_config_,
+                                base::Bind(&ExpectVideoSuccess),
+                                CreateDefaultVideoEncodeAcceleratorCallback(),
+                                CreateDefaultVideoEncodeMemoryCallback());
+
+  receiver_to_sender_->Initialize(CreateSimplePipe(p),
+                                  transport_sender_.PacketReceiverForTesting(),
+                                  task_runner_, &testing_clock_);
+  sender_to_receiver_->Initialize(
+      CreateSimplePipe(p), transport_receiver_->PacketReceiverForTesting(),
+      task_runner_, &testing_clock_);
+
+  task_runner_->RunTasks();
+}
+
 enum CacheResult { FOUND_TRUE, FOUND_FALSE, NOT_FOUND };
 
 template <class T>
 class BenchmarkCache {
  public:
   CacheResult Lookup(const T& x) {
     base::AutoLock key(lock_);
     for (size_t i = 0; i < results_.size(); i++) {
       if (results_[i].second) {
         if (x <= results_[i].first) {
@@ skipping 203 matching lines @@
   media::cast::CastBenchmark benchmark;
   if (getenv("PROFILE_FILE")) {
     std::string profile_file(getenv("PROFILE_FILE"));
     base::debug::StartProfiling(profile_file);
     benchmark.Run();
     base::debug::StopProfiling();
   } else {
     benchmark.Run();
   }
 }