Add CopyOnWriteBuffer class

webrtc/base/copyonwritebuffer.h

Index: webrtc/base/copyonwritebuffer.h
diff --git a/webrtc/base/copyonwritebuffer.h b/webrtc/base/copyonwritebuffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..0c86e491e0915f4bb5d7f053e3fa1b62ed00ab5c
--- /dev/null
+++ b/webrtc/base/copyonwritebuffer.h
@@ -0,0 +1,210 @@
+/*
+ *  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.
+ */
+
+#ifndef WEBRTC_BASE_COPYONWRITEBUFFER_H_
+#define WEBRTC_BASE_COPYONWRITEBUFFER_H_
+
+#include <algorithm>  // std::swap (pre-C++11)
+#include <utility>  // std::swap (C++11 and later)

[kwiberg-webrtc, 2016/02/19 12:36:20]

We're guaranteed to be C++11 or later nowadays.

[joachim, 2016/02/19 20:37:42]

Actually still need both. "algorithm" provides "std::max", "utility" provides
"std::swap". Therefore just removed comments.

[kwiberg-webrtc, 2016/02/20 06:43:32]

Acknowledged.

+
+#include "webrtc/base/buffer.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+
+namespace rtc {
+
+class CopyOnWriteBuffer {
+ public:
+  // An empty buffer.
+  CopyOnWriteBuffer();
+  // Copy size and contents of an existing buffer.
+  CopyOnWriteBuffer(const CopyOnWriteBuffer& buf);
+  // Move contents from an existing buffer.
+  CopyOnWriteBuffer(CopyOnWriteBuffer&& buf);
+
+  // Construct a buffer with the specified number of uninitialized bytes.
+  explicit CopyOnWriteBuffer(size_t size);
+  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);
+  }
+
+  // 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*,
+  // but you may also use .data<int8_t>() and .data<char>().
+  template <typename T = uint8_t, typename internal::ByteType<T>::t = 0>
+  const T* data() const {
+    if (!buffer_) {
+      return nullptr;
+    }
+    return reinterpret_cast<T*>(buffer_->data());

[kwiberg-webrtc, 2016/02/19 12:36:20]

I think you can write

  return buffer_->data<T>();

instead.

[joachim, 2016/02/19 20:37:42]

Done.

+  }
+
+  // Get writable pointer to the data. This will create a copy of the underlying
+  // data if it is shared with other buffers.
+  template <typename T = uint8_t, typename internal::ByteType<T>::t = 0>
+  T* data() {
+    if (!buffer_) {
+      return nullptr;
+    }
+    CloneDataIfReferenced(buffer_->capacity());
+    return reinterpret_cast<T*>(buffer_->data());

[kwiberg-webrtc, 2016/02/19 12:36:20]

data<T>()

[joachim, 2016/02/19 20:37:42]

Done.

+  }
+
+  size_t size() const {
+    return buffer_ ? buffer_->size() : 0;
+  }
+
+  size_t capacity() const {
+    return buffer_ ? buffer_->capacity() : 0;
+  }
+
+  CopyOnWriteBuffer& operator=(const CopyOnWriteBuffer& buf) {
+    if (&buf != this) {
+      buffer_ = buf.buffer_;
+    }
+    return *this;
+  }
+
+  CopyOnWriteBuffer& operator=(CopyOnWriteBuffer&& buf) {
+    buffer_ = std::move(buf.buffer_);

[kwiberg-webrtc, 2016/02/19 12:36:20]

IIRC, we concluded earlier that scoped_refptr doesn't have move. So swap + set
to null is probably a better choice.

For bonus points, post a bug about scoped_refptr needing move support and link
to it from here.

[joachim, 2016/02/19 20:37:42]

Done + bonus points ;-)

+    return *this;
+  }
+
+  bool operator==(const CopyOnWriteBuffer& buf) const {
+    // Must either use the same buffer internally or have the same contents.
+    return buffer_.get() == buf.buffer_.get() ||
+        (buffer_.get() && buf.buffer_.get() &&
+        *buffer_.get() == *buf.buffer_.get());
+  }
+
+  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) {
+    if (!buffer_ || !buffer_->HasOneRef()) {
+      buffer_ = new RefCountedObject<Buffer>(data, size, size);
+    } else {
+      buffer_->SetData(data, size);
+    }
+  }
+
+  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) {
+    if (&buf != this) {
+      buffer_ = buf.buffer_;
+    }
+  }
+
+  // Append data to the buffer. Accepts the same types as the constructors.
+  template <typename T, typename internal::ByteType<T>::t = 0>
+  void AppendData(const T* data, size_t size) {
+    if (!buffer_) {
+      buffer_ = new RefCountedObject<Buffer>(data, size);
+      return;
+    }
+
+    CloneDataIfReferenced(std::max(buffer_->capacity(),
+        buffer_->size() + size));
+    buffer_->AppendData(data, size);
+  }
+
+  template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
+  void AppendData(const T(&array)[N]) {
+    AppendData(array, N);
+  }
+
+  void AppendData(const CopyOnWriteBuffer& buf) {
+    AppendData(buf.data(), buf.size());
+  }
+
+  // Sets the size of the buffer. If the new size is smaller than the old, the
+  // buffer contents will be kept but truncated; if the new size is greater,
+  // the existing contents will be kept and the new space will be
+  // uninitialized.
+  void SetSize(size_t size) {
+    if (!buffer_) {

[kwiberg-webrtc, 2016/02/19 12:36:20]

!buffer_ && size > 0

Otherwise, you violate the "buffer capacity is > 0" invariant.

[joachim, 2016/02/19 20:37:42]

Done.

+      buffer_ = new RefCountedObject<Buffer>(size);
+      return;
+    }
+
+    CloneDataIfReferenced(std::max(buffer_->capacity(), size));
+    buffer_->SetSize(size);
+  }
+
+  // Ensure that the buffer size can be increased to at least capacity without
+  // further reallocation. (Of course, this operation might need to reallocate
+  // the buffer.)
+  void EnsureCapacity(size_t capacity) {
+    if (!buffer_) {

[kwiberg-webrtc, 2016/02/19 12:36:20]

!buffer_ && capacity > 0

for the same reason as above.

[joachim, 2016/02/19 20:37:42]

Done.

+      buffer_ = new RefCountedObject<Buffer>(0, capacity);
+      return;
+    } else if (capacity <= buffer_->capacity()) {
+      return;
+    }
+
+    CloneDataIfReferenced(std::max(buffer_->capacity(), capacity));
+    buffer_->EnsureCapacity(capacity);
+  }
+
+  // Resets the buffer to zero size and capacity.
+  void Clear() {
+    if (!buffer_ || !buffer_->HasOneRef()) {
+      buffer_ = nullptr;
+    } else {
+      buffer_->Clear();
+    }
+  }
+
+  // Swaps two buffers.
+  friend void swap(CopyOnWriteBuffer& a, CopyOnWriteBuffer& b) {
+    std::swap(a.buffer_, b.buffer_);
+  }
+
+ private:
+  // Create a copy of the underlying data if it is referenced from other Buffer
+  // objects.
+  void CloneDataIfReferenced(size_t new_capacity) {
+    if (buffer_->HasOneRef()) {
+      return;
+    }
+
+    buffer_ = new RefCountedObject<Buffer>(buffer_->data(), buffer_->size(),
+        new_capacity);
+  }
+
+  scoped_refptr< RefCountedObject<Buffer> > buffer_;

[kwiberg-webrtc, 2016/02/19 12:36:20]

All those extra spaces aren't necessary, because C++11.

Oh, and is't probably a good idea to document either that buffer_'s capacity is
always >0, or that there are two ways to represent a capacity-0 buffer.

[joachim, 2016/02/19 20:37:42]

Done.

+};
+
+}  // namespace rtc
+
+#endif  // WEBRTC_BASE_COPYONWRITEBUFFER_H_