Delete always-zero ByteBufferWriter::start_.

webrtc/base/bytebuffer.cc

 /*
  *  Copyright 2004 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 25 matching lines @@
   Construct(bytes, len);
 }
 
 ByteBufferWriter::ByteBufferWriter(const char* bytes, size_t len,
                                    ByteOrder byte_order)
     : ByteBuffer(byte_order) {
   Construct(bytes, len);
 }
 
 void ByteBufferWriter::Construct(const char* bytes, size_t len) {
-  start_ = 0;
   size_ = len;
   bytes_ = new char[size_];
 
   if (bytes) {
     end_ = len;
     memcpy(bytes_, bytes, end_);
   } else {
     end_ = 0;
   }
 }
@@ skipping 55 matching lines @@
 char* ByteBufferWriter::ReserveWriteBuffer(size_t len) {
   if (Length() + len > Capacity())
     Resize(Length() + len);
 
   char* start = bytes_ + end_;
   end_ += len;
   return start;
 }
 
 void ByteBufferWriter::Resize(size_t size) {
-  size_t len = std::min(end_ - start_, size);
+  size_t len = std::min(end_, size);
   if (size <= size_) {
     // Don't reallocate, just move data backwards
-    memmove(bytes_, bytes_ + start_, len);
+    memmove(bytes_, bytes_, len);

[joachim, 2016/10/21 13:11:19]

Sorry, didn't notice this in the first place, but the memmove is a no-op now and
can be removed.

[kwiberg-webrtc, 2016/10/21 15:08:42]

So it DOES take three people to review this... :-)

[tommi (sloooow) - chröme, 2016/10/21 15:15:39]

Indeed!

[nisse-chromium (ooo August 14), 2016/10/24 06:51:06]

Done.

   } else {
     // Reallocate a larger buffer.
     size_ = std::max(size, 3 * size_ / 2);
     char* new_bytes = new char[size_];
-    memcpy(new_bytes, bytes_ + start_, len);
+    memcpy(new_bytes, bytes_, len);
     delete [] bytes_;
     bytes_ = new_bytes;
   }
-  start_ = 0;
   end_ = len;
 }
 
 void ByteBufferWriter::Clear() {
   memset(bytes_, 0, size_);
-  start_ = end_ = 0;
+  end_ = 0;
 }
 
 
 ByteBufferReader::ByteBufferReader(const char* bytes, size_t len)
     : ByteBuffer(ORDER_NETWORK) {
   Construct(bytes, len);
 }
 
 ByteBufferReader::ByteBufferReader(const char* bytes, size_t len,
                                    ByteOrder byte_order)
@@ skipping 128 matching lines @@
 }
 
 bool ByteBufferReader::Consume(size_t size) {
   if (size > Length())
     return false;
   start_ += size;
   return true;
 }
 
 }  // namespace rtc