Cast: Use fixed bitrate and set it once for hardware encoder

media/cast/sender/video_sender_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 <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 156 matching lines @@
     video_config.min_bitrate = 1000000;
     video_config.start_bitrate = 1000000;
     video_config.max_qp = 56;
     video_config.min_qp = 0;
     video_config.max_frame_rate = 30;
     video_config.max_number_of_video_buffers_used = 1;
     video_config.codec = CODEC_VIDEO_VP8;
 
     if (external) {
       scoped_ptr<VideoEncodeAccelerator> fake_vea(
-          new test::FakeVideoEncodeAccelerator(task_runner_));
+          new test::FakeVideoEncodeAccelerator(task_runner_,
+                                               &stored_bitrates_));
       video_sender_.reset(
           new PeerVideoSender(cast_environment_,
                               video_config,
                               base::Bind(&CreateVideoEncodeAccelerator,
                                          task_runner_,
                                          base::Passed(&fake_vea)),
                               base::Bind(&CreateSharedMemory),
                               transport_sender_.get()));
     } else {
       video_sender_.reset(
@@ skipping 26 matching lines @@
 
   void RunTasks(int during_ms) {
     task_runner_->Sleep(base::TimeDelta::FromMilliseconds(during_ms));
   }
 
   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
   TestPacketSender transport_;
   scoped_ptr<CastTransportSenderImpl> transport_sender_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_ptr<PeerVideoSender> video_sender_;
+  std::vector<uint32> stored_bitrates_;
   scoped_refptr<CastEnvironment> cast_environment_;
   int last_pixel_value_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoSenderTest);
 };
 
 TEST_F(VideoSenderTest, BuiltInEncoder) {
   InitEncoder(false);
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
   const base::TimeTicks capture_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
 
   task_runner_->RunTasks();
   EXPECT_LE(1, transport_.number_of_rtp_packets());
   EXPECT_LE(1, transport_.number_of_rtcp_packets());
 }
 
 TEST_F(VideoSenderTest, ExternalEncoder) {
   InitEncoder(true);
   task_runner_->RunTasks();
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
 
   const base::TimeTicks capture_time = testing_clock_->NowTicks();
   video_sender_->InsertRawVideoFrame(video_frame, capture_time);
+  task_runner_->RunTasks();
+  video_sender_->InsertRawVideoFrame(video_frame, capture_time);
+  task_runner_->RunTasks();
+  video_sender_->InsertRawVideoFrame(video_frame, capture_time);
+  task_runner_->RunTasks();
 
-  task_runner_->RunTasks();
+  // Fixed bitrate is used for external encoder. Bitrate is only once
+  // to the encoder.
+  EXPECT_EQ(1u, stored_bitrates_.size());
 
   // We need to run the task to cleanup the GPU instance.
   video_sender_.reset(NULL);
   task_runner_->RunTasks();
 }
 
 TEST_F(VideoSenderTest, RtcpTimer) {
   InitEncoder(false);
 
   scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
@@ skipping 254 matching lines @@
   video_sender_->OnReceivedCastFeedback(cast_feedback);
 
   transport_.SetPause(false);
   RunTasks(33);
   // Only one packet should be retransmitted.
   EXPECT_EQ(1, transport_.number_of_rtp_packets());
 }
 
 }  // namespace cast
 }  // namespace media