Split ByteBuffer into writer/reader objects.

webrtc/base/bytebuffer.h

Index: webrtc/base/bytebuffer.h
diff --git a/webrtc/base/bytebuffer.h b/webrtc/base/bytebuffer.h
index ad2e552ed6a8389fffffafa2670fa74b7a709a4e..8fd086367db88d8e6b6fe5e46ff7ded91b7e353a 100644
--- a/webrtc/base/bytebuffer.h
+++ b/webrtc/base/bytebuffer.h
@@ -21,42 +21,34 @@ namespace rtc {
 
 class ByteBuffer {
  public:
-
   enum ByteOrder {
     ORDER_NETWORK = 0,  // Default, use network byte order (big endian).
     ORDER_HOST,         // Use the native order of the host.
   };
 
-  // |byte_order| defines order of bytes in the buffer.
-  ByteBuffer();
-  explicit ByteBuffer(ByteOrder byte_order);
-  ByteBuffer(const char* bytes, size_t len);
-  ByteBuffer(const char* bytes, size_t len, ByteOrder byte_order);
+  explicit ByteBuffer(ByteOrder byte_order) : byte_order_(byte_order) {}
 
-  // Initializes buffer from a zero-terminated string.
-  explicit ByteBuffer(const char* bytes);
+  ByteOrder Order() const { return byte_order_; }
 
-  explicit ByteBuffer(const Buffer& buf);
+ private:
+  ByteOrder byte_order_;
 
-  ~ByteBuffer();
+  RTC_DISALLOW_COPY_AND_ASSIGN(ByteBuffer);
+};
+
+class ByteBufferWriter : public ByteBuffer {
+ public:
+  // |byte_order| defines order of bytes in the buffer.
+  ByteBufferWriter();
+  explicit ByteBufferWriter(ByteOrder byte_order);
+  ByteBufferWriter(const char* bytes, size_t len);
+  ByteBufferWriter(const char* bytes, size_t len, ByteOrder byte_order);
+
+  ~ByteBufferWriter();
 
   const char* Data() const { return bytes_ + start_; }
   size_t Length() const { return end_ - start_; }
   size_t Capacity() const { return size_ - start_; }
-  ByteOrder Order() const { return byte_order_; }
-
-  // Read a next value from the buffer. Return false if there isn't
-  // enough data left for the specified type.
-  bool ReadUInt8(uint8_t* val);
-  bool ReadUInt16(uint16_t* val);
-  bool ReadUInt24(uint32_t* val);
-  bool ReadUInt32(uint32_t* val);
-  bool ReadUInt64(uint64_t* val);
-  bool ReadBytes(char* val, size_t len);
-
-  // Appends next |len| bytes from the buffer to |val|. Returns false
-  // if there is less than |len| bytes left.
-  bool ReadString(std::string* val, size_t len);
 
   // Write value to the buffer. Resizes the buffer when it is
   // neccessary.
@@ -70,51 +62,75 @@ class ByteBuffer {
 
   // Reserves the given number of bytes and returns a char* that can be written
   // into. Useful for functions that require a char* buffer and not a
-  // ByteBuffer.
+  // ByteBufferWriter.
   char* ReserveWriteBuffer(size_t len);
 
-  // Resize the buffer to the specified |size|. This invalidates any remembered
-  // seek positions.
+  // Resize the buffer to the specified |size|.
   void Resize(size_t size);
 
-  // Moves current position |size| bytes forward. Returns false if
-  // there is less than |size| bytes left in the buffer. Consume doesn't
-  // permanently remove data, so remembered read positions are still valid
-  // after this call.
-  bool Consume(size_t size);
-
   // Clears the contents of the buffer. After this, Length() will be 0.
   void Clear();
 
-  // Used with GetReadPosition/SetReadPosition.
-  class ReadPosition {
-    friend class ByteBuffer;
-    ReadPosition(size_t start, int version)
-        : start_(start), version_(version) { }
-    size_t start_;
-    int version_;
-  };
-
-  // Remembers the current read position for a future SetReadPosition. Any
-  // calls to Shift or Resize in the interim will invalidate the position.
-  ReadPosition GetReadPosition() const;
-
-  // If the given position is still valid, restores that read position.
-  bool SetReadPosition(const ReadPosition &position);
-
  private:
-  void Construct(const char* bytes, size_t size, ByteOrder byte_order);
+  void Construct(const char* bytes, size_t size);
 
   char* bytes_;
   size_t size_;
   size_t start_;
   size_t end_;
-  int version_;
-  ByteOrder byte_order_;
 
   // There are sensible ways to define these, but they aren't needed in our code
   // base.
-  RTC_DISALLOW_COPY_AND_ASSIGN(ByteBuffer);
+  RTC_DISALLOW_COPY_AND_ASSIGN(ByteBufferWriter);
+};
+
+// The ByteBufferReader references the passed data, i.e. the pointer must be
+// valid during the lifetime of the reader.
+class ByteBufferReader : public ByteBuffer {
+ public:
+  ByteBufferReader(const char* bytes, size_t len);
+  ByteBufferReader(const char* bytes, size_t len, ByteOrder byte_order);
+
+  // Initializes buffer from a zero-terminated string.
+  explicit ByteBufferReader(const char* bytes);
+
+  explicit ByteBufferReader(const Buffer& buf);
+
+  explicit ByteBufferReader(const ByteBufferWriter& buf);
+
+  // Returns start of unprocessed data.
+  const char* Data() const { return bytes_ + start_; }
+  // Returns number of unprocessed bytes.
+  size_t Length() const { return end_ - start_; }
+
+  // Read a next value from the buffer. Return false if there isn't
+  // enough data left for the specified type.
+  bool ReadUInt8(uint8_t* val);
+  bool ReadUInt16(uint16_t* val);
+  bool ReadUInt24(uint32_t* val);
+  bool ReadUInt32(uint32_t* val);
+  bool ReadUInt64(uint64_t* val);
+  bool ReadBytes(char* val, size_t len);
+
+  // Appends next |len| bytes from the buffer to |val|. Returns false
+  // if there is less than |len| bytes left.
+  bool ReadString(std::string* val, size_t len);
+
+  // Moves current position |size| bytes forward. Returns false if
+  // there is less than |size| bytes left in the buffer. Consume doesn't
+  // permanently remove data, so remembered read positions are still valid
+  // after this call.
+  bool Consume(size_t size);
+
+ private:
+  void Construct(const char* bytes, size_t size);
+
+  const char* bytes_;
+  size_t size_;
+  size_t start_;
+  size_t end_;
+
+  RTC_DISALLOW_COPY_AND_ASSIGN(ByteBufferReader);
 };
 
 }  // namespace rtc