net: Introduce SeekableIOBuffer and clean up HttpStreamParser.

net/base/io_buffer.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_BASE_IO_BUFFER_H_
 #define NET_BASE_IO_BUFFER_H_
 #pragma once
 
 #include <string>
 
@@ skipping 108 matching lines @@
   int size() const { return string_data_.size(); }
 
  private:
   virtual ~StringIOBuffer();
 
   std::string string_data_;
 };
 
 // This version wraps an existing IOBuffer and provides convenient functions
 // to progressively read all the data.
+//
+// DrainableIOBuffer is useful when you have an IOBuffer that contains data
+// to be written progressively, and Write() function takes an IOBuffer rather
+// than char*. DrainableIOBuffer can be used as follows:
+//
+// // payload is the IOBuffer containing the data to be written.
+// buf = new DrainableIOBuffer(payload, payload_size);
+//
+// while (buf->BytesRemaining() > 0) {
+//   // Write() takes an IOBuffer. If it takes char*, we could
+//   // simply use the regular IOBuffer like payload->data() + offset.
+//   int bytes_written = Write(buf, buf->BytesRemaining());
+//   buf->DidConsume(bytes_written);
+// }
+//
 class NET_EXPORT DrainableIOBuffer : public IOBuffer {
  public:
   DrainableIOBuffer(IOBuffer* base, int size);
 
   // DidConsume() changes the |data_| pointer so that |data_| always points
   // to the first unconsumed byte.
   void DidConsume(int bytes);
 
   // Returns the number of unconsumed bytes.
   int BytesRemaining() const;
 
   // Returns the number of consumed bytes.
   int BytesConsumed() const;
 
   // Seeks to an arbitrary point in the buffer. The notion of bytes consumed
   // and remaining are updated appropriately.
   void SetOffset(int bytes);
 
   int size() const { return size_; }
 
  private:
   virtual ~DrainableIOBuffer();
 
   scoped_refptr<IOBuffer> base_;
   int size_;
   int used_;
 };
 
 // This version provides a resizable buffer and a changeable offset.
+//
+// GrowableIOBuffer is useful when you read data progressively without
+// knowing the total size in advance. GrowableIOBuffer can be used as
+// follows:
+//
+// buf = new GrowableIOBuffer;
+// buf->SetCapacity(1024);  // Initial capacity.
+//
+// while (!some_stream->IsEOF()) {
+//   // Double the capacity if the remaining capacity is empty.
+//   if (buf->RemainingCapacity() == 0)
+//     buf->SetCapacity(buf->capacity() * 2);
+//   int bytes_read = some_stream->Read(buf, buf->RemainingCapacity());
+//   buf->set_offset(buf->offset() + bytes_read);
+// }
+//
 class NET_EXPORT GrowableIOBuffer : public IOBuffer {
  public:
   GrowableIOBuffer();
 
   // realloc memory to the specified capacity.
   void SetCapacity(int capacity);
   int capacity() { return capacity_; }
 
   // |offset| moves the |data_| pointer, allowing "seeking" in the data.
   void set_offset(int offset);
@@ skipping 37 matching lines @@
  public:
   explicit WrappedIOBuffer(const char* data);
 
  protected:
   virtual ~WrappedIOBuffer();
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_IO_BUFFER_H_