Add Socket::ReadIfReady()

net/socket/ssl_server_socket_impl.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/ssl_server_socket_impl.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 86 matching lines @@
   bool WasAlpnNegotiated() const override;
   NextProto GetNegotiatedProtocol() const override;
   bool GetSSLInfo(SSLInfo* ssl_info) override;
   void GetConnectionAttempts(ConnectionAttempts* out) const override;
   void ClearConnectionAttempts() override {}
   void AddConnectionAttempts(const ConnectionAttempts& attempts) override {}
   int64_t GetTotalReceivedBytes() const override;
   static int CertVerifyCallback(X509_STORE_CTX* store_ctx, void* arg);
 
   // SocketBIOAdapter::Delegate implementation.
-  void OnReadReady() override;
-  void OnWriteReady() override;
+  void OnReadReady(int result) override;
+  void OnWriteReady(int result) override;
 
  private:
   enum State {
     STATE_NONE,
     STATE_HANDSHAKE,
   };
 
   void OnHandshakeIOComplete(int result);
 
   int DoPayloadRead();
@@ skipping 244 matching lines @@
 }
 
 void SSLServerSocketImpl::GetConnectionAttempts(ConnectionAttempts* out) const {
   out->clear();
 }
 
 int64_t SSLServerSocketImpl::GetTotalReceivedBytes() const {
   return transport_socket_->GetTotalReceivedBytes();
 }
 
-void SSLServerSocketImpl::OnReadReady() {
+void SSLServerSocketImpl::OnReadReady(int result) {
   if (next_handshake_state_ == STATE_HANDSHAKE) {
     // In handshake phase. The parameter to OnHandshakeIOComplete is unused.
     OnHandshakeIOComplete(OK);
     return;
   }
 
   // BoringSSL does not support renegotiation as a server, so the only other
   // operation blocked on Read is DoPayloadRead.
   if (!user_read_buf_)
     return;
 
   int rv = DoPayloadRead();
   if (rv != ERR_IO_PENDING)
     DoReadCallback(rv);
 }
 
-void SSLServerSocketImpl::OnWriteReady() {
+void SSLServerSocketImpl::OnWriteReady(int result) {
   if (next_handshake_state_ == STATE_HANDSHAKE) {
     // In handshake phase. The parameter to OnHandshakeIOComplete is unused.
     OnHandshakeIOComplete(OK);
     return;
   }
 
   // BoringSSL does not support renegotiation as a server, so the only other
   // operation blocked on Read is DoPayloadWrite.
   if (!user_write_buf_)
     return;
@@ skipping 329 matching lines @@
 SSLServerContextImpl::~SSLServerContextImpl() {}
 
 std::unique_ptr<SSLServerSocket> SSLServerContextImpl::CreateSSLServerSocket(
     std::unique_ptr<StreamSocket> socket) {
   bssl::UniquePtr<SSL> ssl(SSL_new(ssl_ctx_.get()));
   return std::unique_ptr<SSLServerSocket>(
       new SSLServerSocketImpl(std::move(socket), std::move(ssl)));
 }
 
 }  // namespace net