Cast: Update simulator tool with more inputs.

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 28 matching lines @@
 #include "base/threading/thread.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_receiver.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/simple_event_subscriber.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
+#include "media/cast/test/loopback_transport.h"
 #include "media/cast/test/skewed_single_thread_task_runner.h"
 #include "media/cast/test/skewed_tick_clock.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/test_util.h"
 #include "media/cast/test/utility/udp_proxy.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "media/cast/transport/cast_transport_sender.h"
@@ skipping 27 matching lines @@
 
 void VideoInitializationStatus(CastInitializationStatus status) {
   EXPECT_EQ(STATUS_VIDEO_INITIALIZED, status);
 }
 
 void IgnoreRawEvents(const std::vector<PacketEvent>& packet_events) {
 }
 
 }  // namespace
 
-// Shim that turns forwards packets from a test::PacketPipe to a
-// PacketReceiverCallback.
-class LoopBackPacketPipe : public test::PacketPipe {
- public:
-  LoopBackPacketPipe(const transport::PacketReceiverCallback& packet_receiver)
-      : packet_receiver_(packet_receiver) {}
-
-  virtual ~LoopBackPacketPipe() {}
-
-  // PacketPipe implementations.
-  virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
-    packet_receiver_.Run(packet.Pass());
-  }
-
- private:
-  transport::PacketReceiverCallback packet_receiver_;
-};
-
-// Class that sends the packet direct from sender into the receiver with the
-// ability to drop packets between the two.
-// TODO(hubbe): Break this out and share code with end2end_unittest.cc
-class LoopBackTransport : public transport::PacketSender {
- public:
-  explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
-      : cast_environment_(cast_environment) {}
-
-  void SetPacketReceiver(
-      const transport::PacketReceiverCallback& packet_receiver,
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-      base::TickClock* clock) {
-    scoped_ptr<test::PacketPipe> loopback_pipe(
-        new LoopBackPacketPipe(packet_receiver));
-    if (packet_pipe_) {
-      packet_pipe_->AppendToPipe(loopback_pipe.Pass());
-    } else {
-      packet_pipe_ = loopback_pipe.Pass();
-    }
-    packet_pipe_->InitOnIOThread(task_runner, clock);
-  }
-
-  virtual bool SendPacket(transport::PacketRef packet,
-                          const base::Closure& cb) OVERRIDE {
-    DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-    scoped_ptr<Packet> packet_copy(new Packet(packet->data));
-    packet_pipe_->Send(packet_copy.Pass());
-    return true;
-  }
-
-  void SetPacketPipe(scoped_ptr<test::PacketPipe> pipe) {
-    // Append the loopback pipe to the end.
-    pipe->AppendToPipe(packet_pipe_.Pass());
-    packet_pipe_ = pipe.Pass();
-  }
-
- private:
-  scoped_refptr<CastEnvironment> cast_environment_;
-  scoped_ptr<test::PacketPipe> packet_pipe_;
-};
-
 // Wraps a CastTransportSender and records some statistics about
 // the data that goes through it.
 class CastTransportSenderWrapper : public transport::CastTransportSender {
  public:
   // Takes ownership of |transport|.
   void Init(CastTransportSender* transport,
             uint64* encoded_video_bytes,
             uint64* encoded_audio_bytes) {
     transport_.reset(transport);
     encoded_video_bytes_ = encoded_video_bytes;
@@ skipping 178 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() {
+  void Create(const MeasuringPoint& p) {
     cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
                                           audio_receiver_config_,
                                           video_receiver_config_,
                                           &receiver_to_sender_);
     net::IPEndPoint dummy_endpoint;
     transport_sender_.Init(new transport::CastTransportSenderImpl(
                                NULL,
                                testing_clock_sender_,
                                dummy_endpoint,
                                base::Bind(&UpdateCastTransportStatus),
                                base::Bind(&IgnoreRawEvents),
                                base::TimeDelta::FromSeconds(1),
                                task_runner_sender_,
                                &sender_to_receiver_),
                            &video_bytes_encoded_,
                            &audio_bytes_encoded_);
 
     cast_sender_ =
         CastSender::Create(cast_environment_sender_, &transport_sender_);
 
     // Initializing audio and video senders.
     cast_sender_->InitializeAudio(audio_sender_config_,
                                   base::Bind(&AudioInitializationStatus));
     cast_sender_->InitializeVideo(video_sender_config_,
                                   base::Bind(&VideoInitializationStatus),
                                   CreateDefaultVideoEncodeAcceleratorCallback(),
                                   CreateDefaultVideoEncodeMemoryCallback());
 
-    receiver_to_sender_.SetPacketReceiver(
-        cast_sender_->packet_receiver(), task_runner_, &testing_clock_);
-    sender_to_receiver_.SetPacketReceiver(
-        cast_receiver_->packet_receiver(), task_runner_, &testing_clock_);
+    receiver_to_sender_.Initialize(
+        CreateSimplePipe(p).Pass(), cast_sender_->packet_receiver(),
+        task_runner_, &testing_clock_);
+    sender_to_receiver_.Initialize(
+        CreateSimplePipe(p).Pass(), cast_receiver_->packet_receiver(),
+        task_runner_, &testing_clock_);
   }
 
   virtual ~RunOneBenchmark() {
     cast_sender_.reset();
     cast_receiver_.reset();
     task_runner_->RunTasks();
   }
 
   void SendFakeVideoFrame() {
     frames_sent_++;
@@ skipping 37 matching lines @@
     pipe->AppendToPipe(
         test::NewRandomDrop(p.percent_packet_drop / 100.0).Pass());
     pipe->AppendToPipe(test::NewConstantDelay(p.latency / 1000.0));
     return pipe.Pass();
   }
 
   void Run(const MeasuringPoint& p) {
     available_bitrate_ = p.bitrate;
     Configure(
         transport::CODEC_VIDEO_FAKE, transport::CODEC_AUDIO_PCM16, 32000, 1);
-    receiver_to_sender_.SetPacketPipe(CreateSimplePipe(p).Pass());
-    sender_to_receiver_.SetPacketPipe(CreateSimplePipe(p).Pass());
-    Create();
+    Create(p);
     StartBasicPlayer();
 
     for (int frame = 0; frame < 1000; frame++) {
       SendFakeVideoFrame();
       RunTasks(kFrameTimerMs);
     }
     RunTasks(100 * kFrameTimerMs);  // Empty the pipeline.
     VLOG(1) << "=============INPUTS============";
     VLOG(1) << "Bitrate: " << p.bitrate << " mbit/s";
     VLOG(1) << "Latency: " << p.latency << " ms";
@@ skipping 309 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();
   }
 }