Use CopyOnWriteBuffer instead of Buffer to avoid unnecessary copies.

webrtc/base/copyonwritebuffer_unittest.cc

 /*
  *  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 23 matching lines @@
 }
 
 void EnsureBuffersDontShareData(const CopyOnWriteBuffer& buf1,
                                 const CopyOnWriteBuffer& buf2) {
   // Data is not shared between buffers.
   const uint8_t* data1 = buf1.cdata();
   const uint8_t* data2 = buf2.cdata();
   EXPECT_NE(data1, data2);
 }
 
+TEST(CopyOnWriteBufferTest, TestCreateEmptyData) {
+  CopyOnWriteBuffer buf(static_cast<const uint8_t*>(nullptr), 0);

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

Do you need the static_cast here?

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

Yes, otherwise compilation fails with

error: no matching constructor for initialization of 'rtc::CopyOnWriteBuffer'
note: candidate constructor not viable: no known conversion from 'nullptr_t' to
'size_t' (aka 'unsigned long') for 1st argument
  CopyOnWriteBuffer(size_t size, size_t capacity);
  ^
note: candidate template ignored: could not match 'const T *' against
'nullptr_t'
  CopyOnWriteBuffer(const T* data, size_t size)
  ^

...and similar errors...

[kwiberg-webrtc, 2016/03/18 05:27:11]

Right. Thanks.

+  EXPECT_EQ(buf.size(), 0u);
+  EXPECT_EQ(buf.capacity(), 0u);
+  EXPECT_EQ(buf.data(), nullptr);
+}
+
 TEST(CopyOnWriteBufferTest, TestMoveConstruct) {
   CopyOnWriteBuffer buf1(kTestData, 3, 10);
   size_t buf1_size = buf1.size();
   size_t buf1_capacity = buf1.capacity();
   const uint8_t* buf1_data = buf1.cdata();
 
   CopyOnWriteBuffer buf2(std::move(buf1));
   EXPECT_EQ(buf1.size(), 0u);
   EXPECT_EQ(buf1.capacity(), 0u);
   EXPECT_EQ(buf1.data(), nullptr);
@@ skipping 66 matching lines @@
   CopyOnWriteBuffer buf3(buf1);
   // buf3 is re-allocated with new data, existing buffers are not modified.
   buf3.SetData("foo");
   EXPECT_EQ(buf1, CopyOnWriteBuffer(kTestData, 3));
   EnsureBuffersShareData(buf1, buf2);
   EnsureBuffersDontShareData(buf1, buf3);
   const int8_t exp[] = {'f', 'o', 'o', 0x0};
   EXPECT_EQ(buf3, CopyOnWriteBuffer(exp));
 }
 
+TEST(CopyOnWriteBufferTest, TestSetDataEmpty) {
+  CopyOnWriteBuffer buf;
+  buf.SetData(static_cast<const uint8_t*>(nullptr), 0u);

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

...and here?

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

see above

[kwiberg-webrtc, 2016/03/18 05:27:11]

Acknowledged.

+  EXPECT_EQ(buf.size(), 0u);
+  EXPECT_EQ(buf.capacity(), 0u);
+  EXPECT_EQ(buf.data(), nullptr);
+}
+
 TEST(CopyOnWriteBufferTest, TestEnsureCapacity) {
   CopyOnWriteBuffer buf1(kTestData, 3, 10);
   CopyOnWriteBuffer buf2(buf1);
 
   // Smaller than existing capacity -> no change and still same contents.
   buf2.EnsureCapacity(8);
   EnsureBuffersShareData(buf1, buf2);
   EXPECT_EQ(buf1.size(), 3u);
   EXPECT_EQ(buf1.capacity(), 10u);
   EXPECT_EQ(buf2.size(), 3u);
@@ skipping 50 matching lines @@
   const uint8_t* data1 = buf1.data();
   const uint8_t* data2 = buf2.data();
   EXPECT_NE(data1, data2);
   // buf1 was cloned above.
   EXPECT_NE(data1, cdata1);
   // Therefore buf2 was no longer sharing data and was not cloned.
   EXPECT_EQ(data2, cdata1);
 }
 
 }  // namespace rtc