Use CopyOnWriteBuffer instead of Buffer to avoid unnecessary copies.

webrtc/base/copyonwritebuffer.h

 /*
  *  Copyright 2016 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 24 matching lines @@
   CopyOnWriteBuffer(size_t size, size_t capacity);
 
   // Construct a buffer and copy the specified number of bytes into it. The
   // source array may be (const) uint8_t*, int8_t*, or char*.
   template <typename T, typename internal::ByteType<T>::t = 0>
   CopyOnWriteBuffer(const T* data, size_t size)
       : CopyOnWriteBuffer(data, size, size) {}
   template <typename T, typename internal::ByteType<T>::t = 0>
   CopyOnWriteBuffer(const T* data, size_t size, size_t capacity)
       : CopyOnWriteBuffer(size, capacity) {
-    std::memcpy(buffer_->data(), data, size);
+    if (size > 0) {
+      std::memcpy(buffer_->data(), data, size);
+    }

[kwiberg-webrtc, 2016/03/14 11:53:49]

The reason for having the conditional is clearer if you write the (equivalent)
if (buffer_) instead.

[joachim, 2016/03/17 20:27:21]

Done.

   }
 
   // Construct a buffer from the contents of an array.
   template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
   CopyOnWriteBuffer(const T(&array)[N])  // NOLINT: runtime/explicit
       : CopyOnWriteBuffer(array, N) {}
 
   ~CopyOnWriteBuffer();
 
   // Get a pointer to the data. Just .data() will give you a (const) uint8_t*,
@@ skipping 65 matching lines @@
 
   bool operator!=(const CopyOnWriteBuffer& buf) const {
     return !(*this == buf);
   }
 
   // Replace the contents of the buffer. Accepts the same types as the
   // constructors.
   template <typename T, typename internal::ByteType<T>::t = 0>
   void SetData(const T* data, size_t size) {
     RTC_DCHECK(IsConsistent());
-    if (!buffer_ || !buffer_->HasOneRef()) {
-      buffer_ = new RefCountedObject<Buffer>(data, size, size);
-    } else {
+    if (size && (!buffer_ || !buffer_->HasOneRef())) {
+      buffer_ = new RefCountedObject<Buffer>(data, size);
+    } else if (buffer_) {
       buffer_->SetData(data, size);
     }
     RTC_DCHECK(IsConsistent());

[kwiberg-webrtc, 2016/03/14 11:53:49]

Hmm. This is still wrong: if size == 0 and !buffer_->HasOneRef(), you'll modify
the shared buffer. I think it should be something like

if (!buffer_ || !buffer_->HasOneRef()) {
  buffer_ = size > 0 ? new RefCountedObject<Buffer>(data, size)
                     : nullptr;
} else {
  buffer_->SetData(data, size);
}

[joachim, 2016/03/17 20:27:21]

Thanks. Changed and added a test.

   }
 
   template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
   void SetData(const T(&array)[N]) {
     SetData(array, N);
   }
 
   void SetData(const CopyOnWriteBuffer& buf) {
     RTC_DCHECK(IsConsistent());
     RTC_DCHECK(buf.IsConsistent());
@@ skipping 100 matching lines @@
     return (!buffer_ || buffer_->capacity() > 0);
   }
 
   // buffer_ is either null, or points to an rtc::Buffer with capacity > 0.
   scoped_refptr<RefCountedObject<Buffer>> buffer_;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_COPYONWRITEBUFFER_H_