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

webrtc/modules/audio_coding/codecs/audio_encoder.cc

Index: webrtc/modules/audio_coding/codecs/audio_encoder.cc
diff --git a/webrtc/modules/audio_coding/codecs/audio_encoder.cc b/webrtc/modules/audio_coding/codecs/audio_encoder.cc
index e99fc30995995dea55ba1bcae4347b784e4691f3..2384bf092995ade391006ebadd2fa68cb17d10c2 100644
--- a/webrtc/modules/audio_coding/codecs/audio_encoder.cc
+++ b/webrtc/modules/audio_coding/codecs/audio_encoder.cc
@@ -26,17 +26,69 @@ int AudioEncoder::RtpTimestampRateHz() const {
 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;
 }