Refactoring: CastTransport InitializeAudio/InitializeVideo.

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 79 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,
-                       std::unique_ptr<RtcpObserver> rtcp_observer) final {
-    audio_ssrc_ = config.ssrc;
-    transport_->InitializeAudio(config, std::move(rtcp_observer));
-  }
-
-  void InitializeVideo(const CastTransportRtpConfig& config,
-                       std::unique_ptr<RtcpObserver> rtcp_observer) final {
-    video_ssrc_ = config.ssrc;
-    transport_->InitializeVideo(config, std::move(rtcp_observer));
+  void InitializeStream(const CastTransportRtpConfig& config,
+                        std::unique_ptr<RtcpObserver> rtcp_observer) final {
+    if (config.rtp_payload_type <= RtpPayloadType::AUDIO_LAST)
+      audio_ssrc_ = config.ssrc;
+    else
+      video_ssrc_ = config.ssrc;
+    transport_->InitializeStream(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 329 matching lines @@
 };
 
 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);
+    EXPECT_EQ(TRANSPORT_STREAM_INITIALIZED, status);
   };
   void OnLoggingEventsReceived(
       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),
-          base::WrapUnique(new TransportClient(nullptr)),
+          base::MakeUnique<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),
-      base::WrapUnique(new TransportClient(this)),
+      base::MakeUnique<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_,
@@ skipping 226 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();
   }
 }