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

net/socket/ssl_client_socket_nss.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.
 
 // This file includes code SSLClientSocketNSS::DoVerifyCertComplete() derived
 // from AuthCertificateCallback() in
 // mozilla/security/manager/ssl/src/nsNSSCallbacks.cpp.
 
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
@@ skipping 1075 matching lines @@
         FROM_HERE,
         base::Bind(IgnoreResult(&Core::Connect), this, callback));
     return posted ? ERR_IO_PENDING : ERR_ABORTED;
   }
 
   DCHECK(OnNSSTaskRunner());
   DCHECK_EQ(STATE_NONE, next_handshake_state_);
   DCHECK(user_read_callback_.is_null());
   DCHECK(user_write_callback_.is_null());
   DCHECK(user_connect_callback_.is_null());
-  DCHECK(!user_read_buf_);
-  DCHECK(!user_write_buf_);
+  DCHECK(!user_read_buf_.get());
+  DCHECK(!user_write_buf_.get());
 
   next_handshake_state_ = STATE_HANDSHAKE;
   int rv = DoHandshakeLoop(OK);
   if (rv == ERR_IO_PENDING) {
     user_connect_callback_ = callback;
   } else if (rv > OK) {
     rv = OK;
   }
   if (rv != ERR_IO_PENDING && !OnNetworkTaskRunner()) {
     PostOrRunCallback(FROM_HERE, base::Bind(callback, rv));
@@ skipping 33 matching lines @@
       nss_waiting_read_ = false;
     }
     return posted ? ERR_IO_PENDING : ERR_ABORTED;
   }
 
   DCHECK(OnNSSTaskRunner());
   DCHECK(handshake_callback_called_);
   DCHECK_EQ(STATE_NONE, next_handshake_state_);
   DCHECK(user_read_callback_.is_null());
   DCHECK(user_connect_callback_.is_null());
-  DCHECK(!user_read_buf_);
+  DCHECK(!user_read_buf_.get());
   DCHECK(nss_bufs_);
 
   user_read_buf_ = buf;
   user_read_buf_len_ = buf_len;
 
   int rv = DoReadLoop(OK);
   if (rv == ERR_IO_PENDING) {
     if (OnNetworkTaskRunner())
       nss_waiting_read_ = true;
     user_read_callback_ = callback;
@@ skipping 33 matching lines @@
       nss_waiting_write_ = false;
     }
     return posted ? ERR_IO_PENDING : ERR_ABORTED;
   }
 
   DCHECK(OnNSSTaskRunner());
   DCHECK(handshake_callback_called_);
   DCHECK_EQ(STATE_NONE, next_handshake_state_);
   DCHECK(user_write_callback_.is_null());
   DCHECK(user_connect_callback_.is_null());
-  DCHECK(!user_write_buf_);
+  DCHECK(!user_write_buf_.get());
   DCHECK(nss_bufs_);
 
   user_write_buf_ = buf;
   user_write_buf_len_ = buf_len;
 
   int rv = DoWriteLoop(OK);
   if (rv == ERR_IO_PENDING) {
     if (OnNetworkTaskRunner())
       nss_waiting_write_ = true;
     user_write_callback_ = callback;
@@ skipping 322 matching lines @@
       FROM_HERE,
       base::Bind(&AddLogEvent, core->weak_net_log_,
                  NetLog::TYPE_SSL_CLIENT_CERT_REQUESTED));
 
   // Regular client certificate requested.
   core->client_auth_cert_needed_ = !core->ssl_config_.send_client_cert;
   void* wincx  = SSL_RevealPinArg(socket);
 
   if (core->ssl_config_.send_client_cert) {
     // Second pass: a client certificate should have been selected.
-    if (core->ssl_config_.client_cert) {
-      CERTCertificate* cert = CERT_DupCertificate(
-          core->ssl_config_.client_cert->os_cert_handle());
+    if (core->ssl_config_.client_cert.get()) {
+      CERTCertificate* cert =
+          CERT_DupCertificate(core->ssl_config_.client_cert->os_cert_handle());
       SECKEYPrivateKey* privkey = PK11_FindKeyByAnyCert(cert, wincx);
       if (privkey) {
         // TODO(jsorianopastor): We should wait for server certificate
         // verification before sending our credentials.  See
         // http://crbug.com/13934.
         *result_certificate = cert;
         *result_private_key = privkey;
         // A cert_count of -1 means the number of certificates is unknown.
         // NSS will construct the certificate chain.
         core->AddCertProvidedEvent(-1);
@@ skipping 389 matching lines @@
   if (rv != SECSuccess)
     return MapNSSError(PORT_GetError());
 
   SetChannelIDProvided();
   GotoState(STATE_HANDSHAKE);
   return OK;
 }
 
 int SSLClientSocketNSS::Core::DoPayloadRead() {
   DCHECK(OnNSSTaskRunner());
-  DCHECK(user_read_buf_);
+  DCHECK(user_read_buf_.get());
   DCHECK_GT(user_read_buf_len_, 0);
 
   int rv;
   // If a previous greedy read resulted in an error that was not consumed (eg:
   // due to the caller having read some data successfully), then return that
   // pending error now.
   if (pending_read_result_ != kNoPendingReadResult) {
     rv = pending_read_result_;
     PRErrorCode prerr = pending_read_nss_error_;
     pending_read_result_ = kNoPendingReadResult;
@@ skipping 97 matching lines @@
                    NetLog::TYPE_SSL_READ_ERROR,
                    CreateNetLogSSLErrorCallback(rv, pending_read_nss_error_)));
     pending_read_nss_error_ = 0;
   }
   return rv;
 }
 
 int SSLClientSocketNSS::Core::DoPayloadWrite() {
   DCHECK(OnNSSTaskRunner());
 
-  DCHECK(user_write_buf_);
+  DCHECK(user_write_buf_.get());
 
   int old_amount_in_read_buffer = memio_GetReadableBufferSize(nss_bufs_);
   int rv = PR_Write(nss_fd_, user_write_buf_->data(), user_write_buf_len_);
   int new_amount_in_read_buffer = memio_GetReadableBufferSize(nss_bufs_);
   // PR_Write could potentially consume the unhandled data in the memio read
   // buffer if a renegotiation is in progress. If the buffer is consumed,
   // notify the latest buffer size to NetworkRunner.
   if (old_amount_in_read_buffer != new_amount_in_read_buffer) {
     PostOrRunCallback(
         FROM_HERE,
@@ skipping 61 matching lines @@
 
   char* buf;
   int nb = memio_GetReadParams(nss_bufs_, &buf);
   int rv;
   if (!nb) {
     // buffer too full to read into, so no I/O possible at moment
     rv = ERR_IO_PENDING;
   } else {
     scoped_refptr<IOBuffer> read_buffer(new IOBuffer(nb));
     if (OnNetworkTaskRunner()) {
-      rv = DoBufferRecv(read_buffer, nb);
+      rv = DoBufferRecv(read_buffer.get(), nb);
     } else {
       bool posted = network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(IgnoreResult(&Core::DoBufferRecv), this, read_buffer,
                      nb));
       rv = posted ? ERR_IO_PENDING : ERR_ABORTED;
     }
 
     if (rv == ERR_IO_PENDING) {
       transport_recv_busy_ = true;
@@ skipping 24 matching lines @@
   memio_GetWriteParams(nss_bufs_, &buf1, &len1, &buf2, &len2);
   const unsigned int len = len1 + len2;
 
   int rv = 0;
   if (len) {
     scoped_refptr<IOBuffer> send_buffer(new IOBuffer(len));
     memcpy(send_buffer->data(), buf1, len1);
     memcpy(send_buffer->data() + len1, buf2, len2);
 
     if (OnNetworkTaskRunner()) {
-      rv = DoBufferSend(send_buffer, len);
+      rv = DoBufferSend(send_buffer.get(), len);
     } else {
       bool posted = network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(IgnoreResult(&Core::DoBufferSend), this, send_buffer,
                      len));
       rv = posted ? ERR_IO_PENDING : ERR_ABORTED;
     }
 
     if (rv == ERR_IO_PENDING) {
       transport_send_busy_ = true;
     } else {
       memio_PutWriteResult(nss_bufs_, MapErrorToNSS(rv));
     }
   }
 
   return rv;
 }
 
 void SSLClientSocketNSS::Core::OnRecvComplete(int result) {
   DCHECK(OnNSSTaskRunner());
 
   if (next_handshake_state_ == STATE_HANDSHAKE) {
     OnHandshakeIOComplete(result);
     return;
   }
 
   // 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);
   if (rv != ERR_IO_PENDING)
     DoReadCallback(rv);
 }
 
 void SSLClientSocketNSS::Core::OnSendComplete(int result) {
   DCHECK(OnNSSTaskRunner());
 
   if (next_handshake_state_ == STATE_HANDSHAKE) {
     OnHandshakeIOComplete(result);
     return;
   }
 
   // OnSendComplete may need to call DoPayloadRead while the renegotiation
   // handshake is in progress.
   int rv_read = ERR_IO_PENDING;
   int rv_write = ERR_IO_PENDING;
   bool network_moved;
   do {
-    if (user_read_buf_)
+    if (user_read_buf_.get())
       rv_read = DoPayloadRead();
-    if (user_write_buf_)
+    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_ || user_write_buf_) &&
-           network_moved);
+  } while (rv_read == ERR_IO_PENDING && rv_write == ERR_IO_PENDING &&
+           (user_read_buf_.get() || user_write_buf_.get()) && network_moved);
 
   // If the parent SSLClientSocketNSS is deleted during the processing of the
   // Read callback and OnNSSTaskRunner() == OnNetworkTaskRunner(), then the Core
   // will be detached (and possibly deleted). Guard against deletion by taking
   // an extra reference, then check if the Core was detached before invoking the
   // next callback.
   scoped_refptr<Core> guard(this);
-  if (user_read_buf_ && rv_read != ERR_IO_PENDING)
+  if (user_read_buf_.get() && rv_read != ERR_IO_PENDING)
     DoReadCallback(rv_read);
 
   if (OnNetworkTaskRunner() && detached_)
     return;
 
-  if (user_write_buf_ && rv_write != ERR_IO_PENDING)
+  if (user_write_buf_.get() && rv_write != ERR_IO_PENDING)
     DoWriteCallback(rv_write);
 }
 
 // As part of Connect(), the SSLClientSocketNSS object performs an SSL
 // handshake. This requires network IO, which in turn calls
 // BufferRecvComplete() with a non-zero byte count. This byte count eventually
 // winds its way through the state machine and ends up being passed to the
 // callback. For Read() and Write(), that's what we want. But for Connect(),
 // the caller expects OK (i.e. 0) for success.
 void SSLClientSocketNSS::Core::DoConnectCallback(int rv) {
@@ skipping 146 matching lines @@
       return ERR_INVALID_ARGUMENT;
   }
 
   return OK;
 }
 
 void SSLClientSocketNSS::Core::UpdateServerCert() {
   nss_handshake_state_.server_cert_chain.Reset(nss_fd_);
   nss_handshake_state_.server_cert = X509Certificate::CreateFromDERCertChain(
       nss_handshake_state_.server_cert_chain.AsStringPieceVector());
-  if (nss_handshake_state_.server_cert) {
+  if (nss_handshake_state_.server_cert.get()) {
     // Since this will be called asynchronously on another thread, it needs to
     // own a reference to the certificate.
     NetLog::ParametersCallback net_log_callback =
         base::Bind(&NetLogX509CertificateCallback,
                    nss_handshake_state_.server_cert);
     PostOrRunCallback(
         FROM_HERE,
         base::Bind(&AddLogEventWithCallback, weak_net_log_,
                    NetLog::TYPE_SSL_CERTIFICATES_RECEIVED,
                    net_log_callback));
@@ skipping 392 matching lines @@
   ssl_info->connection_status =
       core_->state().ssl_connection_status;
   ssl_info->public_key_hashes = server_cert_verify_result_.public_key_hashes;
   for (HashValueVector::const_iterator i = side_pinned_public_keys_.begin();
        i != side_pinned_public_keys_.end(); ++i) {
     ssl_info->public_key_hashes.push_back(*i);
   }
   ssl_info->is_issued_by_known_root =
       server_cert_verify_result_.is_issued_by_known_root;
   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();
 
   PRUint16 cipher_suite = SSLConnectionStatusToCipherSuite(
       core_->state().ssl_connection_status);
   SSLCipherSuiteInfo cipher_info;
   SECStatus ok = SSL_GetCipherSuiteInfo(cipher_suite,
                                         &cipher_info, sizeof(cipher_info));
   if (ok == SECSuccess) {
     ssl_info->security_bits = cipher_info.effectiveKeyBits;
   } else {
@@ skipping 184 matching lines @@
 bool SSLClientSocketNSS::UsingTCPFastOpen() const {
   if (transport_.get() && transport_->socket()) {
     return transport_->socket()->UsingTCPFastOpen();
   }
   NOTREACHED();
   return false;
 }
 
 int SSLClientSocketNSS::Read(IOBuffer* buf, int buf_len,
                              const CompletionCallback& callback) {
-  DCHECK(core_);
+  DCHECK(core_.get());
   DCHECK(!callback.is_null());
 
   EnterFunction(buf_len);
   int rv = core_->Read(buf, buf_len, callback);
   LeaveFunction(rv);
 
   return rv;
 }
 
 int SSLClientSocketNSS::Write(IOBuffer* buf, int buf_len,
                               const CompletionCallback& callback) {
-  DCHECK(core_);
+  DCHECK(core_.get());
   DCHECK(!callback.is_null());
 
   EnterFunction(buf_len);
   int rv = core_->Write(buf, buf_len, callback);
   LeaveFunction(rv);
 
   return rv;
 }
 
 bool SSLClientSocketNSS::SetReceiveBufferSize(int32 size) {
@@ skipping 18 matching lines @@
     // X509Certificate::Verify() runs on a worker thread of CertVerifier.
     EnsureNSSHttpIOInit();
   }
 #endif
 
   LeaveFunction("");
   return OK;
 }
 
 void SSLClientSocketNSS::InitCore() {
-  core_ = new Core(base::ThreadTaskRunnerHandle::Get(), nss_task_runner_,
-                   transport_.get(), host_and_port_, ssl_config_, &net_log_,
+  core_ = new Core(base::ThreadTaskRunnerHandle::Get(),
+                   nss_task_runner_.get(),
+                   transport_.get(),
+                   host_and_port_,
+                   ssl_config_,
+                   &net_log_,
                    server_bound_cert_service_);
 }
 
 int SSLClientSocketNSS::InitializeSSLOptions() {
   // Transport connected, now hook it up to nss
   nss_fd_ = memio_CreateIOLayer(kRecvBufferSize, kSendBufferSize);
   if (nss_fd_ == NULL) {
     return ERR_OUT_OF_MEMORY;  // TODO(port): map NSPR error code.
   }
 
@@ skipping 262 matching lines @@
     DCHECK(start_cert_verification_time_.is_null());
     VLOG(1) << "Received an expected bad cert with status: " << cert_status;
     server_cert_verify_result_.Reset();
     server_cert_verify_result_.cert_status = cert_status;
     server_cert_verify_result_.verified_cert = core_->state().server_cert;
     return OK;
   }
 
   // We may have failed to create X509Certificate object if we are
   // running inside sandbox.
-  if (!core_->state().server_cert) {
+  if (!core_->state().server_cert.get()) {
     server_cert_verify_result_.Reset();
     server_cert_verify_result_.cert_status = CERT_STATUS_INVALID;
     return ERR_CERT_INVALID;
   }
 
   start_cert_verification_time_ = base::TimeTicks::Now();
 
   int flags = 0;
   if (ssl_config_.rev_checking_enabled)
     flags |= CertVerifier::VERIFY_REV_CHECKING_ENABLED;
   if (ssl_config_.verify_ev_cert)
     flags |= CertVerifier::VERIFY_EV_CERT;
   if (ssl_config_.cert_io_enabled)
     flags |= CertVerifier::VERIFY_CERT_IO_ENABLED;
   verifier_.reset(new SingleRequestCertVerifier(cert_verifier_));
   return verifier_->Verify(
-      core_->state().server_cert, host_and_port_.host(), flags,
-      SSLConfigService::GetCRLSet(), &server_cert_verify_result_,
+      core_->state().server_cert.get(),
+      host_and_port_.host(),
+      flags,
+      SSLConfigService::GetCRLSet(),
+      &server_cert_verify_result_,
       base::Bind(&SSLClientSocketNSS::OnHandshakeIOComplete,
                  base::Unretained(this)),
       net_log_);
 }
 
 // Derived from AuthCertificateCallback() in
 // mozilla/source/security/manager/ssl/src/nsNSSCallbacks.cpp.
 int SSLClientSocketNSS::DoVerifyCertComplete(int result) {
   verifier_.reset();
 
@@ skipping 120 matching lines @@
   EnsureThreadIdAssigned();
   base::AutoLock auto_lock(lock_);
   return valid_thread_id_ == base::PlatformThread::CurrentId();
 }
 
 ServerBoundCertService* SSLClientSocketNSS::GetServerBoundCertService() const {
   return server_bound_cert_service_;
 }
 
 }  // namespace net