Add WriteUVarint to ByteBufferWriter and ReadUVarint to ByteBufferReader

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 70 matching lines @@
 void ByteBufferWriter::WriteUInt32(uint32_t val) {
   uint32_t v = (Order() == ORDER_NETWORK) ? HostToNetwork32(val) : val;
   WriteBytes(reinterpret_cast<const char*>(&v), 4);
 }
 
 void ByteBufferWriter::WriteUInt64(uint64_t val) {
   uint64_t v = (Order() == ORDER_NETWORK) ? HostToNetwork64(val) : val;
   WriteBytes(reinterpret_cast<const char*>(&v), 8);
 }
 
+// Serializes an unsigned varint in the format described by
+// https://developers.google.com/protocol-buffers/docs/encoding#varints
+// with the caveat that integers are 64-bit, not 128-bit.
+void ByteBufferWriter::WriteUVarint(uint64_t val) {
+  while (val >= 0x80) {
+    // Write 7 bits at a time, then set the msb to a continuation byte (msb=1).
+    char byte = static_cast<char>(val) | 0x80;
+    WriteBytes(&byte, 1);
+    val >>= 7;
+  }
+  char last_byte = static_cast<char>(val);
+  WriteBytes(&last_byte, 1);
+}
+
 void ByteBufferWriter::WriteString(const std::string& val) {
   WriteBytes(val.c_str(), val.size());
 }
 
 void ByteBufferWriter::WriteBytes(const char* val, size_t len) {
   memcpy(ReserveWriteBuffer(len), val, len);
 }
 
 char* ByteBufferWriter::ReserveWriteBuffer(size_t len) {
   if (Length() + len > Capacity())
@@ skipping 112 matching lines @@
 
   uint64_t v;
   if (!ReadBytes(reinterpret_cast<char*>(&v), 8)) {
     return false;
   } else {
     *val = (Order() == ORDER_NETWORK) ? NetworkToHost64(v) : v;
     return true;
   }
 }
 
+bool ByteBufferReader::ReadUVarint(uint64_t* val) {
+  if (!val) {
+    return false;
+  }
+  // Integers are deserialized 7 bits at a time, with each byte having a
+  // continuation byte (msb=1) if there are more bytes to be read.
+  uint64_t v = 0;
+  for (int i = 0; i < 64; i += 7) {
+    char byte;
+    if (!ReadBytes(&byte, 1)) {
+      return false;
+    }
+    // Read the first 7 bits of the byte, then offset by bits read so far.
+    v |= (static_cast<uint64_t>(byte) & 0x7F) << i;
+    // True if the msb is not a continuation byte.
+    if (static_cast<uint64_t>(byte) < 0x80) {
+      *val = v;
+      return true;
+    }
+  }
+  return false;
+}
+
 bool ByteBufferReader::ReadString(std::string* val, size_t len) {
   if (!val) return false;
 
   if (len > Length()) {
     return false;
   } else {
     val->append(bytes_ + start_, len);
     start_ += len;
     return true;
   }
@@ skipping 10 matching lines @@
 }
 
 bool ByteBufferReader::Consume(size_t size) {
   if (size > Length())
     return false;
   start_ += size;
   return true;
 }
 
 }  // namespace rtc