Fix HttpStreamParser::CanReuseConnection().

net/socket/socket_test_util.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/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 125 matching lines @@
 }
 
 MockConnect::MockConnect(IoMode io_mode, int r, IPEndPoint addr) :
     mode(io_mode),
     result(r),
     peer_addr(addr) {
 }
 
 MockConnect::~MockConnect() {}
 
+bool SocketDataProvider::IsIdle() const {
+  return true;
+}
+
+SocketDataProvider::SocketDataProvider() : socket_(nullptr) {}
+
+SocketDataProvider::~SocketDataProvider() {
+  if (socket_)
+    socket_->OnDataProviderDestroyed();
+}
+
 StaticSocketDataHelper::StaticSocketDataHelper(MockRead* reads,
                                                size_t reads_count,
                                                MockWrite* writes,
                                                size_t writes_count)
     : reads_(reads),
       read_index_(0),
       read_count_(reads_count),
       writes_(writes),
       write_index_(0),
       write_count_(writes_count) {
@@ skipping 125 matching lines @@
 }
 
 SequencedSocketData::SequencedSocketData(MockRead* reads,
                                          size_t reads_count,
                                          MockWrite* writes,
                                          size_t writes_count)
     : helper_(reads, reads_count, writes, writes_count),
       sequence_number_(0),
       read_state_(IDLE),
       write_state_(IDLE),
+      busy_before_sync_reads_(false),
       weak_factory_(this) {
   // Check that reads and writes have a contiguous set of sequence numbers
   // starting from 0 and working their way up, with no repeats and skipping
   // no values.
   size_t next_read = 0;
   size_t next_write = 0;
   int next_sequence_number = 0;
   while (next_read < reads_count || next_write < writes_count) {
     if (next_read < reads_count &&
         reads[next_read].sequence_number == next_sequence_number) {
@@ skipping 119 matching lines @@
 }
 
 bool SequencedSocketData::AllReadDataConsumed() const {
   return helper_.AllReadDataConsumed();
 }
 
 bool SequencedSocketData::AllWriteDataConsumed() const {
   return helper_.AllWriteDataConsumed();
 }
 
+bool SequencedSocketData::IsIdle() const {
+  // If |busy_before_sync_reads_| is not set, always considered idle.  If
+  // no reads left, or the next operation is a write, also consider it idle.
+  if (!busy_before_sync_reads_ || helper_.AllReadDataConsumed() ||
+      helper_.PeekRead().sequence_number != sequence_number_) {
+    return true;
+  }
+
+  // If the next operation is synchronous read, treat the socket as not idle.
+  if (helper_.PeekRead().mode == SYNCHRONOUS)
+    return false;
+  return true;
+}
+
 bool SequencedSocketData::IsReadPaused() {
   return read_state_ == PAUSED;
 }
 
 void SequencedSocketData::CompleteRead() {
   if (read_state_ != PAUSED) {
     ADD_FAILURE() << "Unable to CompleteRead when not paused.";
     return;
   }
   read_state_ = COMPLETING;
@@ skipping 493 matching lines @@
       need_read_data_(true),
       peer_closed_connection_(false),
       pending_read_buf_(NULL),
       pending_read_buf_len_(0),
       was_used_to_convey_data_(false) {
   DCHECK(data_);
   peer_addr_ = data->connect_data().peer_addr;
   data_->Reset();
 }
 
-MockTCPClientSocket::~MockTCPClientSocket() {}
+MockTCPClientSocket::~MockTCPClientSocket() {
+  if (data_)
+    data_->set_socket(nullptr);
+}
 
 int MockTCPClientSocket::Read(IOBuffer* buf, int buf_len,
                               const CompletionCallback& callback) {
-  if (!connected_)
+  if (!connected_ || !data_)
     return ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_read_buf_.get() == NULL);
 
   // Store our async IO data.
   pending_read_buf_ = buf;
   pending_read_buf_len_ = buf_len;
   pending_read_callback_ = callback;
 
@@ skipping 21 matching lines @@
   }
 
   return CompleteRead();
 }
 
 int MockTCPClientSocket::Write(IOBuffer* buf, int buf_len,
                                const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
-  if (!connected_)
+  if (!connected_ || !data_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
   was_used_to_convey_data_ = true;
 
   // ERR_IO_PENDING is a signal that the socket data will call back
   // asynchronously later.
   if (write_result.result == ERR_IO_PENDING) {
@@ skipping 17 matching lines @@
   connection_attempts_.clear();
 }
 
 void MockTCPClientSocket::AddConnectionAttempts(
     const ConnectionAttempts& attempts) {
   connection_attempts_.insert(connection_attempts_.begin(), attempts.begin(),
                               attempts.end());
 }
 
 int MockTCPClientSocket::Connect(const CompletionCallback& callback) {
+  if (!data_)
+    return ERR_UNEXPECTED;
+
   if (connected_)
     return OK;
   connected_ = true;
   peer_closed_connection_ = false;
 
   int result = data_->connect_data().result;
   IoMode mode = data_->connect_data().mode;
 
   if (result != OK && result != ERR_IO_PENDING) {
     IPEndPoint address;
@@ skipping 11 matching lines @@
   return ERR_IO_PENDING;
 }
 
 void MockTCPClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
   pending_connect_callback_.Reset();
   pending_read_callback_.Reset();
 }
 
 bool MockTCPClientSocket::IsConnected() const {
+  if (!data_)
+    return false;
   return connected_ && !peer_closed_connection_;
 }
 
 bool MockTCPClientSocket::IsConnectedAndIdle() const {
-  return IsConnected();
+  if (!data_)
+    return false;
+  return IsConnected() && data_->IsIdle();
 }
 
 int MockTCPClientSocket::GetPeerAddress(IPEndPoint* address) const {
   if (addresses_.empty())
     return MockClientSocket::GetPeerAddress(address);
 
   *address = addresses_[0];
   return OK;
 }
 
 bool MockTCPClientSocket::WasEverUsed() const {
   return was_used_to_convey_data_;
 }
 
 bool MockTCPClientSocket::UsingTCPFastOpen() const {
   return false;
 }
 
 bool MockTCPClientSocket::WasNpnNegotiated() const {
   return false;
 }
 
 bool MockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   return false;
 }
 
 void MockTCPClientSocket::OnReadComplete(const MockRead& data) {
+  // If |data_| has been destroyed, safest to just do nothing.
+  if (!data_)
+    return;
+
   // There must be a read pending.
   DCHECK(pending_read_buf_.get());
   // You can't complete a read with another ERR_IO_PENDING status code.
   DCHECK_NE(ERR_IO_PENDING, data.result);
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
   read_data_.mode = SYNCHRONOUS;
 
   CompletionCallback callback = pending_read_callback_;
   int rv = CompleteRead();
   RunCallback(callback, rv);
 }
 
 void MockTCPClientSocket::OnWriteComplete(int rv) {
+  // If |data_| has been destroyed, safest to just do nothing.
+  if (!data_)
+    return;
+
   // There must be a read pending.
   DCHECK(!pending_write_callback_.is_null());
   CompletionCallback callback = pending_write_callback_;
   RunCallback(callback, rv);
 }
 
 void MockTCPClientSocket::OnConnectComplete(const MockConnect& data) {
+  // If |data_| has been destroyed, safest to just do nothing.
+  if (!data_)
+    return;
+
   CompletionCallback callback = pending_connect_callback_;
   RunCallback(callback, data.result);
 }
 
+void MockTCPClientSocket::OnDataProviderDestroyed() {
+  data_ = nullptr;
+}
+
 int MockTCPClientSocket::CompleteRead() {
   DCHECK(pending_read_buf_.get());
   DCHECK(pending_read_buf_len_ > 0);
 
   was_used_to_convey_data_ = true;
 
   // Save the pending async IO data and reset our |pending_| state.
   scoped_refptr<IOBuffer> buf = pending_read_buf_;
   int buf_len = pending_read_buf_len_;
   CompletionCallback callback = pending_read_callback_;
@@ skipping 365 matching lines @@
 void MockSSLClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
   if (transport_->socket() != NULL)
     transport_->socket()->Disconnect();
 }
 
 bool MockSSLClientSocket::IsConnected() const {
   return transport_->socket()->IsConnected();
 }
 
+bool MockSSLClientSocket::IsConnectedAndIdle() const {
+  return transport_->socket()->IsConnectedAndIdle();
+}
+
 bool MockSSLClientSocket::WasEverUsed() const {
   return transport_->socket()->WasEverUsed();
 }
 
 bool MockSSLClientSocket::UsingTCPFastOpen() const {
   return transport_->socket()->UsingTCPFastOpen();
 }
 
 int MockSSLClientSocket::GetPeerAddress(IPEndPoint* address) const {
   return transport_->socket()->GetPeerAddress(address);
@@ skipping 52 matching lines @@
       source_port_(123),
       pending_read_buf_(NULL),
       pending_read_buf_len_(0),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_NONE)),
       weak_factory_(this) {
   DCHECK(data_);
   data_->Reset();
   peer_addr_ = data->connect_data().peer_addr;
 }
 
-MockUDPClientSocket::~MockUDPClientSocket() {}
+MockUDPClientSocket::~MockUDPClientSocket() {
+  if (data_)
+    data_->set_socket(nullptr);
+}
 
 int MockUDPClientSocket::Read(IOBuffer* buf,
                               int buf_len,
                               const CompletionCallback& callback) {
-  if (!connected_)
+  if (!connected_ || !data_)
     return ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_read_buf_.get() == NULL);
 
   // Store our async IO data.
   pending_read_buf_ = buf;
   pending_read_buf_len_ = buf_len;
   pending_read_callback_ = callback;
 
@@ skipping 10 matching lines @@
   }
 
   return CompleteRead();
 }
 
 int MockUDPClientSocket::Write(IOBuffer* buf, int buf_len,
                                const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
-  if (!connected_)
+  if (!connected_ || !data_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
   // ERR_IO_PENDING is a signal that the socket data will call back
   // asynchronously.
   if (write_result.result == ERR_IO_PENDING) {
     pending_write_callback_ = callback;
     return ERR_IO_PENDING;
@@ skipping 33 matching lines @@
 const BoundNetLog& MockUDPClientSocket::NetLog() const {
   return net_log_;
 }
 
 int MockUDPClientSocket::BindToNetwork(
     NetworkChangeNotifier::NetworkHandle network) {
   return ERR_NOT_IMPLEMENTED;
 }
 
 int MockUDPClientSocket::Connect(const IPEndPoint& address) {
+  if (!data_)
+    return ERR_UNEXPECTED;
   connected_ = true;
   peer_addr_ = address;
   return data_->connect_data().result;
 }
 
 void MockUDPClientSocket::OnReadComplete(const MockRead& data) {
+  if (!data_)
+    return;
+
   // There must be a read pending.
   DCHECK(pending_read_buf_.get());
   // You can't complete a read with another ERR_IO_PENDING status code.
   DCHECK_NE(ERR_IO_PENDING, data.result);
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
   read_data_.mode = SYNCHRONOUS;
 
   CompletionCallback callback = pending_read_callback_;
   int rv = CompleteRead();
   RunCallback(callback, rv);
 }
 
 void MockUDPClientSocket::OnWriteComplete(int rv) {
+  if (!data_)
+    return;
+
   // There must be a read pending.
   DCHECK(!pending_write_callback_.is_null());
   CompletionCallback callback = pending_write_callback_;
   RunCallback(callback, rv);
 }
 
 void MockUDPClientSocket::OnConnectComplete(const MockConnect& data) {
   NOTIMPLEMENTED();
 }
 
+void MockUDPClientSocket::OnDataProviderDestroyed() {
+  data_ = nullptr;
+}
+
 int MockUDPClientSocket::CompleteRead() {
   DCHECK(pending_read_buf_.get());
   DCHECK(pending_read_buf_len_ > 0);
 
   // Save the pending async IO data and reset our |pending_| state.
   scoped_refptr<IOBuffer> buf = pending_read_buf_;
   int buf_len = pending_read_buf_len_;
   CompletionCallback callback = pending_read_callback_;
   pending_read_buf_ = NULL;
   pending_read_buf_len_ = 0;
@@ skipping 352 matching lines @@
 }
 
 int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size) {
   int64_t total = 0;
   for (const MockWrite* write = writes; write != writes + writes_size; ++write)
     total += write->data_len;
   return total;
 }
 
 }  // namespace net