Add Socket::ReadIfReady()

net/socket/socket_test_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

[davidben, 2017/02/01 22:25:57]

mmenke may be a better reviewer for this file. I'm not very familiar with what
it's doing. Is it possible to pattern it after the socket_posix.cc suggestion?
(Supposing, of course, you agree with it.)

[xunjieli, 2017/02/03 16:35:33]

Done.

 // 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 <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 680 matching lines @@
 
   NET_TRACE(1, " *** ") << " Completing socket write for: "
                         << data.sequence_number;
   socket()->OnWriteComplete(rv);
   NET_TRACE(1, " *** ") << "Done";
 }
 
 SequencedSocketData::~SequencedSocketData() {
 }
 
-MockClientSocketFactory::MockClientSocketFactory() {}
+MockClientSocketFactory::MockClientSocketFactory()
+    : enable_read_if_ready_(false) {}
 
 MockClientSocketFactory::~MockClientSocketFactory() {}
 
 void MockClientSocketFactory::AddSocketDataProvider(
     SocketDataProvider* data) {
   mock_data_.Add(data);
 }
 
 void MockClientSocketFactory::AddSSLSocketDataProvider(
     SSLSocketDataProvider* data) {
@@ skipping 23 matching lines @@
 
 std::unique_ptr<StreamSocket>
 MockClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
     std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
     NetLog* net_log,
     const NetLogSource& source) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   std::unique_ptr<MockTCPClientSocket> socket(
       new MockTCPClientSocket(addresses, net_log, data_provider));
+  if (enable_read_if_ready_)
+    socket->set_enable_read_if_ready(enable_read_if_ready_);
   return std::move(socket);
 }
 
 std::unique_ptr<SSLClientSocket> MockClientSocketFactory::CreateSSLClientSocket(
     std::unique_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     const SSLClientSocketContext& context) {
   SSLSocketDataProvider* next_ssl_data = mock_ssl_data_.GetNext();
   if (!next_ssl_data->next_protos_expected_in_ssl_config.empty()) {
@@ skipping 119 matching lines @@
                                          SocketDataProvider* data)
     : MockClientSocket(NetLogWithSource::Make(net_log, NetLogSourceType::NONE)),
       addresses_(addresses),
       data_(data),
       read_offset_(0),
       read_data_(SYNCHRONOUS, ERR_UNEXPECTED),
       need_read_data_(true),
       peer_closed_connection_(false),
       pending_read_buf_(NULL),
       pending_read_buf_len_(0),
-      was_used_to_convey_data_(false) {
+      was_used_to_convey_data_(false),
+      enable_read_if_ready_(false),
+      pending_read_type_(NONE),
+      weak_factory_(this) {
   DCHECK(data_);
   peer_addr_ = data->connect_data().peer_addr;
   data_->Initialize(this);
 }
 
 MockTCPClientSocket::~MockTCPClientSocket() {
   if (data_)
     data_->DetachSocket();
 }
 
 int MockTCPClientSocket::Read(IOBuffer* buf, int buf_len,
                               const CompletionCallback& callback) {
-  if (!connected_ || !data_)
-    return ERR_UNEXPECTED;
-
   // If the buffer is already in use, a read is already in progress!
   DCHECK(!pending_read_buf_);

[davidben, 2017/02/01 22:25:57]

DCHECK_EQ(NONE, pending_read_type_); to match?

[xunjieli, 2017/02/03 16:35:33]

Acknowledged. After applying the suggested Read()/ReadIfReady() split, this is
no longer applicable.

 
-  // Store our async IO data.
-  pending_read_buf_ = buf;
-  pending_read_buf_len_ = buf_len;
-  pending_read_callback_ = callback;
+  int rv = ReadCommon(buf, buf_len, callback, /*use_read_if_ready=*/false);
+  if (rv != ERR_IO_PENDING)
+    return rv;
+  pending_read_type_ = READ;
+  return ERR_IO_PENDING;
+}
 
-  if (need_read_data_) {
-    read_data_ = data_->OnRead();
-    if (read_data_.result == ERR_CONNECTION_CLOSED) {
-      // This MockRead is just a marker to instruct us to set
-      // peer_closed_connection_.
-      peer_closed_connection_ = true;
-    }
-    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_->OnRead();
-      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) {
-      // We need to be using async IO in this case.
-      DCHECK(!callback.is_null());
-      return ERR_IO_PENDING;
-    }
-    need_read_data_ = false;
-  }
+int MockTCPClientSocket::ReadIfReady(IOBuffer* buf,
+                                     int buf_len,
+                                     const CompletionCallback& callback) {
+  DCHECK_EQ(NONE, pending_read_type_);
 
-  return CompleteRead();
+  if (!enable_read_if_ready_)
+    return ERR_READ_IF_READY_NOT_IMPLEMENTED;
+
+  int rv = ReadCommon(buf, buf_len, callback, /*use_read_if_ready=*/false);
+  pending_read_buf_ = nullptr;
+  pending_read_buf_len_ = 0;
+  if (rv != ERR_IO_PENDING)
+    return rv;
+  pending_read_type_ = READ_IF_READY;
+  return ERR_IO_PENDING;
 }
 
 int MockTCPClientSocket::Write(IOBuffer* buf, int buf_len,
                                const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_ || !data_)
     return ERR_UNEXPECTED;
 
@@ skipping 93 matching lines @@
   EXPECT_FALSE(IsConnected()) << "Can't enable fast open after connect.";
 
   data_->OnEnableTCPFastOpenIfSupported();
 }
 
 bool MockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   return false;
 }
 
 void MockTCPClientSocket::OnReadComplete(const MockRead& data) {
+  DCHECK_NE(NONE, pending_read_type_);
+
   // If |data_| has been destroyed, safest to just do nothing.
   if (!data_)
     return;
 
   // There must be a read pending.
-  DCHECK(pending_read_buf_.get());
+  DCHECK(!pending_read_callback_.is_null());
   // 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;
 
+  CompletionCallback callback = pending_read_callback_;
+  pending_read_callback_.Reset();
+
   // 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);
+  if (pending_read_type_ == READ_IF_READY) {
+    RunReadCallback(callback, read_data_.result > 0 ? OK : read_data_.result);
+  } else {
+    int rv = CompleteRead(pending_read_type_);
+    RunReadCallback(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() {
+int MockTCPClientSocket::ReadCommon(IOBuffer* buf,
+                                    int buf_len,
+                                    const CompletionCallback& callback,
+                                    bool use_read_if_ready) {

[davidben, 2017/02/01 22:25:57]

This parameter doesn't seem to be used. Did you mean to pass it into
CompleteRead?

[xunjieli, 2017/02/03 16:35:33]

Acknowledged. After applying the suggested Read()/ReadIfReady() split, this is
no longer applicable.

+  if (!connected_ || !data_)
+    return ERR_UNEXPECTED;
+
+  // If the buffer is already in use, a read is already in progress!
+  DCHECK(!pending_read_buf_);
+  DCHECK_EQ(NONE, pending_read_type_);
+
+  // Store our async IO data.
+  pending_read_buf_ = buf;
+  pending_read_buf_len_ = buf_len;
+  pending_read_callback_ = callback;
+
+  if (need_read_data_) {
+    read_data_ = data_->OnRead();
+    if (read_data_.result == ERR_CONNECTION_CLOSED) {
+      // This MockRead is just a marker to instruct us to set
+      // peer_closed_connection_.
+      peer_closed_connection_ = true;
+    }
+    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_->OnRead();
+      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) {
+      // We need to be using async IO in this case.
+      DCHECK(!callback.is_null());
+      return ERR_IO_PENDING;
+    }
+    need_read_data_ = false;
+  }
+
+  return CompleteRead(false);
+}
+
+int MockTCPClientSocket::CompleteRead(bool read_if_ready_used) {
   DCHECK(pending_read_buf_.get());
   DCHECK(pending_read_buf_len_ > 0);
 
   was_used_to_convey_data_ = true;
 
+  if (read_if_ready_used && read_data_.mode == ASYNC) {
+    CompletionCallback callback = pending_read_callback_;
+    pending_read_callback_.Reset();
+    DCHECK(!callback.is_null());
+    RunReadCallbackAsync(callback,
+                         read_data_.result > 0 ? OK : read_data_.result);
+    return ERR_IO_PENDING;
+  }
   // 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;
   pending_read_callback_.Reset();
 
   int result = read_data_.result;
   DCHECK(result != ERR_IO_PENDING);
 
   if (read_data_.data) {
     if (read_data_.data_len - read_offset_ > 0) {
       result = std::min(buf_len, read_data_.data_len - read_offset_);
       memcpy(buf->data(), read_data_.data + read_offset_, result);
       read_offset_ += result;
       if (read_offset_ == read_data_.data_len) {
         need_read_data_ = true;
         read_offset_ = 0;
       }
     } else {
       result = 0;  // EOF
     }
   }
 
   if (read_data_.mode == ASYNC) {
     DCHECK(!callback.is_null());
-    RunCallbackAsync(callback, result);
+    RunReadCallbackAsync(callback, result);
     return ERR_IO_PENDING;
   }
   return result;
 }
 
+void MockTCPClientSocket::RunReadCallback(const CompletionCallback& callback,
+                                          int result) {
+  pending_read_type_ = NONE;
+  MockClientSocket::RunCallback(callback, result);
+}
+
+void MockTCPClientSocket::RunReadCallbackAsync(
+    const CompletionCallback& callback,
+    int result) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&MockTCPClientSocket::RunReadCallback,
+                            weak_factory_.GetWeakPtr(), callback, result));
+}
+
 // static
 void MockSSLClientSocket::ConnectCallback(
     MockSSLClientSocket* ssl_client_socket,
     const CompletionCallback& callback,
     int rv) {
   if (rv == OK)
     ssl_client_socket->connected_ = true;
   callback.Run(rv);
 }
 
@@ skipping 15 matching lines @@
 
 MockSSLClientSocket::~MockSSLClientSocket() {
   Disconnect();
 }
 
 int MockSSLClientSocket::Read(IOBuffer* buf, int buf_len,
                               const CompletionCallback& callback) {
   return transport_->socket()->Read(buf, buf_len, callback);
 }
 
+int MockSSLClientSocket::ReadIfReady(IOBuffer* buf,
+                                     int buf_len,
+                                     const CompletionCallback& callback) {
+  return transport_->socket()->ReadIfReady(buf, buf_len, callback);
+}
+
 int MockSSLClientSocket::Write(IOBuffer* buf, int buf_len,
                                const CompletionCallback& callback) {
   return transport_->socket()->Write(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Connect(const CompletionCallback& callback) {
   int rv = transport_->socket()->Connect(
       base::Bind(&ConnectCallback, base::Unretained(this), callback));
   if (rv == OK) {
     if (data_->connect.result == OK)
@@ skipping 567 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