Refactoring: Merge VideoSenderConfig and AudioSenderConfig.

media/cast/sender/video_encoder_unittest.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.
 
 #include "media/cast/sender/video_encoder.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 48 matching lines @@
       vea_factory_.reset(new FakeVideoEncodeAcceleratorFactory(task_runner_));
   }
 
   void TearDown() final {
     video_encoder_.reset();
     RunTasksAndAdvanceClock();
   }
 
   void CreateEncoder() {
     ASSERT_EQ(STATUS_UNINITIALIZED, operational_status_);
-    video_config_.max_number_of_video_buffers_used = 1;
+    video_config_.video_codec_params.max_number_of_video_buffers_used = 1;
     video_encoder_ = VideoEncoder::Create(
         cast_environment_, video_config_,
         base::Bind(&VideoEncoderTest::OnOperationalStatusChange,
                    base::Unretained(this)),
         base::Bind(
             &FakeVideoEncodeAcceleratorFactory::CreateVideoEncodeAccelerator,
             base::Unretained(vea_factory_.get())),
         base::Bind(&FakeVideoEncodeAcceleratorFactory::CreateSharedMemory,
                    base::Unretained(vea_factory_.get())));
     RunTasksAndAdvanceClock();
@@ skipping 34 matching lines @@
 
   void DestroyEncoder() {
     video_encoder_.reset();
   }
 
   base::TimeTicks Now() const {
     return testing_clock_->NowTicks();
   }
 
   void RunTasksAndAdvanceClock() const {
+    DCHECK_GT(video_config_.max_frame_rate, 0);
     const base::TimeDelta frame_duration = base::TimeDelta::FromMicroseconds(
         1000000.0 / video_config_.max_frame_rate);
 #if defined(OS_MACOSX)
     if (is_testing_video_toolbox_encoder()) {
       // The H264VideoToolboxEncoder (on MAC_OSX and IOS) is not a faked
       // implementation in these tests, and performs its encoding asynchronously
       // on an unknown set of threads.  Therefore, sleep the current thread for
       // the real amount of time to avoid excessively spinning the CPU while
       // waiting for something to happen.
       base::PlatformThread::Sleep(frame_duration);
@@ skipping 106 matching lines @@
           << "Platform encoder chose to emit a "
           << (have_key_frame ? "key" : "delta")
           << " frame instead of the expected kind @ frame_id="
           << encoded_frame->frame_id;
       LOG_IF(WARNING, encoded_frame->data.empty())
           << "Platform encoder returned an empty frame @ frame_id="
           << encoded_frame->frame_id;
     } else {
       if (expected_frame_id != expected_last_referenced_frame_id) {
         EXPECT_EQ(EncodedFrame::DEPENDENT, encoded_frame->dependency);
-      } else if (video_config_.max_number_of_video_buffers_used == 1) {
+      } else if (video_config_.video_codec_params
+                     .max_number_of_video_buffers_used == 1) {
         EXPECT_EQ(EncodedFrame::KEY, encoded_frame->dependency);
       }
       EXPECT_EQ(expected_last_referenced_frame_id,
                 encoded_frame->referenced_frame_id);
       EXPECT_FALSE(encoded_frame->data.empty());
       ASSERT_TRUE(std::isfinite(encoded_frame->encoder_utilization));
       EXPECT_LE(0.0, encoded_frame->encoder_utilization);
       ASSERT_TRUE(std::isfinite(encoded_frame->lossy_utilization));
       EXPECT_LE(0.0, encoded_frame->lossy_utilization);
     }
 
     ++count_frames_delivered_;
   }
 
   base::SimpleTestTickClock* const testing_clock_;  // Owned by CastEnvironment.
   const scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
   const scoped_refptr<CastEnvironment> cast_environment_;
-  VideoSenderConfig video_config_;
+  FrameSenderConfig video_config_;
   std::unique_ptr<FakeVideoEncodeAcceleratorFactory> vea_factory_;
   base::TimeTicks first_frame_time_;
   OperationalStatus operational_status_;
   std::unique_ptr<VideoEncoder> video_encoder_;
   std::unique_ptr<VideoFrameFactory> video_frame_factory_;
 
   int count_frames_delivered_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoEncoderTest);
 };
@@ skipping 128 matching lines @@
 std::vector<std::pair<Codec, bool>> DetermineEncodersToTest() {
   std::vector<std::pair<Codec, bool>> values;
   // Fake encoder.
   values.push_back(std::make_pair(CODEC_VIDEO_FAKE, false));
   // Software VP8 encoder.
   values.push_back(std::make_pair(CODEC_VIDEO_VP8, false));
   // Hardware-accelerated encoder (faked).
   values.push_back(std::make_pair(CODEC_VIDEO_VP8, true));
 #if defined(OS_MACOSX)
   // VideoToolbox encoder (when VideoToolbox is present).
-  VideoSenderConfig video_config = GetDefaultVideoSenderConfig();
+  FrameSenderConfig video_config = GetDefaultVideoSenderConfig();
   video_config.use_external_encoder = false;
   video_config.codec = CODEC_VIDEO_H264;
   if (H264VideoToolboxEncoder::IsSupported(video_config))
     values.push_back(std::make_pair(CODEC_VIDEO_H264, false));
 #endif
   return values;
 }
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(
     , VideoEncoderTest, ::testing::ValuesIn(DetermineEncodersToTest()));
 
 }  // namespace cast
 }  // namespace media