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

webrtc/modules/audio_coding/codecs/audio_encoder.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.
  */
 
 #include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/trace_event.h"
 
 namespace webrtc {
 
 AudioEncoder::EncodedInfo::EncodedInfo() = default;
 
 AudioEncoder::EncodedInfo::~EncodedInfo() = default;
 
 int AudioEncoder::RtpTimestampRateHz() const {
   return SampleRateHz();
 }
 
 AudioEncoder::EncodedInfo AudioEncoder::Encode(
     uint32_t rtp_timestamp,
     rtc::ArrayView<const int16_t> audio,
+    rtc::Buffer* encoded) {
+  TRACE_EVENT0("webrtc", "AudioEncoder::Encode");
+
+  // ossu: I've seen this expressed in several different ways in checks inside
+  // ossu: EncodeInternal in implementations. Should this not suffice?

[kwiberg-webrtc, 2016/02/25 00:29:04]

Well, maybe. But having an assert close to the code serves as documentation for
that code, and also provides protection in case an assert far away (like this
one) is changed or lost. So they're probably useful, I'd say.

[ossu, 2016/02/25 15:58:46]

Acknowledged.

+  RTC_CHECK_EQ(audio.size(),
+               static_cast<size_t>(NumChannels() * SampleRateHz() / 100));
+
+  EncodedInfo info;
+  info = EncodeInternal(rtp_timestamp, audio, encoded);
+  return info;

[kwiberg-webrtc, 2016/02/25 00:29:04]

You can eliminate the local variable and turn these 3 statements into 1...
except you can't do that if you follow my other piece of advice for these lines,
which is to CHECK that the buffer has grown by at most MaxEncodedBytes() bytes.
The reason for doing this is that otherwise new-style encode calls won't break
for encoders with broken MaxEncodedBytes methods.

[ossu, 2016/02/25 10:39:51]

I believe I split this up while debugging and never put it back. I'm not sure we
need an extra check here, though. The AppendData call in the
backwards-compatible EncodeInternal(_, _, Buffer *) already does that check. As
with your previous comment, though, adding a check here would work as
documentation of our expectations. Is the extra doc-ing worth the redundant
CHECK call, or should I just document that this check is performed elsewhere
with a comment?

[kwiberg-webrtc, 2016/02/25 12:24:25]

The backwards-compatible EncodeInternal is only called when a new-style encode
call is made to an old-style encoder. For the new/new case, MaxEncodedBytes is
never run, so encoders that are only tested in new/new mode can have a broken
MaxEncodedBytes and no one will notice until someone makes an old-style encode
call to it.

[ossu, 2016/02/25 15:58:46]

Ah, yes. Right you are!

+}
+
+AudioEncoder::EncodedInfo AudioEncoder::Encode(
+    uint32_t rtp_timestamp,
+    rtc::ArrayView<const int16_t> audio,
+    size_t max_encoded_bytes,
+    uint8_t* encoded) {
+  return DEPRECATED_Encode(rtp_timestamp, audio, max_encoded_bytes, encoded);
+}
+
+AudioEncoder::EncodedInfo AudioEncoder::DEPRECATED_Encode(
+    uint32_t rtp_timestamp,
+    rtc::ArrayView<const int16_t> audio,
     size_t max_encoded_bytes,
     uint8_t* encoded) {
   TRACE_EVENT0("webrtc", "AudioEncoder::Encode");
   RTC_CHECK_EQ(audio.size(),
                static_cast<size_t>(NumChannels() * SampleRateHz() / 100));
   EncodedInfo info =
-      EncodeInternal(rtp_timestamp, audio, max_encoded_bytes, encoded);
+      EncodeInternal(rtp_timestamp, audio,
+                     max_encoded_bytes, encoded);
   RTC_CHECK_LE(info.encoded_bytes, max_encoded_bytes);
   return info;
 }
 
+AudioEncoder::EncodedInfo AudioEncoder::EncodeInternal(
+    uint32_t rtp_timestamp,
+    rtc::ArrayView<const int16_t> audio,
+    rtc::Buffer* encoded)
+{
+  EncodedInfo info;
+  encoded->AppendData(MaxEncodedBytes(), [&] (rtc::ArrayView<uint8_t> encoded) {
+      info = EncodeInternal(rtp_timestamp, audio,
+                            encoded.size(), encoded.data());
+      return info.encoded_bytes;
+    });
+  return info;
+}
+
+AudioEncoder::EncodedInfo AudioEncoder::EncodeInternal(
+    uint32_t rtp_timestamp,
+    rtc::ArrayView<const int16_t> audio,
+    size_t max_encoded_bytes,
+    uint8_t* encoded)
+{
+  rtc::Buffer temp_buffer;
+  EncodedInfo info = EncodeInternal(rtp_timestamp, audio, &temp_buffer);
+  RTC_DCHECK_LE(temp_buffer.size(), max_encoded_bytes);
+  std::memcpy(encoded, temp_buffer.data(), info.encoded_bytes);
+  return info;
+}
+
 bool AudioEncoder::SetFec(bool enable) {
   return !enable;
 }
 
 bool AudioEncoder::SetDtx(bool enable) {
   return !enable;
 }
 
 bool AudioEncoder::SetApplication(Application application) {
   return false;
 }
 
 void AudioEncoder::SetMaxPlaybackRate(int frequency_hz) {}
 
 void AudioEncoder::SetProjectedPacketLossRate(double fraction) {}
 
 void AudioEncoder::SetTargetBitrate(int target_bps) {}
 
 }  // namespace webrtc