Simplify interface for media/cast: CastTransportSenderImpl

media/cast/test/simulator.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.
 
 // Simulate end to end streaming.
 //
 // Input:
 // --source=
 //   WebM used as the source of video and audio frames.
 // --output=
@@ skipping 96 matching lines @@
   const std::string as_str =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switch_name);
   if (as_str.empty())
     return default_value;
   int as_int;
   CHECK(base::StringToInt(as_str, &as_int));
   CHECK_GT(as_int, 0);
   return as_int;
 }
 
-void UpdateCastTransportStatus(CastTransportStatus status) {
-  LOG(INFO) << "Cast transport status: " << status;
-}
-
 void LogAudioOperationalStatus(OperationalStatus status) {
   LOG(INFO) << "Audio status: " << status;
 }
 
 void LogVideoOperationalStatus(OperationalStatus status) {
   LOG(INFO) << "Video status: " << status;
 }
 
+struct PacketProxy {
+  PacketProxy() : receiver(NULL) {}
+  void ReceivePacket(scoped_ptr<Packet> packet) {
+    if (receiver)
+      receiver->ReceivePacket(std::move(packet));
+  }
+  CastReceiver* receiver;
+};
+
+class TransportClient : public CastTransportSender::Client {
+ public:
+  TransportClient(LogEventDispatcher* log_event_dispatcher,
+                  PacketProxy* packet_proxy)
+      : log_event_dispatcher_(log_event_dispatcher),
+        packet_proxy_(packet_proxy) {}
+
+  void OnStatusChanged(CastTransportStatus status) final {
+    LOG(INFO) << "Cast transport status: " << status;
+  };
+  void OnLoggingEventsReceived(
+      scoped_ptr<std::vector<FrameEvent>> frame_events,
+      scoped_ptr<std::vector<PacketEvent>> packet_events) final {
+    DCHECK(log_event_dispatcher_);
+    log_event_dispatcher_->DispatchBatchOfEvents(std::move(frame_events),
+                                                 std::move(packet_events));
+  };
+  void ProcessRtpPacket(scoped_ptr<Packet> packet) final {
+    if (packet_proxy_)
+      packet_proxy_->ReceivePacket(std::move(packet));
+  };
+
+ private:
+  LogEventDispatcher* const log_event_dispatcher_;  // Not owned by this class.
+  PacketProxy* const packet_proxy_;                 // Not owned by this class.
+
+  DISALLOW_COPY_AND_ASSIGN(TransportClient);
+};
+
 // Maintains a queue of encoded video frames.
 // This works by tracking FRAME_CAPTURE_END and FRAME_ENCODED events.
 // If a video frame is detected to be encoded it transfers a frame
 // from FakeMediaSource to its internal queue. Otherwise it drops a
 // frame from FakeMediaSource.
 class EncodedVideoFrameTracker : public RawEventSubscriber {
  public:
   EncodedVideoFrameTracker(FakeMediaSource* media_source)
       : media_source_(media_source),
         last_frame_event_type_(UNKNOWN) {}
@@ skipping 199 matching lines @@
       video_sender_config.max_playout_delay =
           audio_sender_config.max_playout_delay;
   video_sender_config.max_frame_rate = GetIntegerSwitchValue(kMaxFrameRate, 30);
 
   // Video receiver config.
   FrameReceiverConfig video_receiver_config =
       GetDefaultVideoReceiverConfig();
   video_receiver_config.rtp_max_delay_ms =
       video_sender_config.max_playout_delay.InMilliseconds();
 
-  // Loopback transport.
-  LoopBackTransport receiver_to_sender(receiver_env);
-  LoopBackTransport sender_to_receiver(sender_env);
-
-  struct PacketProxy {
-    PacketProxy() : receiver(NULL) {}
-    void ReceivePacket(scoped_ptr<Packet> packet) {
-      if (receiver)
-        receiver->ReceivePacket(std::move(packet));
-    }
-    CastReceiver* receiver;
-  };
+  // Loopback transport. Owned by CastTransportSender.
+  LoopBackTransport* receiver_to_sender = new LoopBackTransport(receiver_env);
+  LoopBackTransport* sender_to_receiver = new LoopBackTransport(sender_env);
 
   PacketProxy packet_proxy;
 
   // Cast receiver.
   scoped_ptr<CastTransportSender> transport_receiver(
       new CastTransportSenderImpl(
-          nullptr, &testing_clock, net::IPEndPoint(), net::IPEndPoint(),
-          make_scoped_ptr(new base::DictionaryValue),
-          base::Bind(&UpdateCastTransportStatus),
-          base::Bind(&LogEventDispatcher::DispatchBatchOfEvents,
-                     base::Unretained(receiver_env->logger())),
-          base::TimeDelta::FromSeconds(1), task_runner,
-          base::Bind(&PacketProxy::ReceivePacket,
-                     base::Unretained(&packet_proxy)),
-          &receiver_to_sender));
+          &testing_clock, base::TimeDelta::FromSeconds(1),
+          make_scoped_ptr(
+              new TransportClient(receiver_env->logger(), &packet_proxy)),
+          make_scoped_ptr(receiver_to_sender), task_runner));
   scoped_ptr<CastReceiver> cast_receiver(
       CastReceiver::Create(receiver_env,
                            audio_receiver_config,
                            video_receiver_config,
                            transport_receiver.get()));
 
   packet_proxy.receiver = cast_receiver.get();
 
   // Cast sender and transport sender.
   scoped_ptr<CastTransportSender> transport_sender(new CastTransportSenderImpl(
-      nullptr, &testing_clock, net::IPEndPoint(), net::IPEndPoint(),
-      make_scoped_ptr(new base::DictionaryValue),
-      base::Bind(&UpdateCastTransportStatus),
-      base::Bind(&LogEventDispatcher::DispatchBatchOfEvents,
-                 base::Unretained(sender_env->logger())),
-      base::TimeDelta::FromSeconds(1), task_runner, PacketReceiverCallback(),
-      &sender_to_receiver));
+      &testing_clock, base::TimeDelta::FromSeconds(1),
+      make_scoped_ptr(new TransportClient(sender_env->logger(), nullptr)),
+      make_scoped_ptr(sender_to_receiver), task_runner));
   scoped_ptr<CastSender> cast_sender(
       CastSender::Create(sender_env, transport_sender.get()));
 
   // Initialize network simulation model.
   const bool use_network_simulation =
       model.type() == media::cast::proto::INTERRUPTED_POISSON_PROCESS;
   scoped_ptr<test::InterruptedPoissonProcess> ipp;
   if (use_network_simulation) {
     LOG(INFO) << "Running Poisson based network simulation.";
     const IPPModel& ipp_model = model.ipp();
     std::vector<double> average_rates(ipp_model.average_rate_size());
     std::copy(ipp_model.average_rate().begin(),
               ipp_model.average_rate().end(),
               average_rates.begin());
     ipp.reset(new test::InterruptedPoissonProcess(
         average_rates,
         ipp_model.coef_burstiness(), ipp_model.coef_variance(), 0));
-    receiver_to_sender.Initialize(ipp->NewBuffer(128 * 1024),
-                                  transport_sender->PacketReceiverForTesting(),
-                                  task_runner, &testing_clock);
-    sender_to_receiver.Initialize(
+    receiver_to_sender->Initialize(ipp->NewBuffer(128 * 1024),
+                                   transport_sender->PacketReceiverForTesting(),
+                                   task_runner, &testing_clock);
+    sender_to_receiver->Initialize(
         ipp->NewBuffer(128 * 1024),
         transport_receiver->PacketReceiverForTesting(), task_runner,
         &testing_clock);
   } else {
     LOG(INFO) << "No network simulation.";
-    receiver_to_sender.Initialize(
-        scoped_ptr<test::PacketPipe>(),
-        transport_sender->PacketReceiverForTesting(),
-        task_runner, &testing_clock);
-    sender_to_receiver.Initialize(
+    receiver_to_sender->Initialize(scoped_ptr<test::PacketPipe>(),
+                                   transport_sender->PacketReceiverForTesting(),
+                                   task_runner, &testing_clock);
+    sender_to_receiver->Initialize(
         scoped_ptr<test::PacketPipe>(),
         transport_receiver->PacketReceiverForTesting(), task_runner,
         &testing_clock);
   }
 
   // Initialize a fake media source and a tracker to encoded video frames.
   const bool quality_test = !metrics_output_path.empty();
   FakeMediaSource media_source(task_runner,
                                &testing_clock,
                                audio_sender_config,
@@ skipping 285 matching lines @@
   values.SetString("sim-id", sim_id);
 
   std::string extra_data;
   base::JSONWriter::Write(values, &extra_data);
 
   // Run.
   media::cast::RunSimulation(source_path, log_output_path, metrics_output_path,
                              yuv_output_path, extra_data, model);
   return 0;
 }