Make CopyOnWriteBuffer keep capacity

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 98 matching lines @@
   buf2.AppendData("foo");
   EXPECT_EQ(buf2.size(), buf1.size() + 4);  // "foo" + trailing 0x00
   EXPECT_EQ(buf2.capacity(), buf1.capacity());
   EXPECT_NE(buf2.data(), buf1.data());
 
   EXPECT_EQ(buf1, CopyOnWriteBuffer(kTestData, 3));
   const int8_t exp[] = {0x0, 0x1, 0x2, 'f', 'o', 'o', 0x0};
   EXPECT_EQ(buf2, CopyOnWriteBuffer(exp));
 }
 
-TEST(CopyOnWriteBufferTest, TestSetData) {
+TEST(CopyOnWriteBufferTest, SetEmptyData) {
+  CopyOnWriteBuffer buf(10);
+
+  buf.SetData<uint8_t>(nullptr, 0);
+
+  EXPECT_EQ(0u, buf.size());
+}
+
+TEST(CopyOnWriteBufferTest, SetDataNoMoreThanCapacityDoesntCauseReallocation) {
+  CopyOnWriteBuffer buf1(3, 10);
+  const uint8_t* const original_allocation = buf1.cdata();
+
+  buf1.SetData(kTestData, 10);
+
+  EXPECT_EQ(original_allocation, buf1.cdata());
+  EXPECT_EQ(buf1, CopyOnWriteBuffer(kTestData, 10));
+}
+
+TEST(CopyOnWriteBufferTest, SetDataMakeReferenceCopy) {
   CopyOnWriteBuffer buf1(kTestData, 3, 10);
   CopyOnWriteBuffer buf2;
 
   buf2.SetData(buf1);
-  // buf2 shares the same data as buf1 now.
+
+  EnsureBuffersShareData(buf1, buf2);
+}
+
+TEST(CopyOnWriteBufferTest, SetDataOnSharedKeepsOriginal) {
+  const uint8_t data[] = "foo";
+  CopyOnWriteBuffer buf1(kTestData, 3, 10);
+  const uint8_t* const original_allocation = buf1.cdata();
+  CopyOnWriteBuffer buf2(buf1);
+
+  buf2.SetData(data);
+
+  EnsureBuffersDontShareData(buf1, buf2);
+  EXPECT_EQ(original_allocation, buf1.cdata());
+  EXPECT_EQ(buf1, CopyOnWriteBuffer(kTestData, 3));
+  EXPECT_EQ(buf2, CopyOnWriteBuffer(data));
+}
+
+TEST(CopyOnWriteBufferTest, SetDataOnSharedKeepsCapacity) {
+  CopyOnWriteBuffer buf1(kTestData, 3, 10);
+  CopyOnWriteBuffer buf2(buf1);
   EnsureBuffersShareData(buf1, buf2);
 
-  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));
+  buf2.SetData(kTestData, 2);
 
-  buf2.SetData(static_cast<const uint8_t*>(nullptr), 0u);
   EnsureBuffersDontShareData(buf1, buf2);
-  EXPECT_EQ(buf1.size(), 3u);
-  EXPECT_EQ(buf1.capacity(), 10u);
-  EXPECT_EQ(buf2.size(), 0u);
-  EXPECT_EQ(buf2.capacity(), 0u);
-}
-
-TEST(CopyOnWriteBufferTest, TestSetDataEmpty) {
-  CopyOnWriteBuffer buf;
-  buf.SetData(static_cast<const uint8_t*>(nullptr), 0u);
-  EXPECT_EQ(buf.size(), 0u);
-  EXPECT_EQ(buf.capacity(), 0u);
-  EXPECT_EQ(buf.data(), nullptr);
+  EXPECT_EQ(2u, buf2.size());
+  EXPECT_EQ(10u, buf2.capacity());
 }
 
 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);
   EXPECT_EQ(buf2.capacity(), 10u);
 
   // Lager than existing capacity -> data is cloned.
   buf2.EnsureCapacity(16);
   EnsureBuffersDontShareData(buf1, buf2);
   EXPECT_EQ(buf1.size(), 3u);
   EXPECT_EQ(buf1.capacity(), 10u);
   EXPECT_EQ(buf2.size(), 3u);
   EXPECT_EQ(buf2.capacity(), 16u);
   // The size and contents are still the same.
   EXPECT_EQ(buf1, buf2);
 }
 
-TEST(CopyOnWriteBufferTest, TestSetSize) {
+TEST(CopyOnWriteBufferTest, SetSizeDoesntChangeOriginal) {
+  CopyOnWriteBuffer buf1(kTestData, 3, 10);
+  const uint8_t* const original_allocation = buf1.cdata();
+  CopyOnWriteBuffer buf2(buf1);
+
+  buf2.SetSize(16);
+
+  EnsureBuffersDontShareData(buf1, buf2);
+  EXPECT_EQ(original_allocation, buf1.cdata());
+  EXPECT_EQ(3u, buf1.size());
+  EXPECT_EQ(10u, buf1.capacity());
+}
+
+TEST(CopyOnWriteBufferTest, SetSizeCloneContent) {
   CopyOnWriteBuffer buf1(kTestData, 3, 10);
   CopyOnWriteBuffer buf2(buf1);
 
   buf2.SetSize(16);
-  EnsureBuffersDontShareData(buf1, buf2);
-  EXPECT_EQ(buf1.size(), 3u);
-  EXPECT_EQ(buf1.capacity(), 10u);
+
   EXPECT_EQ(buf2.size(), 16u);
-  EXPECT_EQ(buf2.capacity(), 16u);
-  // The contents got cloned.
   EXPECT_EQ(0, memcmp(buf2.data(), kTestData, 3));
 }
 
-TEST(CopyOnWriteBufferTest, TestClear) {
+TEST(CopyOnWriteBufferTest, SetSizeMayIncreaseCapacity) {
+  CopyOnWriteBuffer buf(kTestData, 3, 10);
+
+  buf.SetSize(16);
+
+  EXPECT_EQ(16u, buf.size());
+  EXPECT_EQ(16u, buf.capacity());
+}
+
+TEST(CopyOnWriteBufferTest, SetSizeDoesntDecreaseCapacity) {
+  CopyOnWriteBuffer buf1(kTestData, 5, 10);
+  CopyOnWriteBuffer buf2(buf1);
+
+  buf2.SetSize(2);
+
+  EXPECT_EQ(2u, buf2.size());
+  EXPECT_EQ(10u, buf2.capacity());
+}
+
+TEST(CopyOnWriteBufferTest, ClearDoesntChangeOriginal) {
+  CopyOnWriteBuffer buf1(kTestData, 3, 10);
+  const uint8_t* const original_allocation = buf1.cdata();
+  CopyOnWriteBuffer buf2(buf1);
+
+  buf2.Clear();
+
+  EnsureBuffersDontShareData(buf1, buf2);
+  EXPECT_EQ(3u, buf1.size());
+  EXPECT_EQ(10u, buf1.capacity());
+  EXPECT_EQ(original_allocation, buf1.cdata());
+  EXPECT_EQ(0u, buf2.size());
+}
+
+TEST(CopyOnWriteBufferTest, ClearDoesntChangeCapacity) {
   CopyOnWriteBuffer buf1(kTestData, 3, 10);
   CopyOnWriteBuffer buf2(buf1);
 
   buf2.Clear();
-  EnsureBuffersDontShareData(buf1, buf2);
-  EXPECT_EQ(buf1.size(), 3u);
-  EXPECT_EQ(buf1.capacity(), 10u);
-  EXPECT_EQ(0, memcmp(buf1.data(), kTestData, 3));
-  EXPECT_EQ(buf2.size(), 0u);
-  EXPECT_EQ(buf2.capacity(), 0u);
+
+  EXPECT_EQ(0u, buf2.size());
+  EXPECT_EQ(10u, buf2.capacity());
 }
 
 TEST(CopyOnWriteBufferTest, TestConstDataAccessor) {
   CopyOnWriteBuffer buf1(kTestData, 3, 10);
   CopyOnWriteBuffer buf2(buf1);
 
   // .cdata() doesn't clone data.
   const uint8_t* cdata1 = buf1.cdata();
   const uint8_t* cdata2 = buf2.cdata();
   EXPECT_EQ(cdata1, cdata2);
@@ skipping 41 matching lines @@
     buf1[i] = kTestData[i] + 1;
   }
   EXPECT_EQ(buf1.size(), 3u);
   EXPECT_EQ(buf1.capacity(), 10u);
   EXPECT_EQ(buf2.size(), 3u);
   EXPECT_EQ(buf2.capacity(), 10u);
   EXPECT_EQ(0, memcmp(buf2.cdata(), kTestData, 3));
 }
 
 }  // namespace rtc