Cast: merge InsertCoded{Audio,Video}Frame into InsertFrame

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 94 matching lines @@
             uint64* encoded_audio_bytes) {
     transport_.reset(transport);
     encoded_video_bytes_ = encoded_video_bytes;
     encoded_audio_bytes_ = encoded_audio_bytes;
   }
 
   virtual void InitializeAudio(
       const CastTransportRtpConfig& config,
       const RtcpCastMessageCallback& cast_message_cb,
       const RtcpRttCallback& rtt_cb) OVERRIDE {
+    audio_ssrc_ = config.ssrc;
     transport_->InitializeAudio(config, cast_message_cb, rtt_cb);
   }
 
   virtual void InitializeVideo(
       const CastTransportRtpConfig& config,
       const RtcpCastMessageCallback& cast_message_cb,
       const RtcpRttCallback& rtt_cb) OVERRIDE {
+    video_ssrc_ = config.ssrc;
     transport_->InitializeVideo(config, cast_message_cb, rtt_cb);
   }
 
-  virtual void InsertCodedAudioFrame(
-      const EncodedFrame& audio_frame) OVERRIDE {
-    *encoded_audio_bytes_ += audio_frame.data.size();
-    transport_->InsertCodedAudioFrame(audio_frame);
-  }
-
-  virtual void InsertCodedVideoFrame(
-      const EncodedFrame& video_frame) OVERRIDE {
-    *encoded_video_bytes_ += video_frame.data.size();
-    transport_->InsertCodedVideoFrame(video_frame);
+  virtual void InsertFrame(uint32 ssrc,
+                           const EncodedFrame& frame) OVERRIDE {
+    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);
   }
 
   virtual void SendSenderReport(
       uint32 ssrc,
       base::TimeTicks current_time,
       uint32 current_time_as_rtp_timestamp) OVERRIDE {
     transport_->SendSenderReport(ssrc,
                                  current_time,
                                  current_time_as_rtp_timestamp);
   }
 
   virtual void CancelSendingFrames(
       uint32 ssrc,
       const std::vector<uint32>& frame_ids) OVERRIDE {
     transport_->CancelSendingFrames(ssrc, frame_ids);
   }
 
   virtual void ResendFrameForKickstart(uint32 ssrc,
                                        uint32 frame_id) OVERRIDE {
     transport_->ResendFrameForKickstart(ssrc, frame_id);
   }
 
   virtual PacketReceiverCallback PacketReceiverForTesting() OVERRIDE {
     return transport_->PacketReceiverForTesting();
   }
 
  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_),
         latency(latency_),
         percent_packet_drop(percent_packet_drop_) {}
   bool operator<=(const MeasuringPoint& other) const {
@@ skipping 534 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();
   }
 }