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.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 82 matching lines @@
   return speech_encoder_->Max10MsFramesInAPacket();
 }
 
 int AudioEncoderCng::GetTargetBitrate() const {
   return speech_encoder_->GetTargetBitrate();
 }
 
 AudioEncoder::EncodedInfo AudioEncoderCng::EncodeInternal(
     uint32_t rtp_timestamp,
     rtc::ArrayView<const int16_t> audio,
-    size_t max_encoded_bytes,
-    uint8_t* encoded) {
-  RTC_CHECK_GE(max_encoded_bytes,
-               static_cast<size_t>(num_cng_coefficients_ + 1));
+    rtc::Buffer* encoded) {
   const size_t samples_per_10ms_frame = SamplesPer10msFrame();
   RTC_CHECK_EQ(speech_buffer_.size(),
                rtp_timestamps_.size() * samples_per_10ms_frame);
   rtp_timestamps_.push_back(rtp_timestamp);
   RTC_DCHECK_EQ(samples_per_10ms_frame, audio.size());
   speech_buffer_.insert(speech_buffer_.end(), audio.cbegin(), audio.cend());
   const size_t frames_to_encode = speech_encoder_->Num10MsFramesInNextPacket();
   if (rtp_timestamps_.size() < frames_to_encode) {
     return EncodedInfo();
   }
@@ skipping 21 matching lines @@
   if (activity == Vad::kPassive && blocks_in_second_vad_call > 0) {
     // Only check the second block if the first was passive.
     activity = vad_->VoiceActivity(
         &speech_buffer_[samples_per_10ms_frame * blocks_in_first_vad_call],
         samples_per_10ms_frame * blocks_in_second_vad_call, SampleRateHz());
   }
 
   EncodedInfo info;
   switch (activity) {
     case Vad::kPassive: {
-      info = EncodePassive(frames_to_encode, max_encoded_bytes, encoded);
+      info = EncodePassive(frames_to_encode, encoded);
       last_frame_active_ = false;
       break;
     }
     case Vad::kActive: {
-      info = EncodeActive(frames_to_encode, max_encoded_bytes, encoded);
+      info = EncodeActive(frames_to_encode, encoded);
       last_frame_active_ = true;
       break;
     }
     case Vad::kError: {
       FATAL();  // Fails only if fed invalid data.
       break;
     }
   }
 
   speech_buffer_.erase(
@@ skipping 33 matching lines @@
 void AudioEncoderCng::SetProjectedPacketLossRate(double fraction) {
   speech_encoder_->SetProjectedPacketLossRate(fraction);
 }
 
 void AudioEncoderCng::SetTargetBitrate(int bits_per_second) {
   speech_encoder_->SetTargetBitrate(bits_per_second);
 }
 
 AudioEncoder::EncodedInfo AudioEncoderCng::EncodePassive(
     size_t frames_to_encode,
-    size_t max_encoded_bytes,
-    uint8_t* encoded) {
+    rtc::Buffer* encoded) {
   bool force_sid = last_frame_active_;
   bool output_produced = false;
   const size_t samples_per_10ms_frame = SamplesPer10msFrame();
-  RTC_CHECK_GE(max_encoded_bytes, frames_to_encode * samples_per_10ms_frame);
+  const size_t bytes_to_encode = frames_to_encode * samples_per_10ms_frame;
   AudioEncoder::EncodedInfo info;
-  for (size_t i = 0; i < frames_to_encode; ++i) {
-    // It's important not to pass &info.encoded_bytes directly to
-    // WebRtcCng_Encode(), since later loop iterations may return zero in that
-    // value, in which case we don't want to overwrite any value from an earlier
-    // iteration.
-    size_t encoded_bytes_tmp = 0;
-    RTC_CHECK_GE(WebRtcCng_Encode(cng_inst_.get(),
-                                  &speech_buffer_[i * samples_per_10ms_frame],
-                                  samples_per_10ms_frame, encoded,
-                                  &encoded_bytes_tmp, force_sid),
-                 0);
-    if (encoded_bytes_tmp > 0) {
-      RTC_CHECK(!output_produced);
-      info.encoded_bytes = encoded_bytes_tmp;
-      output_produced = true;
-      force_sid = false;
-    }
-  }
+
+  encoded->AppendData(bytes_to_encode, [&] (rtc::ArrayView<uint8_t> encoded) {

[The Sun (google.com), 2016/03/01 21:06:15]

FYI: Chromium C++11 style guide says to not use default captures:
https://chromium-cpp.appspot.com/

[ossu, 2016/03/02 08:39:42]

Well yes, and no. It says don't use it, referring to the Google Style Guide,
which says "Use default captures judiciously, when it aids readability [...]".
You can surely get turned around by default captures, but I believe this usage
is straight-forward enough: the code in the lambda is code that would otherwise
be in the function's scope (probably at that same point), which does have access
to this and all the local variables.

[kwiberg-webrtc, 2016/03/02 09:40:24]

Yes. The Google style guide used to blanket ban default capture, but that was
changed to the current text, which says "Avoid default lambda captures when
capturing this or if the lambda will escape the current scope.". I'm guessing
the Chromium C++11 text simply hasn't been updated.

By the letter of the text, I guess you should write [&, this], though---but I
certainly won't insist, since I don't think it makes sense to special-case
"this" once we have the "no default capture if the lambda escapes" rule.

+      for (size_t i = 0; i < frames_to_encode; ++i) {
+        // It's important not to pass &info.encoded_bytes directly to
+        // WebRtcCng_Encode(), since later loop iterations may return zero in
+        // that value, in which case we don't want to overwrite any value from
+        // an earlier iteration.
+        size_t encoded_bytes_tmp = 0;
+        RTC_CHECK_GE(
+            WebRtcCng_Encode(cng_inst_.get(),
+                             &speech_buffer_[i * samples_per_10ms_frame],
+                             samples_per_10ms_frame, encoded.data(),
+                             &encoded_bytes_tmp, force_sid),
+            0);
+        if (encoded_bytes_tmp > 0) {
+          RTC_CHECK(!output_produced);
+          info.encoded_bytes = encoded_bytes_tmp;
+          output_produced = true;
+          force_sid = false;
+        }
+      }
+
+      return info.encoded_bytes;
+    });
+
   info.encoded_timestamp = rtp_timestamps_.front();
   info.payload_type = cng_payload_type_;
   info.send_even_if_empty = true;
   info.speech = false;
   return info;
 }
 
 AudioEncoder::EncodedInfo AudioEncoderCng::EncodeActive(
     size_t frames_to_encode,
-    size_t max_encoded_bytes,
-    uint8_t* encoded) {
+    rtc::Buffer* encoded) {
   const size_t samples_per_10ms_frame = SamplesPer10msFrame();
   AudioEncoder::EncodedInfo info;
   for (size_t i = 0; i < frames_to_encode; ++i) {
     info =
         speech_encoder_->Encode(rtp_timestamps_.front(),
                                 rtc::ArrayView<const int16_t>(
                                     &speech_buffer_[i * samples_per_10ms_frame],
                                     samples_per_10ms_frame),
-                                max_encoded_bytes, encoded);
+                                encoded);
     if (i + 1 == frames_to_encode) {
       RTC_CHECK_GT(info.encoded_bytes, 0u) << "Encoder didn't deliver data.";
     } else {
       RTC_CHECK_EQ(info.encoded_bytes, 0u)
           << "Encoder delivered data too early.";
     }
   }
   return info;
 }
 
 size_t AudioEncoderCng::SamplesPer10msFrame() const {
   return rtc::CheckedDivExact(10 * SampleRateHz(), 1000);
 }
 
 }  // namespace webrtc