Split ByteBuffer into writer/reader objects.

webrtc/p2p/base/stun.h

 /*
  *  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 162 matching lines @@
   bool AddMessageIntegrity(const char* key, size_t keylen);
 
   // Verifies that a given buffer is STUN by checking for a correct FINGERPRINT.
   static bool ValidateFingerprint(const char* data, size_t size);
 
   // Adds a FINGERPRINT attribute that is valid for the current message.
   bool AddFingerprint();
 
   // Parses the STUN packet in the given buffer and records it here. The
   // return value indicates whether this was successful.
-  bool Read(rtc::ByteBuffer* buf);
+  bool Read(rtc::ByteBufferReader* buf);
 
   // Writes this object into a STUN packet. The return value indicates whether
   // this was successful.
-  bool Write(rtc::ByteBuffer* buf) const;
+  bool Write(rtc::ByteBufferWriter* buf) const;
 
   // Creates an empty message. Overridable by derived classes.
   virtual StunMessage* CreateNew() const { return new StunMessage(); }
 
  protected:
   // Verifies that the given attribute is allowed for this message.
   virtual StunAttributeValueType GetAttributeValueType(int type) const;
 
  private:
   StunAttribute* CreateAttribute(int type, size_t length) /* const*/;
@@ skipping 16 matching lines @@
   size_t length() const { return length_; }
 
   // Return the type of this attribute.
   virtual StunAttributeValueType value_type() const = 0;
 
   // Only XorAddressAttribute needs this so far.
   virtual void SetOwner(StunMessage* owner) {}
 
   // Reads the body (not the type or length) for this type of attribute from
   // the given buffer.  Return value is true if successful.
-  virtual bool Read(rtc::ByteBuffer* buf) = 0;
+  virtual bool Read(rtc::ByteBufferReader* buf) = 0;
 
   // Writes the body (not the type or length) to the given buffer.  Return
   // value is true if successful.
-  virtual bool Write(rtc::ByteBuffer* buf) const = 0;
+  virtual bool Write(rtc::ByteBufferWriter* buf) const = 0;
 
   // Creates an attribute object with the given type and smallest length.
   static StunAttribute* Create(StunAttributeValueType value_type,
                                uint16_t type,
                                uint16_t length,
                                StunMessage* owner);
   // TODO: Allow these create functions to take parameters, to reduce
   // the amount of work callers need to do to initialize attributes.
   static StunAddressAttribute* CreateAddress(uint16_t type);
   static StunXorAddressAttribute* CreateXorAddress(uint16_t type);
   static StunUInt32Attribute* CreateUInt32(uint16_t type);
   static StunUInt64Attribute* CreateUInt64(uint16_t type);
   static StunByteStringAttribute* CreateByteString(uint16_t type);
   static StunErrorCodeAttribute* CreateErrorCode();
   static StunUInt16ListAttribute* CreateUnknownAttributes();
 
  protected:
   StunAttribute(uint16_t type, uint16_t length);
   void SetLength(uint16_t length) { length_ = length; }
-  void WritePadding(rtc::ByteBuffer* buf) const;
-  void ConsumePadding(rtc::ByteBuffer* buf) const;
+  void WritePadding(rtc::ByteBufferWriter* buf) const;
+  void ConsumePadding(rtc::ByteBufferReader* buf) const;
 
  private:
   uint16_t type_;
   uint16_t length_;
 };
 
 // Implements STUN attributes that record an Internet address.
 class StunAddressAttribute : public StunAttribute {
  public:
   static const uint16_t SIZE_UNDEF = 0;
@@ skipping 23 matching lines @@
   void SetAddress(const rtc::SocketAddress& addr) {
     address_ = addr;
     EnsureAddressLength();
   }
   void SetIP(const rtc::IPAddress& ip) {
     address_.SetIP(ip);
     EnsureAddressLength();
   }
   void SetPort(uint16_t port) { address_.SetPort(port); }
 
-  virtual bool Read(rtc::ByteBuffer* buf);
-  virtual bool Write(rtc::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBufferReader* buf);
+  virtual bool Write(rtc::ByteBufferWriter* buf) const;
 
  private:
   void EnsureAddressLength() {
     switch (family()) {
       case STUN_ADDRESS_IPV4: {
         SetLength(SIZE_IP4);
         break;
       }
       case STUN_ADDRESS_IPV6: {
         SetLength(SIZE_IP6);
@@ skipping 15 matching lines @@
  public:
   StunXorAddressAttribute(uint16_t type, const rtc::SocketAddress& addr);
   StunXorAddressAttribute(uint16_t type, uint16_t length, StunMessage* owner);
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_XOR_ADDRESS;
   }
   virtual void SetOwner(StunMessage* owner) {
     owner_ = owner;
   }
-  virtual bool Read(rtc::ByteBuffer* buf);
-  virtual bool Write(rtc::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBufferReader* buf);
+  virtual bool Write(rtc::ByteBufferWriter* buf) const;
 
  private:
   rtc::IPAddress GetXoredIP() const;
   StunMessage* owner_;
 };
 
 // Implements STUN attributes that record a 32-bit integer.
 class StunUInt32Attribute : public StunAttribute {
  public:
   static const uint16_t SIZE = 4;
   StunUInt32Attribute(uint16_t type, uint32_t value);
   explicit StunUInt32Attribute(uint16_t type);
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_UINT32;
   }
 
   uint32_t value() const { return bits_; }
   void SetValue(uint32_t bits) { bits_ = bits; }
 
   bool GetBit(size_t index) const;
   void SetBit(size_t index, bool value);
 
-  virtual bool Read(rtc::ByteBuffer* buf);
-  virtual bool Write(rtc::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBufferReader* buf);
+  virtual bool Write(rtc::ByteBufferWriter* buf) const;
 
  private:
   uint32_t bits_;
 };
 
 class StunUInt64Attribute : public StunAttribute {
  public:
   static const uint16_t SIZE = 8;
   StunUInt64Attribute(uint16_t type, uint64_t value);
   explicit StunUInt64Attribute(uint16_t type);
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_UINT64;
   }
 
   uint64_t value() const { return bits_; }
   void SetValue(uint64_t bits) { bits_ = bits; }
 
-  virtual bool Read(rtc::ByteBuffer* buf);
-  virtual bool Write(rtc::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBufferReader* buf);
+  virtual bool Write(rtc::ByteBufferWriter* buf) const;
 
  private:
   uint64_t bits_;
 };
 
 // Implements STUN attributes that record an arbitrary byte string.
 class StunByteStringAttribute : public StunAttribute {
  public:
   explicit StunByteStringAttribute(uint16_t type);
   StunByteStringAttribute(uint16_t type, const std::string& str);
   StunByteStringAttribute(uint16_t type, const void* bytes, size_t length);
   StunByteStringAttribute(uint16_t type, uint16_t length);
   ~StunByteStringAttribute();
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_BYTE_STRING;
   }
 
   const char* bytes() const { return bytes_; }
   std::string GetString() const { return std::string(bytes_, length()); }
 
   void CopyBytes(const char* bytes);  // uses strlen
   void CopyBytes(const void* bytes, size_t length);
 
   uint8_t GetByte(size_t index) const;
   void SetByte(size_t index, uint8_t value);
 
-  virtual bool Read(rtc::ByteBuffer* buf);
-  virtual bool Write(rtc::ByteBuffer* buf) const;
+  virtual bool Read(rtc::ByteBufferReader* buf);
+  virtual bool Write(rtc::ByteBufferWriter* buf) const;
 
  private:
   void SetBytes(char* bytes, size_t length);
 
   char* bytes_;
 };
 
 // Implements STUN attributes that record an error code.
 class StunErrorCodeAttribute : public StunAttribute {
  public:
@@ skipping 11 matching lines @@
   void SetCode(int code);
 
   // The individual error components.
   int eclass() const { return class_; }
   int number() const { return number_; }
   const std::string& reason() const { return reason_; }
   void SetClass(uint8_t eclass) { class_ = eclass; }
   void SetNumber(uint8_t number) { number_ = number; }
   void SetReason(const std::string& reason);
 
-  bool Read(rtc::ByteBuffer* buf);
-  bool Write(rtc::ByteBuffer* buf) const;
+  bool Read(rtc::ByteBufferReader* buf);
+  bool Write(rtc::ByteBufferWriter* buf) const;
 
  private:
   uint8_t class_;
   uint8_t number_;
   std::string reason_;
 };
 
 // Implements STUN attributes that record a list of attribute names.
 class StunUInt16ListAttribute : public StunAttribute {
  public:
   StunUInt16ListAttribute(uint16_t type, uint16_t length);
   ~StunUInt16ListAttribute();
 
   virtual StunAttributeValueType value_type() const {
     return STUN_VALUE_UINT16_LIST;
   }
 
   size_t Size() const;
   uint16_t GetType(int index) const;
   void SetType(int index, uint16_t value);
   void AddType(uint16_t value);
 
-  bool Read(rtc::ByteBuffer* buf);
-  bool Write(rtc::ByteBuffer* buf) const;
+  bool Read(rtc::ByteBufferReader* buf);
+  bool Write(rtc::ByteBufferWriter* buf) const;
 
  private:
   std::vector<uint16_t>* attr_types_;
 };
 
 // Returns the (successful) response type for the given request type.
 // Returns -1 if |request_type| is not a valid request type.
 int GetStunSuccessResponseType(int request_type);
 
 // Returns the error response type for the given request type.
@@ skipping 155 matching lines @@
       case STUN_ATTR_ICE_CONTROLLING: return STUN_VALUE_UINT64;
       default: return StunMessage::GetAttributeValueType(type);
     }
   }
   virtual StunMessage* CreateNew() const { return new IceMessage(); }
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_STUN_H_