Introduce HttpStream and HttpBasicStream.

This is the beginning of the http pipelining work.  Introduce HttpStream, an interface for reading and writing to http streams.  Provide a basic implementation with HttpBasicStream.  Switch HttpNetworkTransaction to reading/writing via HttpStream rather than directly to the socket.
Note that the interface will have to change later on.  Read/Write() is the wrong interface, since a pipelining HttpStream implementation will have to detect the end of an http response, rather than having the client (HttpNetworkTransaction) do that.  This is just the first step.
For information of the general roadmap for http pipelining, please refer to the bug.
BUG=http://crbug.com/8991
TEST=none

Review URL: http://codereview.chromium.org/119346

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@18199 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 113 insertions, 5 deletions

diff --git a/net/http/http_basic_stream.h b/net/http/http_basic_stream.h
new file mode 100644
index 0000000..32f1b8a
--- /dev/null
+++ b/net/http/http_basic_stream.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2009 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.
+//
+// HttpBasicStream is a simple implementation of HttpStream.  It assumes it is
+// not sharing a sharing with any other HttpStreams, therefore it just reads and
+// writes directly to the Http Stream.
+
+#ifndef NET_HTTP_HTTP_BASIC_STREAM_H_
+#define NET_HTTP_HTTP_BASIC_STREAM_H_
+
+#include "base/basictypes.h"
+#include "net/base/client_socket_handle.h"
+#include "net/http/http_stream.h"
+
+namespace net {
+
+class HttpBasicStream : public HttpStream {
+ public:
+  explicit HttpBasicStream(ClientSocketHandle* handle) : handle_(handle) {}
+  virtual ~HttpBasicStream() {}
+
+  // HttpStream methods:
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   CompletionCallback* callback) {
+    return handle_->socket()->Read(buf, buf_len, callback);
+  }
+
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
+                    CompletionCallback* callback) {
+    return handle_->socket()->Write(buf, buf_len, callback);
+  }
+
+ private:
+  ClientSocketHandle* const handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(HttpBasicStream);
+};
+
+}  // namespace net
+
+#endif  // NET_HTTP_HTTP_BASIC_STREAM_H_
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index 97f7715..8bfe386 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -22,6 +22,7 @@
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_handler.h"
+#include "net/http/http_basic_stream.h"
 #include "net/http/http_chunked_decoder.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
@@ -582,6 +583,7 @@ int HttpNetworkTransaction::DoInitConnectionComplete(int result) {
         establishing_tunnel_ = true;
     }
   }
+  http_stream_.reset(new HttpBasicStream(&connection_));
   return OK;
 }
 
@@ -657,7 +659,7 @@ int HttpNetworkTransaction::DoWriteHeaders() {
                                  request_headers_bytes_sent_);
   DCHECK_GT(buf_len, 0);
 
-  return connection_.socket()->Write(request_headers_, buf_len, &io_callback_);
+  return http_stream_->Write(request_headers_, buf_len, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoWriteHeadersComplete(int result) {
@@ -684,8 +686,8 @@ int HttpNetworkTransaction::DoWriteBody() {
 
   int buf_len = static_cast<int>(request_body_stream_->buf_len());
 
-  return connection_.socket()->Write(request_body_stream_->buf(), buf_len,
-                                     &io_callback_);
+  return http_stream_->Write(request_body_stream_->buf(), buf_len,
+                             &io_callback_);
 }
 
 int HttpNetworkTransaction::DoWriteBodyComplete(int result) {
@@ -714,7 +716,7 @@ int HttpNetworkTransaction::DoReadHeaders() {
   int buf_len = header_buf_capacity_ - header_buf_len_;
   header_buf_->set_data(header_buf_len_);
 
-  return connection_.socket()->Read(header_buf_, buf_len, &io_callback_);
+  return http_stream_->Read(header_buf_, buf_len, &io_callback_);
 }
 
 int HttpNetworkTransaction::HandleConnectionClosedBeforeEndOfHeaders() {
@@ -845,7 +847,7 @@ int HttpNetworkTransaction::DoReadBody() {
   }
 
   reading_body_from_socket_ = true;
-  return connection_.socket()->Read(read_buf_, read_buf_len_, &io_callback_);
+  return http_stream_->Read(read_buf_, read_buf_len_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoReadBodyComplete(int result) {
diff --git a/net/http/http_network_transaction.h b/net/http/http_network_transaction.h
index 3c3811d..af3a5f4 100644
--- a/net/http/http_network_transaction.h
+++ b/net/http/http_network_transaction.h
@@ -30,6 +30,7 @@ namespace net {
 class ClientSocketFactory;
 class HttpChunkedDecoder;
 class HttpNetworkSession;
+class HttpStream;
 class UploadDataStream;
 
 class HttpNetworkTransaction : public HttpTransaction {
@@ -296,6 +297,7 @@ class HttpNetworkTransaction : public HttpTransaction {
 
   ClientSocketFactory* socket_factory_;
   ClientSocketHandle connection_;
+  scoped_ptr<HttpStream> http_stream_;
   bool reused_socket_;
 
   bool using_ssl_;     // True if handling a HTTPS request
diff --git a/net/http/http_stream.h b/net/http/http_stream.h
new file mode 100644
index 0000000..361edb0
--- /dev/null
+++ b/net/http/http_stream.h
@@ -0,0 +1,60 @@
+// Copyright (c) 2009 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.
+//
+// HttpStream is an interface for reading and writing data to an HttpStream that
+// keeps the client agnostic of the actual underlying transport layer.  This
+// provides an abstraction for both a basic http stream as well as http
+// pipelining implementations.
+//
+// NOTE(willchan): This interface is a work in progress.  It will most likely
+// change, since for a pipelining implementation, the stream needs to contain
+// the http parsing code.  For symmetry, the writing methods will probably
+// contain the code for constructing http requests.
+
+#ifndef NET_HTTP_HTTP_STREAM_H_
+#define NET_HTTP_HTTP_STREAM_H_
+
+#include "base/basictypes.h"
+#include "net/base/completion_callback.h"
+
+namespace net {
+
+class IOBuffer;
+
+class HttpStream {
+ public:
+  HttpStream() {}
+  virtual ~HttpStream() {}
+
+  // Reads data, up to buf_len bytes, from the socket.  The number of bytes
+  // read is returned, or an error is returned upon failure.  Zero is returned
+  // to indicate end-of-file.  ERR_IO_PENDING is returned if the operation
+  // could not be completed synchronously, in which case the result will be
+  // passed to the callback when available. If the operation is not completed
+  // immediately, the socket acquires a reference to the provided buffer until
+  // the callback is invoked or the socket is destroyed.
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
+                   CompletionCallback* callback) = 0;
+
+  // Writes data, up to buf_len bytes, to the socket.  Note: only part of the
+  // data may be written!  The number of bytes written is returned, or an error
+  // is returned upon failure.  ERR_IO_PENDING is returned if the operation
+  // could not be completed synchronously, in which case the result will be
+  // passed to the callback when available. If the operation is not completed
+  // immediately, the socket acquires a reference to the provided buffer until
+  // the callback is invoked or the socket is destroyed.
+  // Implementations of this method should not modify the contents of the actual
+  // buffer that is written to the socket.
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
+                    CompletionCallback* callback) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(HttpStream);
+};
+
+}  // namespace net
+
+#endif  // NET_HTTP_HTTP_STREAM_H_