Cast: Make receiver use cast_transport

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 134 matching lines @@
   }
 
   void ResendFrameForKickstart(uint32 ssrc, uint32 frame_id) override {
     transport_->ResendFrameForKickstart(ssrc, frame_id);
   }
 
   PacketReceiverCallback PacketReceiverForTesting() override {
     return transport_->PacketReceiverForTesting();
   }
 
+  void AddValidSsrc(uint32 ssrc) override {
+    return transport_->AddValidSsrc(ssrc);
+  }
+
+  void SendRtcpFromRtpReceiver(
+      uint32 ssrc,
+      uint32 sender_ssrc,
+      const RtcpTimeData& time_data,
+      const RtcpCastMessage* cast_message,
+      base::TimeDelta target_delay,
+      const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
+      const RtpReceiverStatistics* rtp_receiver_statistics) override {
+    return transport_->SendRtcpFromRtpReceiver(ssrc,
+                                               sender_ssrc,
+                                               time_data,
+                                               cast_message,
+                                               target_delay,
+                                               rtcp_events,
+                                               rtp_receiver_statistics);
+  }
+
  private:
   scoped_ptr<CastTransportSender> transport_;
   uint32 audio_ssrc_, video_ssrc_;
   uint64* encoded_video_bytes_;
   uint64* encoded_audio_bytes_;
 };
 
 struct MeasuringPoint {
   MeasuringPoint(double bitrate_, double latency_, double percent_packet_drop_)
       : bitrate(bitrate_),
@@ skipping 114 matching lines @@
     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) {
-    cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
-                                          audio_receiver_config_,
-                                          video_receiver_config_,
-                                          &receiver_to_sender_);
     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_);
 
     // 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_.Initialize(
         CreateSimplePipe(p).Pass(),
         transport_sender_.PacketReceiverForTesting(),
         task_runner_, &testing_clock_);
     sender_to_receiver_.Initialize(
-        CreateSimplePipe(p).Pass(), cast_receiver_->packet_receiver(),
+        CreateSimplePipe(p).Pass(),
+        transport_receiver_->PacketReceiverForTesting(),
         task_runner_, &testing_clock_);
   }
 
+  void ReceivePacket(scoped_ptr<Packet> packet) {
+    cast_receiver_->ReceivePacket(packet.Pass());
+  }
+
   virtual ~RunOneBenchmark() {
     cast_sender_.reset();
     cast_receiver_.reset();
     task_runner_->RunTasks();
   }
 
   void SendFakeVideoFrame() {
     frames_sent_++;
     cast_sender_->video_frame_input()->InsertRawVideoFrame(
         media::VideoFrame::CreateBlackFrame(gfx::Size(2, 2)),
@@ skipping 130 matching lines @@
   // 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_;
   CastTransportSenderWrapper transport_sender_;
+  scoped_ptr<CastTransportSender> transport_receiver_;
   uint64 video_bytes_encoded_;
   uint64 audio_bytes_encoded_;
 
   scoped_ptr<CastReceiver> cast_receiver_;
   scoped_ptr<CastSender> cast_sender_;
 
   int frames_sent_;
   double available_bitrate_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_;
@@ skipping 215 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();
   }
 }