Cast: Make receiver use cast_transport

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 369 matching lines @@
   // 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(packet.Pass());

[miu, 2014/12/04 04:18:55]

style nit: Need newline before start of then-clause.

[hubbe, 2014/12/05 23:57:20]

Done.

+    }
+    CastReceiver* receiver;
+  };
+
+  PacketProxy packet_proxy;
+
   // Cast receiver.
+  scoped_ptr<CastTransportSender> transport_receiver(
+      new CastTransportSenderImpl(
+          NULL,
+          &testing_clock,
+          net::IPEndPoint(),
+          net::IPEndPoint(),
+          make_scoped_ptr(new base::DictionaryValue),
+          base::Bind(&UpdateCastTransportStatus),
+          base::Bind(&LogTransportEvents, receiver_env),
+          base::TimeDelta::FromSeconds(1),
+          task_runner,
+          base::Bind(&PacketProxy::ReceivePacket,
+                     base::Unretained(&packet_proxy)),
+          &receiver_to_sender));
   scoped_ptr<CastReceiver> cast_receiver(
       CastReceiver::Create(receiver_env,
                            audio_receiver_config,
                            video_receiver_config,
-                           &receiver_to_sender));
+                           transport_receiver.get()));
+
+  packet_proxy.receiver = cast_receiver.get();
 
   // Cast sender and transport sender.
   scoped_ptr<CastTransportSender> transport_sender(
       new CastTransportSenderImpl(
           NULL,
           &testing_clock,
           net::IPEndPoint(),
+          net::IPEndPoint(),
           make_scoped_ptr(new base::DictionaryValue),
           base::Bind(&UpdateCastTransportStatus),
           base::Bind(&LogTransportEvents, sender_env),
           base::TimeDelta::FromSeconds(1),
           task_runner,
+          PacketReceiverCallback(),
           &sender_to_receiver));
   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).Pass(),
         transport_sender->PacketReceiverForTesting(),
         task_runner, &testing_clock);
     sender_to_receiver.Initialize(
         ipp->NewBuffer(128 * 1024).Pass(),
-        cast_receiver->packet_receiver(), task_runner,
+        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(
         scoped_ptr<test::PacketPipe>(),
-        cast_receiver->packet_receiver(), task_runner,
+        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,
                                video_sender_config,
                                quality_test);
   scoped_ptr<EncodedVideoFrameTracker> video_frame_tracker;
@@ skipping 283 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;
 }