Revert of Refactoring: Merge VideoSenderConfig and AudioSenderConfig.

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 240 matching lines @@
             base::TimeDelta::FromMilliseconds(kTargetPlayoutDelayMs);
     video_sender_config_.max_bitrate = 4000000;
     video_sender_config_.min_bitrate = 4000000;
     video_sender_config_.start_bitrate = 4000000;
     video_sender_config_.codec = video_codec;
 
     video_receiver_config_ = GetDefaultVideoReceiverConfig();
     video_receiver_config_.rtp_max_delay_ms = kTargetPlayoutDelayMs;
     video_receiver_config_.codec = video_codec;
 
-    DCHECK_GT(video_sender_config_.max_frame_rate, 0);
-    frame_duration_ = base::TimeDelta::FromSecondsD(
-        1.0 / video_sender_config_.max_frame_rate);
+    frame_duration_ = base::TimeDelta::FromSeconds(1) /
+        video_sender_config_.max_frame_rate;
   }
 
   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(const MeasuringPoint& p);
 
   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) {
-    return frame_number * base::TimeDelta::FromSecondsD(
-                              1.0 / video_sender_config_.max_frame_rate);
+    return (frame_number * base::TimeDelta::FromSeconds(1)) /
+        video_sender_config_.max_frame_rate;
   }
 
   void SendFakeVideoFrame() {
     // NB: Blackframe with timestamp
     cast_sender_->video_frame_input()->InsertRawVideoFrame(
         media::VideoFrame::CreateColorFrame(gfx::Size(2, 2),
         0x00, 0x80, 0x80, VideoTimestamp(frames_sent_)),
         testing_clock_sender_->NowTicks());
     frames_sent_++;
   }
@@ skipping 103 matching lines @@
 
   bool SimpleGood() {
     return frames_lost() <= 1 && late_frames() <= 1 &&
            video_bandwidth() > desired_video_bitrate() * 0.8 &&
            video_bandwidth() < desired_video_bitrate() * 1.2;
   }
 
  private:
   FrameReceiverConfig audio_receiver_config_;
   FrameReceiverConfig video_receiver_config_;
-  FrameSenderConfig audio_sender_config_;
-  FrameSenderConfig video_sender_config_;
+  AudioSenderConfig audio_sender_config_;
+  VideoSenderConfig video_sender_config_;
 
   base::TimeTicks start_time_;
 
   // These run in "test time"
   base::SimpleTestTickClock testing_clock_;
   scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
 
   // These run on the sender timeline.
   test::SkewedTickClock* testing_clock_sender_;
   scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_sender_;
@@ skipping 302 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();
   }
 }