Changed AudioEncoder::Encode to take an rtc::Buffer* instead of uint8_t* and a maximum size.

webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 52 matching lines @@
     ASSERT_LE(num_audio_samples_10ms_, kMaxNumSamples);
     EXPECT_CALL(mock_encoder_, SampleRateHz())
         .WillRepeatedly(Return(sample_rate_hz_));
     // Max10MsFramesInAPacket() is just used to verify that the SID frame period
     // is not too small. The return value does not matter that much, as long as
     // it is smaller than 10.
     EXPECT_CALL(mock_encoder_, Max10MsFramesInAPacket()).WillOnce(Return(1u));
     EXPECT_CALL(mock_encoder_, MaxEncodedBytes())
         .WillRepeatedly(Return(kMockMaxEncodedBytes));
     cng_.reset(new AudioEncoderCng(config_));
-    encoded_.resize(cng_->MaxEncodedBytes(), 0);
   }
 
   void Encode() {
     ASSERT_TRUE(cng_) << "Must call CreateCng() first.";
     encoded_info_ = cng_->Encode(
         timestamp_,
         rtc::ArrayView<const int16_t>(audio_, num_audio_samples_10ms_),
-        encoded_.size(), &encoded_[0]);
+        &encoded_);
     timestamp_ += static_cast<uint32_t>(num_audio_samples_10ms_);
   }
 
   // Expect |num_calls| calls to the encoder, all successful. The last call
   // claims to have encoded |kMockMaxEncodedBytes| bytes, and all the preceding
   // ones 0 bytes.
   void ExpectEncodeCalls(size_t num_calls) {
     InSequence s;
     AudioEncoder::EncodedInfo info;
     for (size_t j = 0; j < num_calls - 1; ++j) {
-      EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _, _))
+      EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _))
           .WillOnce(Return(info));
     }
     info.encoded_bytes = kMockReturnEncodedBytes;
-    EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _, _))
-        .WillOnce(Return(info));
+    EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _))
+        .WillOnce(Invoke(
+            MockAudioEncoder::FakeEncoding(kMockReturnEncodedBytes)));
   }
 
   // Verifies that the cng_ object waits until it has collected
   // |blocks_per_frame| blocks of audio, and then dispatches all of them to
   // the underlying codec (speech or cng).
   void CheckBlockGrouping(size_t blocks_per_frame, bool active_speech) {
     EXPECT_CALL(mock_encoder_, Num10MsFramesInNextPacket())
         .WillRepeatedly(Return(blocks_per_frame));
     CreateCng();
     EXPECT_CALL(*mock_vad_, VoiceActivity(_, _, _))
         .WillRepeatedly(Return(active_speech ? Vad::kActive : Vad::kPassive));
 
     // Don't expect any calls to the encoder yet.
-    EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _, _)).Times(0);
+    EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _)).Times(0);
     for (size_t i = 0; i < blocks_per_frame - 1; ++i) {
       Encode();
       EXPECT_EQ(0u, encoded_info_.encoded_bytes);
     }
     if (active_speech)
       ExpectEncodeCalls(blocks_per_frame);
     Encode();
     if (active_speech) {
       EXPECT_EQ(kMockReturnEncodedBytes, encoded_info_.encoded_bytes);
     } else {
@@ skipping 62 matching lines @@
     return encoded_info_.payload_type != kCngPayloadType;
   }
 
   AudioEncoderCng::Config config_;
   std::unique_ptr<AudioEncoderCng> cng_;
   MockAudioEncoder mock_encoder_;
   MockVad* mock_vad_;  // Ownership is transferred to |cng_|.
   uint32_t timestamp_;
   int16_t audio_[kMaxNumSamples];
   size_t num_audio_samples_10ms_;
-  std::vector<uint8_t> encoded_;
+  rtc::Buffer encoded_;
   AudioEncoder::EncodedInfo encoded_info_;
   int sample_rate_hz_;
 };
 
 TEST_F(AudioEncoderCngTest, CreateAndDestroy) {
   CreateCng();
 }
 
 TEST_F(AudioEncoderCngTest, CheckFrameSizePropagation) {
   CreateCng();
@@ skipping 47 matching lines @@
 }
 
 TEST_F(AudioEncoderCngTest, EncodePassive) {
   const size_t kBlocksPerFrame = 3;
   EXPECT_CALL(mock_encoder_, Num10MsFramesInNextPacket())
       .WillRepeatedly(Return(kBlocksPerFrame));
   CreateCng();
   EXPECT_CALL(*mock_vad_, VoiceActivity(_, _, _))
       .WillRepeatedly(Return(Vad::kPassive));
   // Expect no calls at all to the speech encoder mock.
-  EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _, _)).Times(0);
+  EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _)).Times(0);
   uint32_t expected_timestamp = timestamp_;
   for (size_t i = 0; i < 100; ++i) {
     Encode();
     // Check if it was time to call the cng encoder. This is done once every
     // |kBlocksPerFrame| calls.
     if ((i + 1) % kBlocksPerFrame == 0) {
       // Now check if a SID interval has elapsed.
       if ((i % (config_.sid_frame_interval_ms / 10)) < kBlocksPerFrame) {
         // If so, verify that we got a CNG encoding.
         EXPECT_EQ(kCngPayloadType, encoded_info_.payload_type);
@@ skipping 61 matching lines @@
   CheckVadInputSize(50, 30, 20);
 }
 TEST_F(AudioEncoderCngTest, VadInputSize60Ms) {
   CreateCng();
   CheckVadInputSize(60, 30, 30);
 }
 
 // Verifies that the correct payload type is set when CNG is encoded.
 TEST_F(AudioEncoderCngTest, VerifyCngPayloadType) {
   CreateCng();
-  EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _, _)).Times(0);
+  EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _)).Times(0);
   EXPECT_CALL(mock_encoder_, Num10MsFramesInNextPacket()).WillOnce(Return(1U));
   EXPECT_CALL(*mock_vad_, VoiceActivity(_, _, _))
       .WillOnce(Return(Vad::kPassive));
   encoded_info_.payload_type = 0;
   Encode();
   EXPECT_EQ(kCngPayloadType, encoded_info_.payload_type);
 }
 
 // Verifies that a SID frame is encoded immediately as the signal changes from
 // active speech to passive.
@@ skipping 11 matching lines @@
             encoded_info_.encoded_bytes);
   // Encode again, and make sure we got no frame at all (since the SID frame
   // period is 100 ms by default).
   Encode();
   EXPECT_EQ(0u, encoded_info_.encoded_bytes);
 
   // Now encode active speech.
   encoded_info_.payload_type = 0;
   EXPECT_CALL(*mock_vad_, VoiceActivity(_, _, _))
       .WillOnce(Return(Vad::kActive));
-  AudioEncoder::EncodedInfo info;
-  info.encoded_bytes = kMockReturnEncodedBytes;
-  EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _, _)).WillOnce(Return(info));
+  EXPECT_CALL(mock_encoder_, EncodeInternal(_, _, _)).WillOnce(
+      Invoke(MockAudioEncoder::FakeEncoding(kMockReturnEncodedBytes)));
   Encode();
   EXPECT_EQ(kMockReturnEncodedBytes, encoded_info_.encoded_bytes);
 
   // Go back to noise again, and verify that a SID frame is emitted.
   EXPECT_CALL(*mock_vad_, VoiceActivity(_, _, _))
       .WillOnce(Return(Vad::kPassive));
   Encode();
   EXPECT_EQ(kCngPayloadType, encoded_info_.payload_type);
   EXPECT_EQ(static_cast<size_t>(config_.num_cng_coefficients) + 1,
             encoded_info_.encoded_bytes);
@@ skipping 68 matching lines @@
       .WillRepeatedly(Return(7U));
   for (int i = 0; i < 6; ++i)
     Encode();
   EXPECT_DEATH(Encode(),
                "Frame size cannot be larger than 60 ms when using VAD/CNG.");
 }
 
 #endif  // GTEST_HAS_DEATH_TEST
 
 }  // namespace webrtc