Move logic to figure out if a socket can be reused into HttpStream.

net/http/http_stream.h

 // 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.
 //
 // HttpStream provides an abstraction for a basic http streams, SPDY, and QUIC.
 // The HttpStream subtype is expected to manage the underlying transport
 // appropriately.  For example, a basic http stream will return the transport
 // socket to the pool for reuse.  SPDY streams on the other hand leave the
 // transport socket management to the SpdySession.
 
@@ skipping 71 matching lines @@
   // the socket acquires a reference to the provided buffer until the callback
   // is invoked or the socket is destroyed.
   virtual int ReadResponseBody(IOBuffer* buf, int buf_len,
                                const CompletionCallback& callback) = 0;
 
   // Closes the stream.
   // |not_reusable| indicates if the stream can be used for further requests.
   // In the case of HTTP, where we re-use the byte-stream (e.g. the connection)
   // this means we need to close the connection; in the case of SPDY, where the
   // underlying stream is never reused, it has no effect.
-  // TODO(mbelshe): We should figure out how to fold the not_reusable flag
-  //                into the stream implementation itself so that the caller
-  //                does not need to pass it at all.  We might also be able to
-  //                eliminate the SetConnectionReused() below.
+  // TODO(mmenke): We should fold the |not_reusable| flag into the stream
+  //               implementation itself so that the caller does not need to
+  //               pass it at all.  Ideally we'd be able to remove
+  //               CanReuseConnection() and IsResponseBodyComplete().
+  // TODO(mmenke): We should try and merge Drain() into this method as well.
   virtual void Close(bool not_reusable) = 0;
 
   // Indicates if the response body has been completely read.
   virtual bool IsResponseBodyComplete() const = 0;
 
-  // Indicates that the end of the response is detectable. This means that
-  // the response headers indicate either chunked encoding or content length.
-  // If neither is sent, the server must close the connection for us to detect
-  // the end of the response.
-  // TODO(rch): Rename this method, so that it is clear why it exists
-  // particularly as it applies to QUIC and SPDY for which the end of the
-  // response is always findable.
-  virtual bool CanFindEndOfResponse() const = 0;
-
   // A stream exists on top of a connection.  If the connection has been used
   // to successfully exchange data in the past, error handling for the
   // stream is done differently.  This method returns true if the underlying
   // connection is reused or has been connected and idle for some time.
   virtual bool IsConnectionReused() const = 0;
+  // TODO(mmenke): We should fold this into RenewStreamForAuth(), and make that
+  //    method drain the stream as well, if needed (And return asynchronously).
   virtual void SetConnectionReused() = 0;
 
-  // Checks whether the current state of the underlying connection
-  // allows it to be reused.
-  virtual bool IsConnectionReusable() const = 0;
+  // Checks whether the underlying connection can be reused.  The stream's
+  // connection can be reused if the response headers allow for it, the socket
+  // is still connected, and the stream exclusively owns the underlying
+  // connection.  SPDY and QUIC streams don't own their own connections, so
+  // always return false.
+  virtual bool CanReuseConnection() const = 0;
 
   // Get the total number of bytes received from network for this stream.
   virtual int64 GetTotalReceivedBytes() const = 0;
 
   // Populates the connection establishment part of |load_timing_info|, and
   // socket ID.  |load_timing_info| must have all null times when called.
   // Returns false and does nothing if there is no underlying connection, either
   // because one has yet to be assigned to the stream, or because the underlying
   // socket has been closed.
   //
   // In practice, this means that this function will always succeed any time
   // between when the full headers have been received and the stream has been
   // closed.
   virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const = 0;
 
   // Get the SSLInfo associated with this stream's connection.  This should
   // only be called for streams over SSL sockets, otherwise the behavior is
   // undefined.
   virtual void GetSSLInfo(SSLInfo* ssl_info) = 0;
 
   // Get the SSLCertRequestInfo associated with this stream's connection.
   // This should only be called for streams over SSL sockets, otherwise the
   // behavior is undefined.
   virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) = 0;
 
-  // HACK(willchan): Really, we should move the HttpResponseDrainer logic into
-  // the HttpStream implementation. This is just a quick hack.
-  virtual bool IsSpdyHttpStream() const = 0;
-
   // In the case of an HTTP error or redirect, flush the response body (usually
   // a simple error or "this page has moved") so that we can re-use the
   // underlying connection. This stream is responsible for deleting itself when
   // draining is complete.
   virtual void Drain(HttpNetworkSession* session) = 0;
 
   // Called when the priority of the parent transaction changes.
   virtual void SetPriority(RequestPriority priority) = 0;
 
   // Queries the UploadDataStream for its progress (bytes sent).
   virtual UploadProgress GetUploadProgress() const = 0;
 
   // Returns a new (not initialized) stream using the same underlying
   // connection and invalidates the old stream - no further methods should be
   // called on the old stream.  The caller should ensure that the response body
   // from the previous request is drained before calling this method.  If the
   // subclass does not support renewing the stream, NULL is returned.
   virtual HttpStream* RenewStreamForAuth() = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HttpStream);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_H_