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/feature_list.h"
 #include "base/location.h"
 #include "base/logging.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::FeatureList::IsEnabled(Socket::kReadIfReadyExperiment)) {
+      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 37 matching lines @@
     read_buffer_ = nullptr;
 }
 
 void SocketBIOAdapter::OnSocketReadComplete(int result) {
   DCHECK_EQ(ERR_IO_PENDING, read_result_);
 
   HandleSocketReadResult(result);
   delegate_->OnReadReady();
 }
 
+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();
+}
+
 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);
 
   // If a previous Write() failed, report the error.
   if (write_error_ != OK && write_error_ != ERR_IO_PENDING) {
@@ skipping 182 matching lines @@
     SocketBIOAdapter::BIOReadWrapper,
     nullptr,  // puts
     nullptr,  // gets
     SocketBIOAdapter::BIOCtrlWrapper,
     nullptr,  // create
     nullptr,  // destroy
     nullptr,  // callback_ctrl
 };
 
 }  // namespace net