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

net/http/http_network_transaction.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_network_transaction.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 141 matching lines @@
       next_state_(STATE_NONE),
       establishing_tunnel_(false),
       websocket_handshake_stream_base_create_helper_(NULL) {
   session->ssl_config_service()->GetSSLConfig(&server_ssl_config_);
   session->GetNextProtos(&server_ssl_config_.next_protos);
   proxy_ssl_config_ = server_ssl_config_;
 }
 
 HttpNetworkTransaction::~HttpNetworkTransaction() {
   if (stream_.get()) {
-    HttpResponseHeaders* headers = GetResponseHeaders();
     // TODO(mbelshe): The stream_ should be able to compute whether or not the
     //                stream should be kept alive.  No reason to compute here
     //                and pass it in.
-    bool try_to_keep_alive =
-        next_state_ == STATE_NONE &&
-        stream_->CanFindEndOfResponse() &&
-        (!headers || headers->IsKeepAlive());
-    if (!try_to_keep_alive) {
+    if (!stream_->CanReuseConnection() || next_state_ != STATE_NONE) {
       stream_->Close(true /* not reusable */);
+    } else if (stream_->IsResponseBodyComplete()) {
+      // If the response body is complete, we can just reuse the socket.
+      stream_->Close(false /* reusable */);
     } else {
-      if (stream_->IsResponseBodyComplete()) {
-        // If the response body is complete, we can just reuse the socket.
-        stream_->Close(false /* reusable */);
-      } else if (stream_->IsSpdyHttpStream()) {
-        // Doesn't really matter for SpdyHttpStream. Just close it.
-        stream_->Close(true /* not reusable */);
-      } else {
-        // Otherwise, we try to drain the response body.
-        HttpStream* stream = stream_.release();
-        stream->Drain(session_);
-      }
+      // Otherwise, we try to drain the response body.
+      HttpStream* stream = stream_.release();
+      stream->Drain(session_);
     }
   }
 
   if (request_ && request_->upload_data_stream)
     request_->upload_data_stream->Reset();  // Invalidate pending callbacks.
 }
 
 int HttpNetworkTransaction::Start(const HttpRequestInfo* request_info,
                                   const CompletionCallback& callback,
                                   const BoundNetLog& net_log) {
@@ skipping 92 matching lines @@
   return rv;
 }
 
 void HttpNetworkTransaction::PrepareForAuthRestart(HttpAuth::Target target) {
   DCHECK(HaveAuth(target));
   DCHECK(!stream_request_.get());
 
   bool keep_alive = false;
   // Even if the server says the connection is keep-alive, we have to be
   // able to find the end of each response in order to reuse the connection.
-  if (GetResponseHeaders()->IsKeepAlive() &&
-      stream_->CanFindEndOfResponse()) {
+  if (stream_->CanReuseConnection()) {
     // If the response body hasn't been completely read, we need to drain
     // it first.
     if (!stream_->IsResponseBodyComplete()) {
       next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
       read_buf_ = new IOBuffer(kDrainBodyBufferSize);  // A bit bucket.
       read_buf_len_ = kDrainBodyBufferSize;
       return;
     }
     keep_alive = true;
   }
 
   // We don't need to drain the response body, so we act as if we had drained
   // the response body.
   DidDrainBodyForAuthRestart(keep_alive);
 }
 
 void HttpNetworkTransaction::DidDrainBodyForAuthRestart(bool keep_alive) {
   DCHECK(!stream_request_.get());
 
   if (stream_.get()) {
     total_received_bytes_ += stream_->GetTotalReceivedBytes();
     HttpStream* new_stream = NULL;
-    if (keep_alive && stream_->IsConnectionReusable()) {
+    if (keep_alive && stream_->CanReuseConnection()) {
       // We should call connection_->set_idle_time(), but this doesn't occur
       // often enough to be worth the trouble.
       stream_->SetConnectionReused();
       new_stream = stream_->RenewStreamForAuth();
     }
 
     if (!new_stream) {
       // Close the stream and mark it as not_reusable.  Even in the
       // keep_alive case, we've determined that the stream_ is not
       // reusable if new_stream is NULL.
@@ skipping 777 matching lines @@
 }
 
 int HttpNetworkTransaction::DoReadBodyComplete(int result) {
   // We are done with the Read call.
   bool done = false;
   if (result <= 0) {
     DCHECK_NE(ERR_IO_PENDING, result);
     done = true;
   }
 
-  bool keep_alive = false;
-  if (stream_->IsResponseBodyComplete()) {
+  // Clean up connection if we are done.
+  if (done) {
     // Note: Just because IsResponseBodyComplete is true, we're not
     // necessarily "done".  We're only "done" when it is the last
     // read on this HttpNetworkTransaction, which will be signified
     // by a zero-length read.
-    // TODO(mbelshe): The keepalive property is really a property of
+    // TODO(mbelshe): The keep-alive property is really a property of
     //    the stream.  No need to compute it here just to pass back
     //    to the stream's Close function.
-    // TODO(rtenneti): CanFindEndOfResponse should return false if there are no
-    // ResponseHeaders.
-    if (stream_->CanFindEndOfResponse()) {
-      HttpResponseHeaders* headers = GetResponseHeaders();
-      if (headers)
-        keep_alive = headers->IsKeepAlive();
-    }
-  }
+    bool keep_alive =
+        stream_->IsResponseBodyComplete() && stream_->CanReuseConnection();
 
-  // Clean up connection if we are done.
-  if (done) {
     stream_->Close(!keep_alive);
     // Note: we don't reset the stream here.  We've closed it, but we still
     // need it around so that callers can call methods such as
     // GetUploadProgress() and have them be meaningful.
     // TODO(mbelshe): This means we closed the stream here, and we close it
     // again in ~HttpNetworkTransaction.  Clean that up.
 
     // The next Read call will return 0 (EOF).
   }
 
@@ skipping 512 matching lines @@
   DCHECK(stream_request_);
 
   // Since the transaction can restart with auth credentials, it may create a
   // stream more than once. Accumulate all of the connection attempts across
   // those streams by appending them to the vector:
   for (const auto& attempt : stream_request_->connection_attempts())
     connection_attempts_.push_back(attempt);
 }
 
 }  // namespace net