Remove implicit conversions from scoped_refptr to T* in net/socket/

net/socket/ssl_client_socket_unittest.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_client_socket.h"
 
 #include "base/callback_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
@@ skipping 415 matching lines @@
 int FakeBlockingStreamSocket::Write(IOBuffer* buf,
                                     int len,
                                     const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_LE(0, len);
 
   if (!should_block_write_)
     return transport_->Write(buf, len, callback);
 
   // Schedule the write, but do nothing.
-  DCHECK(!pending_write_buf_);
+  DCHECK(!pending_write_buf_.get());
   DCHECK_EQ(-1, pending_write_len_);
   DCHECK(pending_write_callback_.is_null());
   DCHECK(!callback.is_null());
   pending_write_buf_ = buf;
   pending_write_len_ = len;
   pending_write_callback_ = callback;
 
   // Stop the write loop, if any.
   if (write_loop_)
     write_loop_->Quit();
@@ skipping 35 matching lines @@
   DCHECK(!should_block_write_);
   should_block_write_ = true;
 }
 
 void FakeBlockingStreamSocket::UnblockWrite() {
   DCHECK(should_block_write_);
   should_block_write_ = false;
 
   // Do nothing if UnblockWrite() was called after BlockWrite(),
   // without a Write() in between.
-  if (!pending_write_buf_)
+  if (!pending_write_buf_.get())
     return;
 
-  int rv = transport_->Write(pending_write_buf_, pending_write_len_,
-                             pending_write_callback_);
+  int rv = transport_->Write(
+      pending_write_buf_.get(), pending_write_len_, pending_write_callback_);
   pending_write_buf_ = NULL;
   pending_write_len_ = -1;
   if (rv == ERR_IO_PENDING) {
     pending_write_callback_.Reset();
   } else {
     base::ResetAndReturn(&pending_write_callback_).Run(rv);
   }
 }
 
 void FakeBlockingStreamSocket::WaitForWrite() {
   DCHECK(should_block_write_);
   DCHECK(!write_loop_);
 
-  if (pending_write_buf_)
+  if (pending_write_buf_.get())
     return;
   write_loop_.reset(new base::RunLoop);
   write_loop_->Run();
   write_loop_.reset();
-  DCHECK(pending_write_buf_);
+  DCHECK(pending_write_buf_.get());
 }
 
 void FakeBlockingStreamSocket::OnReadCompleted(int result) {
   DCHECK_EQ(ERR_IO_PENDING, pending_read_result_);
   DCHECK(!pending_read_callback_.is_null());
 
   if (should_block_read_) {
     // Store the result so that the callback can be invoked once Unblock() is
     // called.
     pending_read_result_ = result;
@@ skipping 1812 matching lines @@
   verify_result.verified_cert = X509Certificate::CreateFromHandle(
       certs[0]->os_cert_handle(), temp_intermediates);
 
   // Add a rule that maps the server cert (A) to the chain of A->B->C2
   // rather than A->B->C.
   cert_verifier_->AddResultForCert(certs[0].get(), verify_result, OK);
 
   // Load and install the root for the validated chain.
   scoped_refptr<X509Certificate> root_cert = ImportCertFromFile(
       GetTestCertsDirectory(), "redundant-validated-chain-root.pem");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), root_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), root_cert.get());
   ScopedTestRoot scoped_root(root_cert.get());
 
   // Set up a test server with CERT_CHAIN_WRONG_ROOT.
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_CHAIN_WRONG_ROOT);
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
@@ skipping 631 matching lines @@
   ssl_config.channel_id_enabled = true;
 
   int rv;
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
 
   EXPECT_EQ(ERR_UNEXPECTED, rv);
   EXPECT_FALSE(sock_->IsConnected());
 }
 
 }  // namespace net