Simplify interface for media/cast: CastTransportSenderImpl

media/cast/test/simulator.cc

Index: media/cast/test/simulator.cc
diff --git a/media/cast/test/simulator.cc b/media/cast/test/simulator.cc
index a2aa6e45b91b7e84d153ceba5cf4a5e4753660df..78c1ccf661409863d762653937d2239a333e8da6 100644
--- a/media/cast/test/simulator.cc
+++ b/media/cast/test/simulator.cc
@@ -114,10 +114,6 @@ int GetIntegerSwitchValue(const char* switch_name, int default_value) {
   return as_int;
 }
 
-void UpdateCastTransportStatus(CastTransportStatus status) {
-  LOG(INFO) << "Cast transport status: " << status;
-}
-
 void LogAudioOperationalStatus(OperationalStatus status) {
   LOG(INFO) << "Audio status: " << status;
 }
@@ -126,6 +122,44 @@ 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
@@ -345,33 +379,19 @@ void RunSimulation(const base::FilePath& source_path,
   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,
@@ -382,13 +402,9 @@ void RunSimulation(const base::FilePath& source_path,
 
   // 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()));
 
@@ -406,20 +422,19 @@ void RunSimulation(const base::FilePath& source_path,
     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);