Update Android to use scoped_refptr<T>::get() rather than implicit "operator T*"

net/socket/ssl_client_socket_openssl.cc

Index: net/socket/ssl_client_socket_openssl.cc
diff --git a/net/socket/ssl_client_socket_openssl.cc b/net/socket/ssl_client_socket_openssl.cc
index 9269c0c15d0356292fecb9bc3bba4d838c3c44da..9141a5b57724334cd04286807db7c4db71d8704d 100644
--- a/net/socket/ssl_client_socket_openssl.cc
+++ b/net/socket/ssl_client_socket_openssl.cc
@@ -590,7 +590,7 @@ int SSLClientSocketOpenSSL::ClientCertRequestCallback(SSL* ssl,
   }
 
   // Second pass: a client certificate should have been selected.
-  if (ssl_config_.client_cert) {
+  if (ssl_config_.client_cert.get()) {
     // A note about ownership: FetchClientCertPrivateKey() increments
     // the reference count of the EVP_PKEY. Ownership of this reference
     // is passed directly to OpenSSL, which will release the reference
@@ -616,7 +616,7 @@ int SSLClientSocketOpenSSL::ClientCertRequestCallback(SSL* ssl,
 
 bool SSLClientSocketOpenSSL::GetSSLInfo(SSLInfo* ssl_info) {
   ssl_info->Reset();
-  if (!server_cert_)
+  if (!server_cert_.get())
     return false;
 
   ssl_info->cert = server_cert_verify_result_.verified_cert;
@@ -626,7 +626,7 @@ bool SSLClientSocketOpenSSL::GetSSLInfo(SSLInfo* ssl_info) {
   ssl_info->public_key_hashes =
     server_cert_verify_result_.public_key_hashes;
   ssl_info->client_cert_sent =
-      ssl_config_.send_client_cert && ssl_config_.client_cert;
+      ssl_config_.send_client_cert && ssl_config_.client_cert.get();
   ssl_info->channel_id_sent = WasChannelIDSent();
 
   const SSL_CIPHER* cipher = SSL_get_current_cipher(ssl_);
@@ -927,11 +927,11 @@ int SSLClientSocketOpenSSL::SelectNextProtoCallback(unsigned char** out,
 }
 
 int SSLClientSocketOpenSSL::DoVerifyCert(int result) {
-  DCHECK(server_cert_);
+  DCHECK(server_cert_.get());
   GotoState(STATE_VERIFY_CERT_COMPLETE);
 
   CertStatus cert_status;
-  if (ssl_config_.IsAllowedBadCert(server_cert_, &cert_status)) {
+  if (ssl_config_.IsAllowedBadCert(server_cert_.get(), &cert_status)) {
     VLOG(1) << "Received an expected bad cert with status: " << cert_status;
     server_cert_verify_result_.Reset();
     server_cert_verify_result_.cert_status = cert_status;
@@ -948,7 +948,9 @@ int SSLClientSocketOpenSSL::DoVerifyCert(int result) {
     flags |= CertVerifier::VERIFY_CERT_IO_ENABLED;
   verifier_.reset(new SingleRequestCertVerifier(cert_verifier_));
   return verifier_->Verify(
-      server_cert_, host_and_port_.host(), flags,
+      server_cert_.get(),
+      host_and_port_.host(),
+      flags,
       NULL /* no CRL set */,
       &server_cert_verify_result_,
       base::Bind(&SSLClientSocketOpenSSL::OnHandshakeIOComplete,
@@ -974,8 +976,8 @@ int SSLClientSocketOpenSSL::DoVerifyCertComplete(int result) {
 }
 
 X509Certificate* SSLClientSocketOpenSSL::UpdateServerCert() {
-  if (server_cert_)
-    return server_cert_;
+  if (server_cert_.get())
+    return server_cert_.get();
 
   crypto::ScopedOpenSSL<X509, X509_free> cert(SSL_get_peer_certificate(ssl_));
   if (!cert.get()) {
@@ -992,9 +994,9 @@ X509Certificate* SSLClientSocketOpenSSL::UpdateServerCert() {
       intermediates.push_back(sk_X509_value(chain, i));
   }
   server_cert_ = X509Certificate::CreateFromHandle(cert.get(), intermediates);
-  DCHECK(server_cert_);
+  DCHECK(server_cert_.get());
 
-  return server_cert_;
+  return server_cert_.get();
 }
 
 bool SSLClientSocketOpenSSL::DoTransportIO() {
@@ -1016,7 +1018,7 @@ int SSLClientSocketOpenSSL::BufferSend(void) {
   if (transport_send_busy_)
     return ERR_IO_PENDING;
 
-  if (!send_buffer_) {
+  if (!send_buffer_.get()) {
     // Get a fresh send buffer out of the send BIO.
     size_t max_read = BIO_ctrl_pending(transport_bio_);
     if (!max_read)
@@ -1028,10 +1030,10 @@ int SSLClientSocketOpenSSL::BufferSend(void) {
   }
 
   int rv = transport_->socket()->Write(
-        send_buffer_,
-        send_buffer_->BytesRemaining(),
-        base::Bind(&SSLClientSocketOpenSSL::BufferSendComplete,
-                   base::Unretained(this)));
+      send_buffer_.get(),
+      send_buffer_->BytesRemaining(),
+      base::Bind(&SSLClientSocketOpenSSL::BufferSendComplete,
+                 base::Unretained(this)));
   if (rv == ERR_IO_PENDING) {
     transport_send_busy_ = true;
   } else {
@@ -1055,7 +1057,7 @@ void SSLClientSocketOpenSSL::TransportWriteComplete(int result) {
     BIO_set_mem_eof_return(transport_bio_, 0);
     send_buffer_ = NULL;
   } else {
-    DCHECK(send_buffer_);
+    DCHECK(send_buffer_.get());
     send_buffer_->DidConsume(result);
     DCHECK_GE(send_buffer_->BytesRemaining(), 0);
     if (send_buffer_->BytesRemaining() <= 0)
@@ -1091,7 +1093,8 @@ int SSLClientSocketOpenSSL::BufferRecv(void) {
 
   recv_buffer_ = new IOBuffer(max_write);
   int rv = transport_->socket()->Read(
-      recv_buffer_, max_write,
+      recv_buffer_.get(),
+      max_write,
       base::Bind(&SSLClientSocketOpenSSL::BufferRecvComplete,
                  base::Unretained(this)));
   if (rv == ERR_IO_PENDING) {
@@ -1119,7 +1122,7 @@ void SSLClientSocketOpenSSL::TransportReadComplete(int result) {
     BIO_set_mem_eof_return(transport_bio_, 0);
     (void)BIO_shutdown_wr(transport_bio_);
   } else {
-    DCHECK(recv_buffer_);
+    DCHECK(recv_buffer_.get());
     int ret = BIO_write(transport_bio_, recv_buffer_->data(), result);
     // A write into a memory BIO should always succeed.
     CHECK_EQ(result, ret);
@@ -1157,28 +1160,26 @@ void SSLClientSocketOpenSSL::OnSendComplete(int result) {
   int rv_write = ERR_IO_PENDING;
   bool network_moved;
   do {
-      if (user_read_buf_)
-          rv_read = DoPayloadRead();
-      if (user_write_buf_)
-          rv_write = DoPayloadWrite();
-      network_moved = DoTransportIO();
-  } while (rv_read == ERR_IO_PENDING &&
-           rv_write == ERR_IO_PENDING &&
-           (user_read_buf_ || user_write_buf_) &&
-           network_moved);
+    if (user_read_buf_.get())
+      rv_read = DoPayloadRead();
+    if (user_write_buf_.get())
+      rv_write = DoPayloadWrite();
+    network_moved = DoTransportIO();
+  } while (rv_read == ERR_IO_PENDING && rv_write == ERR_IO_PENDING &&
+           (user_read_buf_.get() || user_write_buf_.get()) && network_moved);
 
   // Performing the Read callback may cause |this| to be deleted. If this
   // happens, the Write callback should not be invoked. Guard against this by
   // holding a WeakPtr to |this| and ensuring it's still valid.
   base::WeakPtr<SSLClientSocketOpenSSL> guard(weak_factory_.GetWeakPtr());
-  if (user_read_buf_ && rv_read != ERR_IO_PENDING)
-      DoReadCallback(rv_read);
+  if (user_read_buf_.get() && rv_read != ERR_IO_PENDING)
+    DoReadCallback(rv_read);
 
   if (!guard.get())
     return;
 
-  if (user_write_buf_ && rv_write != ERR_IO_PENDING)
-      DoWriteCallback(rv_write);
+  if (user_write_buf_.get() && rv_write != ERR_IO_PENDING)
+    DoWriteCallback(rv_write);
 }
 
 void SSLClientSocketOpenSSL::OnRecvComplete(int result) {
@@ -1190,7 +1191,7 @@ void SSLClientSocketOpenSSL::OnRecvComplete(int result) {
 
   // Network layer received some data, check if client requested to read
   // decrypted data.
-  if (!user_read_buf_)
+  if (!user_read_buf_.get())
     return;
 
   int rv = DoReadLoop(result);
@@ -1203,7 +1204,7 @@ bool SSLClientSocketOpenSSL::IsConnected() const {
   if (!completed_handshake_)
     return false;
   // If an asynchronous operation is still pending.
-  if (user_read_buf_ || user_write_buf_)
+  if (user_read_buf_.get() || user_write_buf_.get())
     return true;
 
   return transport_->socket()->IsConnected();
@@ -1214,7 +1215,7 @@ bool SSLClientSocketOpenSSL::IsConnectedAndIdle() const {
   if (!completed_handshake_)
     return false;
   // If an asynchronous operation is still pending.
-  if (user_read_buf_ || user_write_buf_)
+  if (user_read_buf_.get() || user_write_buf_.get())
     return false;
   // If there is data waiting to be sent, or data read from the network that
   // has not yet been consumed.