net: Introduce SeekableIOBuffer and clean up HttpStreamParser.

net/http/http_stream_parser.cc

 // Copyright (c) 2012 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.
 
 #include "net/http/http_stream_parser.h"
 
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "net/base/address_list.h"
@@ skipping 49 matching lines @@
 
 }  // namespace
 
 namespace net {
 
 // 2 CRLFs + max of 8 hex chars.
 const size_t HttpStreamParser::kChunkHeaderFooterSize = 12;
 
 HttpStreamParser::HttpStreamParser(ClientSocketHandle* connection,
                                    const HttpRequestInfo* request,
                                    GrowableIOBuffer* read_buffer,

[rvargas (doing something else), 2012/02/03 23:13:34]

This is of course not related to your change, but something to keep in mind is
that the IOBuffer subclasses are not meant to be passed around directly... they
are just convenience classes for creation of buffers, but the base class is the
only interface that is supposed to be used when going from one class to another.

[satorux1, 2012/02/03 23:46:11]

Thank you for sharing the thought. I'll keep in mind that IOBuffer should be
used for interface.

                                    const BoundNetLog& net_log)
     : io_state_(STATE_NONE),
       request_(request),
       request_headers_(NULL),
       request_body_(NULL),
       read_buf_(read_buffer),
       read_buf_unused_offset_(0),
       response_header_start_offset_(-1),
       response_body_length_(-1),
       response_body_read_(0),
@@ skipping 40 matching lines @@
   AddressList address;
   int result = connection_->socket()->GetPeerAddress(&address);
   if (result != OK)
     return result;
   response_->socket_address = HostPortPair::FromAddrInfo(address.head());
 
   std::string request = request_line + headers.ToString();
   request_body_.reset(request_body);
   if (request_body_ != NULL && request_body_->is_chunked()) {
     request_body_->set_chunk_callback(this);
-    // The raw chunk buffer is guaranteed to be large enough to hold the
-    // encoded chunk.
-    raw_chunk_buf_ = new IOBufferWithSize(UploadDataStream::GetBufferSize() +
-                                          kChunkHeaderFooterSize);
+    // The chunk buffer is guaranteed to be large enough to hold the encoded
+    // chunk.
+    chunk_buf_ = new SeekableIOBuffer(UploadDataStream::GetBufferSize() +
+                                      kChunkHeaderFooterSize);
   }
 
   io_state_ = STATE_SENDING_HEADERS;
 
   // If we have a small request body, then we'll merge with the headers into a
   // single write.
   bool did_merge = false;
   if (ShouldMergeRequestHeadersAndBody(request, request_body_.get())) {
     size_t merged_size = request.size() + request_body->size();
     scoped_refptr<IOBuffer> merged_request_headers_and_body(
@@ skipping 197 matching lines @@
     io_state_ = STATE_REQUEST_SENT;
   }
   return result;
 }
 
 int HttpStreamParser::DoSendChunkedBody(int result) {
   // |result| is the number of bytes sent from the last call to
   // DoSendChunkedBody(), or 0 (i.e. OK) the first time.
 
   // Send the remaining data in the chunk buffer.
-  if (chunk_buf_.get()) {
-    chunk_buf_->DidConsume(result);
-    if (chunk_buf_->BytesRemaining() > 0) {
-      return connection_->socket()->Write(chunk_buf_,
-                                          chunk_buf_->BytesRemaining(),
-                                          io_callback_);
-    }
+  chunk_buf_->DidConsume(result);
+  if (chunk_buf_->BytesRemaining() > 0) {
+    return connection_->socket()->Write(chunk_buf_,
+                                        chunk_buf_->BytesRemaining(),
+                                        io_callback_);
   }
 
   if (sent_last_chunk_) {
     io_state_ = STATE_REQUEST_SENT;
     return OK;
   }
 
   // |chunk_length_without_encoding_| is 0 when DoSendBody() is first
   // called, hence the first call to MarkConsumedAndFillBuffer() is a noop.
   request_body_->MarkConsumedAndFillBuffer(chunk_length_without_encoding_);
   chunk_length_without_encoding_ = 0;
 
   if (request_body_->eof()) {
+    chunk_buf_->Clear();
     const int chunk_length = EncodeChunk(
-        base::StringPiece(), raw_chunk_buf_->data(), raw_chunk_buf_->size());
-    chunk_buf_ = new DrainableIOBuffer(raw_chunk_buf_, chunk_length);
+        base::StringPiece(), chunk_buf_->data(), chunk_buf_->capacity());
+    chunk_buf_->DidAppend(chunk_length);
     sent_last_chunk_ = true;
   } else if (request_body_->buf_len() > 0) {
     // Encode and send the buffer as 1 chunk.
     const base::StringPiece payload(request_body_->buf()->data(),
                                     request_body_->buf_len());
+    chunk_buf_->Clear();
     const int chunk_length = EncodeChunk(
-        payload, raw_chunk_buf_->data(), raw_chunk_buf_->size());
-    chunk_buf_ = new DrainableIOBuffer(raw_chunk_buf_, chunk_length);
+        payload, chunk_buf_->data(), chunk_buf_->capacity());
+    chunk_buf_->DidAppend(chunk_length);
     chunk_length_without_encoding_ = payload.size();
   } else {
     // Nothing to send. More POST data is yet to come?
     return ERR_IO_PENDING;
   }
 
   return connection_->socket()->Write(chunk_buf_, chunk_buf_->BytesRemaining(),
                                       io_callback_);
 }
 
@@ skipping 430 matching lines @@
       request_body->IsInMemory() &&
       request_body->size() > 0) {
     size_t merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 }  // namespace net