CopyOnWriteBuffer::SetSize to smaller size memcpy less.

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 204 matching lines @@
   void SetSize(size_t size) {
     RTC_DCHECK(IsConsistent());
     if (!buffer_) {
       if (size > 0) {
         buffer_ = new RefCountedObject<Buffer>(size);
       }
       RTC_DCHECK(IsConsistent());
       return;
     }
 
-    CloneDataIfReferenced(std::max(buffer_->capacity(), size));
+    // Clone data if referenced.
+    if (!buffer_->HasOneRef()) {
+      buffer_ = new RefCountedObject<Buffer>(buffer_->data(),
+        std::min(buffer_->size(), size),
+        std::max(buffer_->capacity(), size));

[kwiberg-webrtc, 2016/09/09 08:28:29]

You maintain the capacity of the original buffer here. Is that supposed to
happen everywhere? (Because it seems to be done in many but not all places. And
it does cost some, so we shouldn't be doing it unless we intend to.)

[danilchap, 2016/09/09 11:25:33]

Yes. there is no need to reallocate with full capacity after this change.
Code adjusted to use smaller buffer.

[danilchap, 2016/09/09 12:58:44]

Actually, it is debatable if SetSize allowed to decrease capacity (realized I
need a version that keeps capacity).
Since capacity is a topic for neighbor CL, I'll keep old behavior where capacity
is kept and land just less memcpy change here.

+    }
     buffer_->SetSize(size);
     RTC_DCHECK(IsConsistent());
   }
 
   // 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) {
     RTC_DCHECK(IsConsistent());
     if (!buffer_) {
@@ skipping 45 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_