Follow up to wtc comments on http://codereview.chromium.org/3571011

net/socket/ssl_client_socket_openssl.cc

 // Copyright (c) 2010 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.
 
 // OpenSSL binding for SSLClientSocket. The class layout and general principle
 // of operation is derived from SSLClientSocketNSS.
 
 #include "net/socket/ssl_client_socket_openssl.h"
 
 #include <openssl/ssl.h>
@@ skipping 31 matching lines @@
     DVLOG(1) << "SSL error " << error_num << ": " << buf;
   }
 }
 
 int MapOpenSSLError(int err) {
   switch (err) {
     case SSL_ERROR_WANT_READ:
     case SSL_ERROR_WANT_WRITE:
       return ERR_IO_PENDING;
     case SSL_ERROR_SYSCALL:
-      DVLOG(1) << "OpenSSL SYSVCALL error, errno " << errno;
+      DVLOG(1) << "OpenSSL SYSCALL error, errno " << errno;
       MaybeLogSSLError();
       return ERR_SSL_PROTOCOL_ERROR;
     default:
       // TODO(joth): Implement full mapping.
       LOG(WARNING) << "Unknown OpenSSL error " << err;
       MaybeLogSSLError();
       return ERR_SSL_PROTOCOL_ERROR;
   }
 }
 
@@ skipping 309 matching lines @@
             next_handshake_state_ != STATE_NONE);
   return rv;
 }
 
 int SSLClientSocketOpenSSL::DoHandshake() {
   int net_error = net::OK;
   int rv = SSL_do_handshake(ssl_);
 
   if (rv == 1) {
     // SSL handshake is completed.  Let's verify the certificate.
-    if (UpdateServerCert() == NULL) {
-      net_error = ERR_SSL_PROTOCOL_ERROR;
-    } else {
-      GotoState(STATE_VERIFY_CERT);
-
-      // TODO(joth): Remove this check when X509Certificate::Verify is
-      // implemented for OpenSSL
-      long verify_result = SSL_get_verify_result(ssl_);
-      LOG_IF(WARNING, verify_result != X509_V_OK)
-          << "Built in verify failed: " << verify_result;
-    }
+    const bool got_cert = !!UpdateServerCert();
+    DCHECK(got_cert);
+    GotoState(STATE_VERIFY_CERT);
   } else {
     int ssl_error = SSL_get_error(ssl_, rv);
     net_error = MapOpenSSLError(ssl_error);
 
     // If not done, stay in this state
     if (net_error == ERR_IO_PENDING) {
       GotoState(STATE_HANDSHAKE);
     } else {
       LOG(ERROR) << "handshake failed; returned " << rv
                  << ", SSL error code " << ssl_error
@@ skipping 120 matching lines @@
   return rv;
 }
 
 void SSLClientSocketOpenSSL::BufferSendComplete(int result) {
   transport_send_busy_ = false;
   TransportWriteComplete(result);
   OnSendComplete(result);
 }
 
 void SSLClientSocketOpenSSL::TransportWriteComplete(int result) {
+  DCHECK(ERR_IO_PENDING != result);
   if (result < 0) {
     // Got a socket write error; close the BIO to indicate this upward.
+    DVLOG(1) << "TransportWriteComplete error " << result;
     (void)BIO_shutdown_wr(transport_bio_);
     send_buffer_ = NULL;
   } else {
     DCHECK(send_buffer_);
     send_buffer_->DidConsume(result);
     DCHECK_GE(send_buffer_->BytesRemaining(), 0);
     if (send_buffer_->BytesRemaining() <= 0)
       send_buffer_ = NULL;
   }
 }
@@ skipping 19 matching lines @@
   }
   return rv;
 }
 
 void SSLClientSocketOpenSSL::BufferRecvComplete(int result) {
   TransportReadComplete(result);
   OnRecvComplete(result);
 }
 
 void SSLClientSocketOpenSSL::TransportReadComplete(int result) {
-  if (result > 0) {
+  DCHECK(ERR_IO_PENDING != result);
+  if (result <= 0) {
+    DVLOG(1) << "TransportReadComplete result " << result;
+    // Received 0 (end of file) or an error. Either way, bubble it up to the
+    // SSL layer via the BIO.
+    BIO_set_mem_eof_return(transport_bio_, 0);
+    (void)BIO_shutdown_wr(transport_bio_);
+  } else {
+    DCHECK(recv_buffer_);
     int ret = BIO_write(transport_bio_, recv_buffer_->data(), result);
     // A write into a memory BIO should always succeed.
     CHECK_EQ(result, ret);
-  } else {
-    // Received end of file: bubble it up to the SSL layer via the BIO.
-    BIO_set_mem_eof_return(transport_bio_, 0);
-    (void)BIO_shutdown_wr(transport_bio_);
   }
   recv_buffer_ = NULL;
   transport_recv_busy_ = false;
 }
 
 void SSLClientSocketOpenSSL::DoConnectCallback(int rv) {
   CompletionCallback* c = user_connect_callback_;
   user_connect_callback_ = NULL;
   c->Run(rv > OK ? OK : rv);
 }
@@ skipping 185 matching lines @@
   int rv = SSL_write(ssl_, user_write_buf_->data(), user_write_buf_len_);
 
   if (rv >= 0)
     return rv;
 
   int err = SSL_get_error(ssl_, rv);
   return MapOpenSSLError(err);
 }
 
 } // namespace net