Extend the use of IOBuffers to the code underneath...

net/http/http_network_transaction.h

 // Copyright (c) 2006-2008 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_HTTP_HTTP_NETWORK_TRANSACTION_H_
 #define NET_HTTP_HTTP_NETWORK_TRANSACTION_H_
 
 #include <string>
 
 #include "base/ref_counted.h"
@@ skipping 37 matching lines @@
   }
 
   virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
   virtual const HttpResponseInfo* GetResponseInfo() const;
   virtual LoadState GetLoadState() const;
   virtual uint64 GetUploadProgress() const;
 
  private:
   FRIEND_TEST(HttpNetworkTransactionTest, ResetStateForRestart);
 
+  // This version of IOBuffer lets us use a string as the real storage and
+  // "move" the data pointer inside the string before using it to do actual IO.
+  class RequestHeaders : public net::IOBuffer {
+   public:
+    RequestHeaders() : net::IOBuffer() {}
+    ~RequestHeaders() { data_ = NULL; }
+
+    void SetDataOffset(size_t offset) {
+      data_ = const_cast<char*>(headers_.data()) + offset;
+    }
+
+    // This is intentionally a public member.
+    std::string headers_;
+  };
+
+  // This version of IOBuffer lets us use a malloc'ed buffer as the real storage
+  // and "move" the data pointer inside the buffer before using it to do actual
+  // IO.
+  class ResponseHeaders : public net::IOBuffer {
+   public:
+    ResponseHeaders() : net::IOBuffer() {}
+    ~ResponseHeaders() { data_ = NULL; }
+
+    void set_data(size_t offset) { data_ = headers_.get() + offset; }
+    char* headers() { return headers_.get(); }
+    void Reset() { headers_.reset(); }
+    void Realloc(size_t new_size);
+
+   private:
+    scoped_ptr_malloc<char> headers_;
+  };
+
   void BuildRequestHeaders();
   void BuildTunnelRequest();
   void DoCallback(int result);
   void OnIOComplete(int result);
 
   // Runs the state transition loop.
   int DoLoop(int result);
 
   // Each of these methods corresponds to a State value.  Those with an input
   // argument receive the result from the previous state.  If a method returns
@@ skipping 197 matching lines @@
   //
   // TODO(wtc): this is similar to the |ignore_ok_result_| member of the
   // SSLClientSocketWin class.  We may want to add an internal error code, say
   // ERR_EOF, to indicate a connection closure, so that 0 simply means 0 bytes
   // or OK.  Note that we already have an ERR_CONNECTION_CLOSED error code,
   // but it isn't really being used.
   bool reading_body_from_socket_;
 
   SSLConfig ssl_config_;
 
-  std::string request_headers_;
+  scoped_refptr<RequestHeaders> request_headers_;
   size_t request_headers_bytes_sent_;
   scoped_ptr<UploadDataStream> request_body_stream_;
+  scoped_refptr<IOBuffer> write_buffer_;
 
   // The read buffer may be larger than it is full.  The 'capacity' indicates
   // the allocation size of the buffer, and the 'len' indicates how much data
   // is in the buffer already.  The 'body offset' indicates the offset of the
   // start of the response body within the read buffer.
-  scoped_ptr_malloc<char> header_buf_;
+  scoped_refptr<ResponseHeaders> header_buf_;
   int header_buf_capacity_;
   int header_buf_len_;
   int header_buf_body_offset_;
 
   // The number of bytes by which the header buffer is grown when it reaches
   // capacity.
   enum { kHeaderBufInitialSize = 4096 };
 
   // |kMaxHeaderBufSize| is the number of bytes that the response headers can
   // grow to. If the body start is not found within this range of the
@@ skipping 51 matching lines @@
     STATE_DRAIN_BODY_FOR_AUTH_RESTART,
     STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE,
     STATE_NONE
   };
   State next_state_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_NETWORK_TRANSACTION_H_