After draining the body of a 401/407 response, verify that...

net/socket/socket_test_util.cc

 // 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.
 
 #include "net/socket/socket_test_util.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 48 matching lines @@
                                    int result) {
   if (callback)
     callback->Run(result);
 }
 
 MockTCPClientSocket::MockTCPClientSocket(const net::AddressList& addresses,
                                          net::SocketDataProvider* data)
     : addresses_(addresses),
       data_(data),
       read_offset_(0),
-      read_data_(true, net::ERR_UNEXPECTED),
+      read_data_(false, net::ERR_UNEXPECTED),
       need_read_data_(true),
+      peer_closed_connection_(false),
       pending_buf_(NULL),
       pending_buf_len_(0),
       pending_callback_(NULL) {
   DCHECK(data_);
   data_->Reset();
 }
 
 int MockTCPClientSocket::Connect(net::CompletionCallback* callback,
                                  LoadLog* load_log) {
   if (connected_)
     return net::OK;
   connected_ = true;
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
     return net::ERR_IO_PENDING;
   }
   return data_->connect_data().result;
 }
 
+bool MockTCPClientSocket::IsConnected() const {
+  return connected_ && !peer_closed_connection_;
+}
+
 int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len,
                               net::CompletionCallback* callback) {
-  if (!IsConnected())
+  if (!connected_)
     return net::ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_buf_ == NULL);
 
   // Store our async IO data.
   pending_buf_ = buf;
   pending_buf_len_ = buf_len;
   pending_callback_ = callback;
 
   if (need_read_data_) {
     read_data_ = data_->GetNextRead();
+    if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) {
+      // This MockRead is just a marker to instruct us to set
+      // peer_closed_connection_.  Skip it and get the next one.
+      read_data_ = data_->GetNextRead();
+      peer_closed_connection_ = true;
+    }
     // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
     // to complete the async IO manually later (via OnReadComplete).
     if (read_data_.result == ERR_IO_PENDING) {
       DCHECK(callback);  // We need to be using async IO in this case.
       return ERR_IO_PENDING;
     }
     need_read_data_ = false;
   }
 
   return CompleteRead();
 }
 
 int MockTCPClientSocket::Write(net::IOBuffer* buf, int buf_len,
                                net::CompletionCallback* callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
-  if (!IsConnected())
+  if (!connected_)
     return net::ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   net::MockWriteResult write_result = data_->OnWrite(data);
 
   if (write_result.async) {
     RunCallbackAsync(callback, write_result.result);
     return net::ERR_IO_PENDING;
   }
   return write_result.result;
@@ skipping 164 matching lines @@
   write_index_ = 0;
 }
 
 DynamicSocketDataProvider::DynamicSocketDataProvider()
     : short_read_limit_(0),
       allow_unconsumed_reads_(false) {
 }
 
 MockRead DynamicSocketDataProvider::GetNextRead() {
   if (reads_.empty())
-    return MockRead(true, ERR_UNEXPECTED);
+    return MockRead(false, ERR_UNEXPECTED);
   MockRead result = reads_.front();
   if (short_read_limit_ == 0 || result.data_len <= short_read_limit_) {
     reads_.pop_front();
   } else {
     result.data_len = short_read_limit_;
     reads_.front().data += result.data_len;
     reads_.front().data_len -= result.data_len;
   }
   return result;
 }
@@ skipping 117 matching lines @@
 }
 
 void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) {
   bool released_one;
   do {
     released_one = ReleaseOneConnection(keep_alive);
   } while (released_one);
 }
 
 }  // namespace net