Perform HTTP authentication over a keep-alive connection....

net/http/http_network_transaction.cc

 // 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.
 
 #include "net/http/http_network_transaction.h"
 
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
@@ skipping 109 matching lines @@
   DCHECK(auth_identity_[target].source != HttpAuth::IDENT_SRC_PATH_LOOKUP);
 
   // Add the auth entry to the cache before restarting. We don't know whether
   // the identity is valid yet, but if it is valid we want other transactions
   // to know about it. If an entry for (origin, handler->realm()) already
   // exists, we update it.
   session_->auth_cache()->Add(AuthOrigin(target), auth_handler_[target],
       auth_identity_[target].username, auth_identity_[target].password,
       AuthPath(target));
 
-  next_state_ = STATE_INIT_CONNECTION;
-  connection_.set_socket(NULL);
-  connection_.Reset();
+  bool keep_alive = false;
+  if (response_.headers->IsKeepAlive()) {
+    // If there is a response body of known length, we need to drain it first.
+    if (content_length_ > 0 || chunked_decoder_.get()) {
+      next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
+      read_buf_ = new IOBuffer(kDrainBodyBufferSize);  // A bit bucket
+      read_buf_len_ = kDrainBodyBufferSize;
+      return;
+    }
+    if (content_length_ == 0)  // No response body to drain.
+      keep_alive = true;
+    // content_length_ is -1 and we're not using chunked encoding.  We don't
+    // know the length of the response body, so we can't reuse this connection
+    // even though the server says it's keep-alive.
+  }
+
+  // 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) {
+  if (keep_alive) {
+    next_state_ = STATE_WRITE_HEADERS;
+    reused_socket_ = true;
+  } else {
+    next_state_ = STATE_INIT_CONNECTION;
+    connection_.set_socket(NULL);
+    connection_.Reset();
+  }
 
   // Reset the other member variables.
   ResetStateForRestart();
 }
 
 int HttpNetworkTransaction::Read(IOBuffer* buf, int buf_len,
                                  CompletionCallback* callback) {
   DCHECK(response_.headers);
   DCHECK(buf);
   DCHECK(buf_len > 0);
@@ skipping 229 matching lines @@
         break;
       case STATE_READ_BODY:
         DCHECK(rv == OK);
         TRACE_EVENT_BEGIN("http.read_body", request_, request_->url.spec());
         rv = DoReadBody();
         break;
       case STATE_READ_BODY_COMPLETE:
         rv = DoReadBodyComplete(rv);
         TRACE_EVENT_END("http.read_body", request_, request_->url.spec());
         break;
+      case STATE_DRAIN_BODY_FOR_AUTH_RESTART:
+        DCHECK(rv == OK);
+        TRACE_EVENT_BEGIN("http.drain_body_for_auth_restart",
+                          request_, request_->url.spec());
+        rv = DoDrainBodyForAuthRestart();
+        break;
+      case STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE:
+        rv = DoDrainBodyForAuthRestartComplete(rv);
+        TRACE_EVENT_END("http.drain_body_for_auth_restart",
+                        request_, request_->url.spec());
+        break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_FAILED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
   return rv;
 }
 
@@ skipping 379 matching lines @@
       keep_alive = response_.headers->IsKeepAlive();
       // We can't reuse the connection if we read more than the advertised
       // content length, or if the tunnel was not established successfully.
       if (unfiltered_eof ||
           (content_length_ != -1 && content_read_ > content_length_) ||
           establishing_tunnel_)
         keep_alive = false;
     }
   }
 
-  // Clean up the HttpConnection if we are done.
+  // Clean up connection_ if we are done.
   if (done) {
     LogTransactionMetrics();
     if (!keep_alive)
       connection_.set_socket(NULL);
     connection_.Reset();
     // The next Read call will return 0 (EOF).
   }
 
   // Clear these to avoid leaving around old state.
   read_buf_ = NULL;
   read_buf_len_ = 0;
 
   return result;
 }
 
+int HttpNetworkTransaction::DoDrainBodyForAuthRestart() {
+  // This method differs from DoReadBody only in the next_state_.  So we just
+  // call DoReadBody and override the next_state_.  Perhaps there is a more
+  // elegant way for these two methods to share code.
+  int rv = DoReadBody();
+  DCHECK(next_state_ == STATE_READ_BODY_COMPLETE);
+  next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE;
+  return rv;
+}
+
+// TODO(wtc): The first two thirds of this method and the DoReadBodyComplete
+// method are almost the same.  Figure out a good way for these two methods
+// to share code.
+int HttpNetworkTransaction::DoDrainBodyForAuthRestartComplete(int result) {
+  bool unfiltered_eof = (result == 0);
+
+  // Filter incoming data if appropriate.  FilterBuf may return an error.
+  if (result > 0 && chunked_decoder_.get()) {
+    result = chunked_decoder_->FilterBuf(read_buf_->data(), result);
+    if (result == 0 && !chunked_decoder_->reached_eof()) {
+      // Don't signal completion of the Read call yet or else it'll look like
+      // we received end-of-file.  Wait for more data.
+      next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
+      return OK;
+    }
+  }
+
+  bool done = false, keep_alive = false;
+  if (result < 0) {
+    // Error while reading the socket.
+    done = true;
+  } else {
+    content_read_ += result;
+    if (unfiltered_eof ||
+        (content_length_ != -1 && content_read_ >= content_length_) ||
+        (chunked_decoder_.get() && chunked_decoder_->reached_eof())) {
+      done = true;
+      keep_alive = response_.headers->IsKeepAlive();
+      // We can't reuse the connection if we read more than the advertised
+      // content length.
+      if (unfiltered_eof ||
+          (content_length_ != -1 && content_read_ > content_length_))
+        keep_alive = false;
+    }
+  }
+
+  if (done) {
+    DidDrainBodyForAuthRestart(keep_alive);
+  } else {
+    // Keep draining.
+    next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
+  }
+
+  return OK;
+}
+
 void HttpNetworkTransaction::LogTransactionMetrics() const {
   base::TimeDelta duration = base::Time::Now() - response_.request_time;
   if (60 < duration.InMinutes())
     return;
   UMA_HISTOGRAM_LONG_TIMES(L"Net.Transaction_Latency", duration);
   if (!duration.InMilliseconds())
     return;
   UMA_HISTOGRAM_COUNTS(L"Net.Transaction_Bandwidth",
       static_cast<int> (content_read_ / duration.InMilliseconds()));
 }
@@ skipping 55 matching lines @@
               header_buf_len_);
     }
     header_buf_body_offset_ = -1;
     next_state_ = STATE_READ_HEADERS;
     return OK;
   }
 
   response_.headers = headers;
   response_.vary_data.Init(*request_, *response_.headers);
 
-  int rv = HandleAuthChallenge();
-  if (rv == WILL_RESTART_TRANSACTION) {
-    DCHECK(next_state_ == STATE_INIT_CONNECTION);
-    return OK;
-  }
-  if (rv != OK)
-    return rv;
-
   // Figure how to determine EOF:
 
   // For certain responses, we know the content length is always 0.
   switch (response_.headers->response_code()) {
     case 204:  // No Content
     case 205:  // Reset Content
     case 304:  // Not Modified
       content_length_ = 0;
       break;
   }
 
   if (content_length_ == -1) {
     // Ignore spurious chunked responses from HTTP/1.0 servers and proxies.
     // Otherwise "Transfer-Encoding: chunked" trumps "Content-Length: N"
     if (response_.headers->GetHttpVersion() >= HttpVersion(1, 1) &&
         response_.headers->HasHeaderValue("Transfer-Encoding", "chunked")) {
       chunked_decoder_.reset(new HttpChunkedDecoder());
     } else {
       content_length_ = response_.headers->GetContentLength();
       // If content_length_ is still -1, then we have to wait for the server to
       // close the connection.
     }
   }
 
+  int rv = HandleAuthChallenge();
+  if (rv == WILL_RESTART_TRANSACTION)
+    return OK;
+  if (rv != OK)
+    return rv;
+
   if (using_ssl_ && !establishing_tunnel_) {
     SSLClientSocket* ssl_socket =
         reinterpret_cast<SSLClientSocket*>(connection_.socket());
     ssl_socket->GetSSLInfo(&response_.ssl_info);
   }
 
   return OK;
 }
 
 int HttpNetworkTransaction::HandleCertificateError(int error) {
@@ skipping 359 matching lines @@
   if (target == HttpAuth::AUTH_PROXY) {
     auth_info->host = ASCIIToWide(proxy_info_.proxy_server());
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     auth_info->host = ASCIIToWide(request_->url.host());
   }
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net