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

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 "net/base/address_list.h"
 #include "net/base/io_buffer.h"
@@ skipping 144 matching lines @@
 };
 
 ReadBufferingStreamSocket::ReadBufferingStreamSocket(
     scoped_ptr<net::StreamSocket> transport)
     : WrappedStreamSocket(transport.Pass()),
       read_buffer_(new net::GrowableIOBuffer()),
       buffer_size_(0) {
 }
 
 void ReadBufferingStreamSocket::SetBufferSize(int size) {
-  DCHECK(!user_read_buf_);
+  DCHECK(!user_read_buf_.get());
   buffer_size_ = size;
   read_buffer_->SetCapacity(size);
 }
 
 int ReadBufferingStreamSocket::Read(net::IOBuffer* buf,
                                     int buf_len,
                                     const net::CompletionCallback& callback) {
   if (buffer_size_ == 0)
     return transport_->Read(buf, buf_len, callback);
 
@@ skipping 27 matching lines @@
         NOTREACHED() << "Unexpected state: " << current_state;
         rv = net::ERR_UNEXPECTED;
         break;
     }
   } while (rv != net::ERR_IO_PENDING && state_ != STATE_NONE);
   return rv;
 }
 
 int ReadBufferingStreamSocket::DoRead() {
   state_ = STATE_READ_COMPLETE;
-  int rv = transport_->Read(
-      read_buffer_,
-      read_buffer_->RemainingCapacity(),
-      base::Bind(&ReadBufferingStreamSocket::OnReadCompleted,
-                 base::Unretained(this)));
+  int rv =
+      transport_->Read(read_buffer_.get(),
+                       read_buffer_->RemainingCapacity(),
+                       base::Bind(&ReadBufferingStreamSocket::OnReadCompleted,
+                                  base::Unretained(this)));
   return rv;
 }
 
 int ReadBufferingStreamSocket::DoReadComplete(int result) {
   state_ = STATE_NONE;
   if (result <= 0)
     return result;
 
   read_buffer_->set_offset(read_buffer_->offset() + result);
   if (read_buffer_->RemainingCapacity() > 0) {
@@ skipping 600 matching lines @@
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(net::OK, rv);
   EXPECT_TRUE(sock->IsConnected());
 
   const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
   scoped_refptr<net::IOBuffer> request_buffer(
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
-  rv = sock->Write(request_buffer, arraysize(request_text) - 1,
-                   callback.callback());
+  rv = sock->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(static_cast<int>(arraysize(request_text) - 1), rv);
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(4096));
   for (;;) {
-    rv = sock->Read(buf, 4096, callback.callback());
+    rv = sock->Read(buf.get(), 4096, callback.callback());
     EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
 
     EXPECT_GE(rv, 0);
     if (rv <= 0)
       break;
   }
 }
@@ skipping 31 matching lines @@
   EXPECT_EQ(net::OK, rv);
   EXPECT_TRUE(sock->IsConnected());
 
   const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
   static const int kRequestTextSize =
       static_cast<int>(arraysize(request_text) - 1);
   scoped_refptr<net::IOBuffer> request_buffer(
       new net::IOBuffer(kRequestTextSize));
   memcpy(request_buffer->data(), request_text, kRequestTextSize);
 
-  rv = callback.GetResult(sock->Write(request_buffer, kRequestTextSize,
-                                      callback.callback()));
+  rv = callback.GetResult(
+      sock->Write(request_buffer.get(), kRequestTextSize, callback.callback()));
   EXPECT_EQ(kRequestTextSize, rv);
 
   // Simulate an unclean/forcible shutdown.
   transport->SetNextReadError(net::ERR_CONNECTION_RESET);
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(4096));
 
   // Note: This test will hang if this bug has regressed. Simply checking that
   // rv != ERR_IO_PENDING is insufficient, as ERR_IO_PENDING is a legitimate
   // result when using a dedicated task runner for NSS.
-  rv = callback.GetResult(sock->Read(buf, 4096, callback.callback()));
+  rv = callback.GetResult(sock->Read(buf.get(), 4096, callback.callback()));
 
 #if !defined(USE_OPENSSL)
   // NSS records the error exactly
   EXPECT_EQ(net::ERR_CONNECTION_RESET, rv);
 #else
   // OpenSSL treats any errors as a simple EOF.
   EXPECT_EQ(0, rv);
 #endif
 }
 
@@ skipping 22 matching lines @@
                             kDefaultSSLConfig));
 
   rv = sock->Connect(callback.callback());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(net::OK, rv);
   EXPECT_TRUE(sock->IsConnected());
 
   // Issue a "hanging" Read first.
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(4096));
-  rv = sock->Read(buf, 4096, callback.callback());
+  rv = sock->Read(buf.get(), 4096, callback.callback());
   // We haven't written the request, so there should be no response yet.
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
 
   // Write the request.
   // The request is padded with a User-Agent header to a size that causes the
   // memio circular buffer (4k bytes) in SSLClientSocketNSS to wrap around.
   // This tests the fix for http://crbug.com/29815.
   std::string request_text = "GET / HTTP/1.1\r\nUser-Agent: long browser name ";
   for (int i = 0; i < 3770; ++i)
     request_text.push_back('*');
   request_text.append("\r\n\r\n");
   scoped_refptr<net::IOBuffer> request_buffer(
       new net::StringIOBuffer(request_text));
 
   net::TestCompletionCallback callback2;  // Used for Write only.
-  rv = sock->Write(request_buffer, request_text.size(), callback2.callback());
+  rv = sock->Write(
+      request_buffer.get(), request_text.size(), callback2.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
     rv = callback2.WaitForResult();
   EXPECT_EQ(static_cast<int>(request_text.size()), rv);
 
   // Now get the Read result.
   rv = callback.WaitForResult();
   EXPECT_GT(rv, 0);
 }
@@ skipping 50 matching lines @@
   error_socket->SetNextWriteError(net::ERR_CONNECTION_RESET);
   // ... but have those errors returned asynchronously. Because the Write() will
   // return first, this will trigger the error.
   transport->SetNextReadShouldBlock();
   transport->SetNextWriteShouldBlock();
 
   // Enqueue a Read() before calling Write(), which should "hang" due to
   // the ERR_IO_PENDING caused by SetReadShouldBlock() and thus return.
   DeleteSocketCallback read_callback(sock);
   scoped_refptr<net::IOBuffer> read_buf(new net::IOBuffer(4096));
-  rv = sock->Read(read_buf, 4096, read_callback.callback());
+  rv = sock->Read(read_buf.get(), 4096, read_callback.callback());
 
   // Ensure things didn't complete synchronously, otherwise |sock| is invalid.
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
   ASSERT_FALSE(read_callback.have_result());
 
 #if !defined(USE_OPENSSL)
   // NSS follows a pattern where a call to PR_Write will only consume as
   // much data as it can encode into application data records before the
   // internal memio buffer is full, which should only fill if writing a large
   // amount of data and the underlying transport is blocked. Once this happens,
   // NSS will return (total size of all application data records it wrote) - 1,
   // with the caller expected to resume with the remaining unsent data.
   //
   // This causes SSLClientSocketNSS::Write to return that it wrote some data
   // before it will return ERR_IO_PENDING, so make an extra call to Write() to
   // get the socket in the state needed for the test below.
   //
   // This is not needed for OpenSSL, because for OpenSSL,
   // SSL_MODE_ENABLE_PARTIAL_WRITE is not specified - thus
   // SSLClientSocketOpenSSL::Write() will not return until all of
   // |request_buffer| has been written to the underlying BIO (although not
   // necessarily the underlying transport).
-  rv = callback.GetResult(sock->Write(request_buffer,
+  rv = callback.GetResult(sock->Write(request_buffer.get(),
                                       request_buffer->BytesRemaining(),
                                       callback.callback()));
   ASSERT_LT(0, rv);
   request_buffer->DidConsume(rv);
 
   // Guard to ensure that |request_buffer| was larger than all of the internal
   // buffers (transport, memio, NSS) along the way - otherwise the next call
   // to Write() will crash with an invalid buffer.
   ASSERT_LT(0, request_buffer->BytesRemaining());
 #endif
 
   // Attempt to write the remaining data. NSS will not be able to consume the
   // application data because the internal buffers are full, while OpenSSL will
   // return that its blocked because the underlying transport is blocked.
-  rv = sock->Write(request_buffer, request_buffer->BytesRemaining(),
+  rv = sock->Write(request_buffer.get(),
+                   request_buffer->BytesRemaining(),
                    callback.callback());
   ASSERT_EQ(net::ERR_IO_PENDING, rv);
   ASSERT_FALSE(callback.have_result());
 
   // Now unblock Write(), which will invoke OnSendComplete and (eventually)
   // call the Read() callback, deleting the socket and thus aborting calling
   // the Write() callback.
   transport->UnblockWrite();
 
   rv = read_callback.WaitForResult();
@@ skipping 34 matching lines @@
   rv = sock->Connect(callback.callback());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
   const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
   scoped_refptr<net::IOBuffer> request_buffer(
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
-  rv = sock->Write(request_buffer, arraysize(request_text) - 1,
-                   callback.callback());
+  rv = sock->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(static_cast<int>(arraysize(request_text) - 1), rv);
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(1));
   for (;;) {
-    rv = sock->Read(buf, 1, callback.callback());
+    rv = sock->Read(buf.get(), 1, callback.callback());
     EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
 
     EXPECT_GE(rv, 0);
     if (rv <= 0)
       break;
   }
 }
@@ skipping 23 matching lines @@
   rv = callback.GetResult(sock->Connect(callback.callback()));
   ASSERT_EQ(net::OK, rv);
   ASSERT_TRUE(sock->IsConnected());
 
   const char request_text[] = "GET /ssl-many-small-records HTTP/1.0\r\n\r\n";
   scoped_refptr<net::IOBuffer> request_buffer(
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
   rv = callback.GetResult(sock->Write(
-      request_buffer, arraysize(request_text) - 1, callback.callback()));
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback()));
   ASSERT_GT(rv, 0);
   ASSERT_EQ(static_cast<int>(arraysize(request_text) - 1), rv);
 
   // Note: This relies on SSLClientSocketNSS attempting to read up to 17K of
   // data (the max SSL record size) at a time. Ensure that at least 15K worth
   // of SSL data is buffered first. The 15K of buffered data is made up of
   // many smaller SSL records (the TestServer writes along 1350 byte
   // plaintext boundaries), although there may also be a few records that are
   // smaller or larger, due to timing and SSL False Start.
   // 15K was chosen because 15K is smaller than the 17K (max) read issued by
   // the SSLClientSocket implementation, and larger than the minimum amount
   // of ciphertext necessary to contain the 8K of plaintext requested below.
   transport->SetBufferSize(15000);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(8192));
-  rv = callback.GetResult(sock->Read(buffer, 8192, callback.callback()));
+  rv = callback.GetResult(sock->Read(buffer.get(), 8192, callback.callback()));
   ASSERT_EQ(rv, 8192);
 }
 
 TEST_F(SSLClientSocketTest, Read_Interrupted) {
   net::SpawnedTestServer test_server(net::SpawnedTestServer::TYPE_HTTPS,
                                      net::SpawnedTestServer::kLocalhost,
                                      base::FilePath());
   ASSERT_TRUE(test_server.Start());
 
   net::AddressList addr;
@@ skipping 14 matching lines @@
   rv = sock->Connect(callback.callback());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
   const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
   scoped_refptr<net::IOBuffer> request_buffer(
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
-  rv = sock->Write(request_buffer, arraysize(request_text) - 1,
-                   callback.callback());
+  rv = sock->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(static_cast<int>(arraysize(request_text) - 1), rv);
 
   // Do a partial read and then exit.  This test should not crash!
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(512));
-  rv = sock->Read(buf, 512, callback.callback());
+  rv = sock->Read(buf.get(), 512, callback.callback());
   EXPECT_TRUE(rv > 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
 
   EXPECT_GT(rv, 0);
 }
 
 TEST_F(SSLClientSocketTest, Read_FullLogging) {
   net::SpawnedTestServer test_server(net::SpawnedTestServer::TYPE_HTTPS,
@@ skipping 22 matching lines @@
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(net::OK, rv);
   EXPECT_TRUE(sock->IsConnected());
 
   const char request_text[] = "GET / HTTP/1.0\r\n\r\n";
   scoped_refptr<net::IOBuffer> request_buffer(
       new net::IOBuffer(arraysize(request_text) - 1));
   memcpy(request_buffer->data(), request_text, arraysize(request_text) - 1);
 
-  rv = sock->Write(request_buffer, arraysize(request_text) - 1,
-                   callback.callback());
+  rv = sock->Write(
+      request_buffer.get(), arraysize(request_text) - 1, callback.callback());
   EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   EXPECT_EQ(static_cast<int>(arraysize(request_text) - 1), rv);
 
   net::CapturingNetLog::CapturedEntryList entries;
   log.GetEntries(&entries);
   size_t last_index = net::ExpectLogContainsSomewhereAfter(
       entries, 5, net::NetLog::TYPE_SSL_SOCKET_BYTES_SENT,
       net::NetLog::PHASE_NONE);
 
   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(4096));
   for (;;) {
-    rv = sock->Read(buf, 4096, callback.callback());
+    rv = sock->Read(buf.get(), 4096, callback.callback());
     EXPECT_TRUE(rv >= 0 || rv == net::ERR_IO_PENDING);
 
     if (rv == net::ERR_IO_PENDING)
       rv = callback.WaitForResult();
 
     EXPECT_GE(rv, 0);
     if (rv <= 0)
       break;
 
     log.GetEntries(&entries);
@@ skipping 250 matching lines @@
   temp_intermediates.push_back(certs[1]->os_cert_handle());
   temp_intermediates.push_back(certs[2]->os_cert_handle());
 
   net::CertVerifyResult verify_result;
   verify_result.verified_cert =
       net::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], verify_result, net::OK);
+  cert_verifier_->AddResultForCert(certs[0].get(), verify_result, net::OK);
 
   // Load and install the root for the validated chain.
   scoped_refptr<net::X509Certificate> root_cert =
     net::ImportCertFromFile(net::GetTestCertsDirectory(),
                            "redundant-validated-chain-root.pem");
   ASSERT_NE(static_cast<net::X509Certificate*>(NULL), root_cert);
-  net::ScopedTestRoot scoped_root(root_cert);
+  net::ScopedTestRoot scoped_root(root_cert.get());
 
   // Set up a test server with CERT_CHAIN_WRONG_ROOT.
   net::SpawnedTestServer::SSLOptions ssl_options(
       net::SpawnedTestServer::SSLOptions::CERT_CHAIN_WRONG_ROOT);
   net::SpawnedTestServer test_server(
       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   net::AddressList addr;
@@ skipping 87 matching lines @@
 
     return request_info;
   }
 };
 
 TEST_F(SSLClientSocketCertRequestInfoTest, NoAuthorities) {
   net::SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
   scoped_refptr<net::SSLCertRequestInfo> request_info =
       GetCertRequest(ssl_options);
-  ASSERT_TRUE(request_info);
+  ASSERT_TRUE(request_info.get());
   EXPECT_EQ(0u, request_info->cert_authorities.size());
 }
 
 TEST_F(SSLClientSocketCertRequestInfoTest, TwoAuthorities) {
   const base::FilePath::CharType kThawteFile[] =
       FILE_PATH_LITERAL("thawte.single.pem");
   const unsigned char kThawteDN[] = {
     0x30, 0x4c, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13,
     0x02, 0x5a, 0x41, 0x31, 0x25, 0x30, 0x23, 0x06, 0x03, 0x55, 0x04, 0x0a,
     0x13, 0x1c, 0x54, 0x68, 0x61, 0x77, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x6e,
@@ skipping 20 matching lines @@
   const size_t kDiginotarLen = sizeof(kDiginotarDN);
 
   net::SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
   ssl_options.client_authorities.push_back(
       net::GetTestClientCertsDirectory().Append(kThawteFile));
   ssl_options.client_authorities.push_back(
       net::GetTestClientCertsDirectory().Append(kDiginotarFile));
   scoped_refptr<net::SSLCertRequestInfo> request_info =
       GetCertRequest(ssl_options);
-  ASSERT_TRUE(request_info);
+  ASSERT_TRUE(request_info.get());
   ASSERT_EQ(2u, request_info->cert_authorities.size());
   EXPECT_EQ(std::string(reinterpret_cast<const char*>(kThawteDN), kThawteLen),
             request_info->cert_authorities[0]);
   EXPECT_EQ(
       std::string(reinterpret_cast<const char*>(kDiginotarDN), kDiginotarLen),
       request_info->cert_authorities[1]);
 }