Add Socket::ReadIfReady()

net/socket/socket_bio_adapter.cc

 // Copyright 2016 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_bio_adapter.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/metrics/field_trial.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
+#include "net/socket/socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/ssl/openssl_ssl_util.h"
 #include "third_party/boringssl/src/include/openssl/bio.h"
 
 namespace net {
 
 SocketBIOAdapter::SocketBIOAdapter(StreamSocket* socket,
                                    int read_buffer_capacity,
                                    int write_buffer_capacity,
                                    Delegate* delegate)
@@ skipping 53 matching lines @@
 
   if (read_result_ == 0) {
     // Instantiate the read buffer and read from the socket. Although only |len|
     // bytes were requested, intentionally read to the full buffer size. The SSL
     // layer reads the record header and body in separate reads to avoid
     // overreading, but issuing one is more efficient. SSL sockets are not
     // reused after shutdown for non-SSL traffic, so overreading is fine.
     DCHECK(!read_buffer_);
     DCHECK_EQ(0, read_offset_);
     read_buffer_ = new IOBuffer(read_buffer_capacity_);
-    int result = socket_->Read(read_buffer_.get(), read_buffer_capacity_,
-                               read_callback_);
+    int result = ERR_READ_IF_READY_NOT_IMPLEMENTED;
+    if (base::FieldTrialList::FindFullName(Socket::kReadIfReadyTrialName) ==
+        "enable") {
+      result = socket_->ReadIfReady(
+          read_buffer_.get(), read_buffer_capacity_,
+          base::Bind(&SocketBIOAdapter::OnSocketReadIfReadyComplete,
+                     weak_factory_.GetWeakPtr()));
+      if (result == ERR_IO_PENDING)
+        read_buffer_ = nullptr;
+    }
+    if (result == ERR_READ_IF_READY_NOT_IMPLEMENTED) {
+      result = socket_->Read(read_buffer_.get(), read_buffer_capacity_,
+                             read_callback_);
+    }
     if (result == ERR_IO_PENDING) {
       read_result_ = ERR_IO_PENDING;
     } else {
       HandleSocketReadResult(result);
     }
   }
 
   // There is a pending Read(). Inform the caller to retry when it completes.
   if (read_result_ == ERR_IO_PENDING) {
     BIO_set_retry_read(bio());
@@ skipping 34 matching lines @@
 
   // The read buffer is no longer needed.
   if (read_result_ <= 0)
     read_buffer_ = nullptr;
 }
 
 void SocketBIOAdapter::OnSocketReadComplete(int result) {
   DCHECK_EQ(ERR_IO_PENDING, read_result_);
 
   HandleSocketReadResult(result);
-  delegate_->OnReadReady();
+  delegate_->OnReadReady(read_result_ > 0 ? OK : read_result_);
+}
+
+void SocketBIOAdapter::OnSocketReadIfReadyComplete(int result) {
+  DCHECK_EQ(ERR_IO_PENDING, read_result_);
+  DCHECK_GE(OK, result);
+
+  // Do not use HandleSocketReadResult() because |result == OK| doesn't mean EOF
+  read_result_ = result;
+
+  delegate_->OnReadReady(read_result_);
 }
 
 int SocketBIOAdapter::BIOWrite(const char* in, int len) {
   if (len <= 0)
     return len;
 
   // If the write buffer is not empty, there must be a pending Write() to flush
   // it.
   DCHECK(write_buffer_used_ == 0 || write_error_ == ERR_IO_PENDING);
 
@@ skipping 50 matching lines @@
   // have been empty.)
   SocketWrite();
 
   // If a read-interrupting write error was synchronously discovered,
   // asynchronously notify OnReadReady. See https://crbug.com/249848. Avoid
   // reentrancy by deferring it to a later event loop iteration.
   if (write_error_ != OK && write_error_ != ERR_IO_PENDING &&
       read_result_ == ERR_IO_PENDING) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&SocketBIOAdapter::CallOnReadReady,
-                              weak_factory_.GetWeakPtr()));
+                              weak_factory_.GetWeakPtr(), write_error_));
   }
 
   return bytes_copied;
 }
 
 void SocketBIOAdapter::SocketWrite() {
   while (write_error_ == OK && write_buffer_used_ > 0) {
     int write_size =
         std::min(write_buffer_used_, write_buffer_->RemainingCapacity());
     int result =
@@ skipping 36 matching lines @@
 
   bool was_full = write_buffer_used_ == write_buffer_->capacity();
 
   HandleSocketWriteResult(result);
   SocketWrite();
 
   // If transitioning from being unable to accept data to being able to, signal
   // OnWriteReady.
   if (was_full) {
     base::WeakPtr<SocketBIOAdapter> guard(weak_factory_.GetWeakPtr());
-    delegate_->OnWriteReady();
+    DCHECK_GE(OK, write_error_);
+    delegate_->OnWriteReady(write_error_);
     // OnWriteReady may delete the adapter.
     if (!guard)
       return;
   }
 
   // Write errors are fed back into BIO_read once the read buffer is empty. If
   // BIO_read is currently blocked, signal early that a read result is ready.
   if (result < 0 && read_result_ == ERR_IO_PENDING)
-    delegate_->OnReadReady();
+    delegate_->OnReadReady(result);
 }
 
-void SocketBIOAdapter::CallOnReadReady() {
+void SocketBIOAdapter::CallOnReadReady(int rv) {
   if (read_result_ == ERR_IO_PENDING)
-    delegate_->OnReadReady();
+    delegate_->OnReadReady(rv);
 }
 
 SocketBIOAdapter* SocketBIOAdapter::GetAdapter(BIO* bio) {
   DCHECK_EQ(&kBIOMethod, bio->method);
   SocketBIOAdapter* adapter = reinterpret_cast<SocketBIOAdapter*>(bio->ptr);
   if (adapter)
     DCHECK_EQ(bio, adapter->bio());
   return adapter;
 }
 
@@ skipping 42 matching lines @@
     SocketBIOAdapter::BIOReadWrapper,
     nullptr,  // puts
     nullptr,  // gets
     SocketBIOAdapter::BIOCtrlWrapper,
     nullptr,  // create
     nullptr,  // destroy
     nullptr,  // callback_ctrl
 };
 
 }  // namespace net