Refactor: simplify interface of SenderRtcpSession and CastTransport.

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 15 matching lines @@
 #include <stdint.h>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/profiler.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/fake_single_thread_task_runner.h"
@@ skipping 41 matching lines @@
  public:
   // Takes ownership of |transport|.
   void Init(CastTransport* transport,
             uint64_t* encoded_video_bytes,
             uint64_t* encoded_audio_bytes) {
     transport_.reset(transport);
     encoded_video_bytes_ = encoded_video_bytes;
     encoded_audio_bytes_ = encoded_audio_bytes;
   }
 
-  void InitializeAudio(const CastTransportRtpConfig& config,
-                       const RtcpCastMessageCallback& cast_message_cb,
-                       const RtcpRttCallback& rtt_cb,
-                       const RtcpPliCallback& key_frame_cb) final {
+  void InitializeAudio(
+      const CastTransportRtpConfig& config,
+      std::unique_ptr<SenderRtcpObserver> rtcp_observer) final {
     audio_ssrc_ = config.ssrc;
-    transport_->InitializeAudio(config, cast_message_cb, rtt_cb, key_frame_cb);
+    transport_->InitializeAudio(config, std::move(rtcp_observer));
   }
 
-  void InitializeVideo(const CastTransportRtpConfig& config,
-                       const RtcpCastMessageCallback& cast_message_cb,
-                       const RtcpRttCallback& rtt_cb,
-                       const RtcpPliCallback& key_frame_cb) final {
+  void InitializeVideo(
+      const CastTransportRtpConfig& config,
+      std::unique_ptr<SenderRtcpObserver> rtcp_observer) final {
     video_ssrc_ = config.ssrc;
-    transport_->InitializeVideo(config, cast_message_cb, rtt_cb, key_frame_cb);
+    transport_->InitializeVideo(config, std::move(rtcp_observer));
   }
 
   void InsertFrame(uint32_t ssrc, const EncodedFrame& frame) final {
     if (ssrc == audio_ssrc_) {
       *encoded_audio_bytes_ += frame.data.size();
     } else if (ssrc == video_ssrc_) {
       *encoded_video_bytes_ += frame.data.size();
     }
     transport_->InsertFrame(ssrc, frame);
   }
@@ skipping 47 matching lines @@
     transport_->AddPli(pli_message);
   }
 
   void SendRtcpFromRtpReceiver() final {
     transport_->SendRtcpFromRtpReceiver();
   }
 
   void SetOptions(const base::DictionaryValue& options) final {}
 
  private:
-  scoped_ptr<CastTransport> transport_;
+  std::unique_ptr<CastTransport> transport_;
   uint32_t audio_ssrc_, video_ssrc_;
   uint64_t* encoded_video_bytes_;
   uint64_t* encoded_audio_bytes_;
 };
 
 struct MeasuringPoint {
   MeasuringPoint(double bitrate_, double latency_, double percent_packet_drop_)
       : bitrate(bitrate_),
         latency(latency_),
         percent_packet_drop(percent_packet_drop_) {}
@@ skipping 21 matching lines @@
   RunOneBenchmark()
       : start_time_(),
         task_runner_(new FakeSingleThreadTaskRunner(&testing_clock_)),
         testing_clock_sender_(new test::SkewedTickClock(&testing_clock_)),
         task_runner_sender_(
             new test::SkewedSingleThreadTaskRunner(task_runner_)),
         testing_clock_receiver_(new test::SkewedTickClock(&testing_clock_)),
         task_runner_receiver_(
             new test::SkewedSingleThreadTaskRunner(task_runner_)),
         cast_environment_sender_(new CastEnvironment(
-            scoped_ptr<base::TickClock>(testing_clock_sender_),
+            std::unique_ptr<base::TickClock>(testing_clock_sender_),
             task_runner_sender_,
             task_runner_sender_,
             task_runner_sender_)),
         cast_environment_receiver_(new CastEnvironment(
-            scoped_ptr<base::TickClock>(testing_clock_receiver_),
+            std::unique_ptr<base::TickClock>(testing_clock_receiver_),
             task_runner_receiver_,
             task_runner_receiver_,
             task_runner_receiver_)),
         video_bytes_encoded_(0),
         audio_bytes_encoded_(0),
         frames_sent_(0) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
@@ skipping 32 matching lines @@
     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);
 
-  void ReceivePacket(scoped_ptr<Packet> packet) {
+  void ReceivePacket(std::unique_ptr<Packet> packet) {
     cast_receiver_->ReceivePacket(std::move(packet));
   }
 
   virtual ~RunOneBenchmark() {
     cast_sender_.reset();
     cast_receiver_.reset();
     task_runner_->RunTasks();
   }
 
   base::TimeDelta VideoTimestamp(int frame_number) {
@@ skipping 17 matching lines @@
   void BasicPlayerGotVideoFrame(
       const scoped_refptr<media::VideoFrame>& video_frame,
       const base::TimeTicks& render_time,
       bool continuous) {
     video_ticks_.push_back(
         std::make_pair(testing_clock_receiver_->NowTicks(), render_time));
     cast_receiver_->RequestDecodedVideoFrame(base::Bind(
         &RunOneBenchmark::BasicPlayerGotVideoFrame, base::Unretained(this)));
   }
 
-  void BasicPlayerGotAudioFrame(scoped_ptr<AudioBus> audio_bus,
+  void BasicPlayerGotAudioFrame(std::unique_ptr<AudioBus> audio_bus,
                                 const base::TimeTicks& playout_time,
                                 bool is_continuous) {
     audio_ticks_.push_back(
         std::make_pair(testing_clock_receiver_->NowTicks(), playout_time));
     cast_receiver_->RequestDecodedAudioFrame(base::Bind(
         &RunOneBenchmark::BasicPlayerGotAudioFrame, base::Unretained(this)));
   }
 
   void StartBasicPlayer() {
     cast_receiver_->RequestDecodedVideoFrame(base::Bind(
         &RunOneBenchmark::BasicPlayerGotVideoFrame, base::Unretained(this)));
     cast_receiver_->RequestDecodedAudioFrame(base::Bind(
         &RunOneBenchmark::BasicPlayerGotAudioFrame, base::Unretained(this)));
   }
 
-  scoped_ptr<test::PacketPipe> CreateSimplePipe(const MeasuringPoint& p) {
-    scoped_ptr<test::PacketPipe> pipe = test::NewBuffer(65536, p.bitrate);
+  std::unique_ptr<test::PacketPipe> CreateSimplePipe(const MeasuringPoint& p) {
+    std::unique_ptr<test::PacketPipe> pipe = test::NewBuffer(65536, p.bitrate);
     pipe->AppendToPipe(test::NewRandomDrop(p.percent_packet_drop / 100.0));
     pipe->AppendToPipe(test::NewConstantDelay(p.latency / 1000.0));
     return pipe;
   }
 
   void Run(const MeasuringPoint& p) {
     available_bitrate_ = p.bitrate;
     Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
     Create(p);
     StartBasicPlayer();
@@ skipping 83 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_;  // Owned by CastTransportImpl.
   LoopBackTransport* sender_to_receiver_;  // Owned by CastTransportImpl.
   CastTransportWrapper transport_sender_;
-  scoped_ptr<CastTransport> transport_receiver_;
+  std::unique_ptr<CastTransport> transport_receiver_;
   uint64_t video_bytes_encoded_;
   uint64_t audio_bytes_encoded_;
 
-  scoped_ptr<CastReceiver> cast_receiver_;
-  scoped_ptr<CastSender> cast_sender_;
+  std::unique_ptr<CastReceiver> cast_receiver_;
+  std::unique_ptr<CastSender> cast_sender_;
 
   int frames_sent_;
   base::TimeDelta frame_duration_;
   double available_bitrate_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_;
   std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_;
 };
 
 namespace {
 
 class TransportClient : public CastTransport::Client {
  public:
   explicit TransportClient(RunOneBenchmark* run_one_benchmark)
       : run_one_benchmark_(run_one_benchmark) {}
 
   void OnStatusChanged(CastTransportStatus status) final {
     bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
                    status == TRANSPORT_VIDEO_INITIALIZED);
     EXPECT_TRUE(result);
   };
   void OnLoggingEventsReceived(
-      scoped_ptr<std::vector<FrameEvent>> frame_events,
-      scoped_ptr<std::vector<PacketEvent>> packet_events) final{};
-  void ProcessRtpPacket(scoped_ptr<Packet> packet) final {
+      std::unique_ptr<std::vector<FrameEvent>> frame_events,
+      std::unique_ptr<std::vector<PacketEvent>> packet_events) final{};
+  void ProcessRtpPacket(std::unique_ptr<Packet> packet) final {
     if (run_one_benchmark_)
       run_one_benchmark_->ReceivePacket(std::move(packet));
   };
 
  private:
   RunOneBenchmark* const run_one_benchmark_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportClient);
 };
 
 }  // namepspace
 
 void RunOneBenchmark::Create(const MeasuringPoint& p) {
   sender_to_receiver_ = new LoopBackTransport(cast_environment_sender_);
   transport_sender_.Init(
       new CastTransportImpl(
           testing_clock_sender_, base::TimeDelta::FromSeconds(1),
-          make_scoped_ptr(new TransportClient(nullptr)),
-          make_scoped_ptr(sender_to_receiver_), task_runner_sender_),
+          base::WrapUnique(new TransportClient(nullptr)),
+          base::WrapUnique(sender_to_receiver_), task_runner_sender_),
       &video_bytes_encoded_, &audio_bytes_encoded_);
 
   receiver_to_sender_ = new LoopBackTransport(cast_environment_receiver_);
   transport_receiver_.reset(new CastTransportImpl(
       testing_clock_receiver_, base::TimeDelta::FromSeconds(1),
-      make_scoped_ptr(new TransportClient(this)),
-      make_scoped_ptr(receiver_to_sender_), task_runner_receiver_));
+      base::WrapUnique(new TransportClient(this)),
+      base::WrapUnique(receiver_to_sender_), task_runner_receiver_));
 
   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_);
 
   cast_sender_->InitializeAudio(audio_sender_config_,
                                 base::Bind(&ExpectAudioSuccess));
@@ skipping 228 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();
   }
 }