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 110 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()) {
+  if (result > 0) {

[wtc, 2012/02/02 20:22:57]

Nit: it is safe to call 
  chunk_buf_->DidConsume(result)
with a result of 0, so you can omit this result > 0 test.

[satorux1, 2012/02/02 22:02:27]

Good point. Done.

     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