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

net/socket_stream/socket_stream.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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <set>
@@ skipping 200 matching lines @@
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
   DCHECK_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type())
       << "The current base::MessageLoop must be TYPE_IO";
   DCHECK_GT(len, 0);
 
   if (!socket_.get() || !socket_->IsConnected() || next_state_ == STATE_NONE)
     return false;
 
   int total_buffered_bytes = len;
-  if (current_write_buf_) {
+  if (current_write_buf_.get()) {
     // Since
     // - the purpose of this check is to limit the amount of buffer used by
     //   this instance.
     // - the DrainableIOBuffer doesn't release consumed memory.
     // we need to use not BytesRemaining() but size() here.
     total_buffered_bytes += current_write_buf_->size();
   }
   total_buffered_bytes += GetTotalSizeOfPendingWriteBufs();
   if (total_buffered_bytes > max_pending_send_allowed_)
     return false;
 
   // TODO(tyoshino): Split data into smaller chunks e.g. 8KiB to free consumed
   // buffer progressively
   pending_write_bufs_.push_back(make_scoped_refptr(
       new IOBufferWithSize(len)));
   memcpy(pending_write_bufs_.back()->data(), data, len);
 
   // If current_write_buf_ is not NULL, it means that a) there's ongoing write
   // operation or b) the connection is being closed. If a), the buffer we just
   // pushed will be automatically handled when the completion callback runs
   // the loop, and therefore we don't need to enqueue DoLoop(). If b), it's ok
   // to do nothing. If current_write_buf_ is NULL, to make sure DoLoop() is
   // ran soon, enequeue it.
-  if (!current_write_buf_) {
+  if (!current_write_buf_.get()) {
     // Send pending data asynchronously, so that delegate won't be called
     // back before returning from SendData().
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&SocketStream::DoLoop, this, OK));
   }
 
   return true;
 }
 
 void SocketStream::Close() {
@@ skipping 85 matching lines @@
   // waiting for restarting.  In these states, we'll close the SocketStream
   // now.
   if (next_state_ == STATE_TCP_CONNECT || next_state_ == STATE_AUTH_REQUIRED) {
     DoLoop(ERR_ABORTED);
     return;
   }
   // If next_state_ is STATE_READ_WRITE, we'll run DoLoop and close
   // the SocketStream.
   // If it's writing now, we should defer the closing after the current
   // writing is completed.
-  if (next_state_ == STATE_READ_WRITE && !current_write_buf_)
+  if (next_state_ == STATE_READ_WRITE && !current_write_buf_.get())
     DoLoop(ERR_ABORTED);
 
   // In other next_state_, we'll wait for callback of other APIs, such as
   // ResolveProxy().
 }
 
 void SocketStream::Finish(int result) {
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
   DCHECK_EQ(base::MessageLoop::TYPE_IO, base::MessageLoop::current()->type())
@@ skipping 24 matching lines @@
   metrics_->OnConnected();
 
   net_log_.EndEvent(NetLog::TYPE_SOCKET_STREAM_CONNECT);
   if (delegate_)
     delegate_->OnConnected(this, max_pending_send_allowed_);
 
   return OK;
 }
 
 int SocketStream::DidReceiveData(int result) {
-  DCHECK(read_buf_);
+  DCHECK(read_buf_.get());
   DCHECK_GT(result, 0);
   net_log_.AddEvent(NetLog::TYPE_SOCKET_STREAM_RECEIVED);
   int len = result;
   metrics_->OnRead(len);
   if (delegate_) {
     // Notify recevied data to delegate.
     delegate_->OnReceivedData(this, read_buf_->data(), len);
   }
   read_buf_ = NULL;
   return OK;
 }
 
 void SocketStream::DidSendData(int result) {
   DCHECK_GT(result, 0);
-  DCHECK(current_write_buf_);
+  DCHECK(current_write_buf_.get());
   net_log_.AddEvent(NetLog::TYPE_SOCKET_STREAM_SENT);
 
   int bytes_sent = result;
 
   metrics_->OnWrite(bytes_sent);
 
   current_write_buf_->DidConsume(result);
 
   if (current_write_buf_->BytesRemaining())
     return;
@@ skipping 11 matching lines @@
 
 void SocketStream::OnIOCompleted(int result) {
   DoLoop(result);
 }
 
 void SocketStream::OnReadCompleted(int result) {
   if (result == 0) {
     // 0 indicates end-of-file, so socket was closed.
     // Don't close the socket if it's still writing.
     server_closed_ = true;
-  } else if (result > 0 && read_buf_) {
+  } else if (result > 0 && read_buf_.get()) {
     result = DidReceiveData(result);
   }
   DoLoop(result);
 }
 
 void SocketStream::OnWriteCompleted(int result) {
   waiting_for_write_completion_ = false;
   if (result > 0) {
     DidSendData(result);
     result = OK;
@@ skipping 360 matching lines @@
     tunnel_request_headers_->headers_ = base::StringPrintf(
         "CONNECT %s HTTP/1.1\r\n"
         "%s",
         GetHostAndPort(url_).c_str(),
         request_headers.ToString().c_str());
   }
   tunnel_request_headers_->SetDataOffset(tunnel_request_headers_bytes_sent_);
   int buf_len = static_cast<int>(tunnel_request_headers_->headers_.size() -
                                  tunnel_request_headers_bytes_sent_);
   DCHECK_GT(buf_len, 0);
-  return socket_->Write(tunnel_request_headers_, buf_len, io_callback_);
+  return socket_->Write(tunnel_request_headers_.get(), buf_len, io_callback_);
 }
 
 int SocketStream::DoWriteTunnelHeadersComplete(int result) {
   DCHECK_EQ(kTunnelProxy, proxy_mode_);
 
   if (result < 0) {
     next_state_ = STATE_CLOSE;
     return result;
   }
 
@@ skipping 22 matching lines @@
     tunnel_response_headers_capacity_ = kMaxTunnelResponseHeadersSize;
     tunnel_response_headers_->Realloc(tunnel_response_headers_capacity_);
     tunnel_response_headers_len_ = 0;
   }
 
   int buf_len = tunnel_response_headers_capacity_ -
       tunnel_response_headers_len_;
   tunnel_response_headers_->SetDataOffset(tunnel_response_headers_len_);
   CHECK(tunnel_response_headers_->data());
 
-  return socket_->Read(tunnel_response_headers_, buf_len, io_callback_);
+  return socket_->Read(tunnel_response_headers_.get(), buf_len, io_callback_);
 }
 
 int SocketStream::DoReadTunnelHeadersComplete(int result) {
   DCHECK_EQ(kTunnelProxy, proxy_mode_);
 
   if (result < 0) {
     next_state_ = STATE_CLOSE;
     return result;
   }
 
@@ skipping 219 matching lines @@
     return result;
   }
   if (!socket_.get() || !socket_->IsConnected()) {
     next_state_ = STATE_CLOSE;
     return ERR_CONNECTION_CLOSED;
   }
 
   // If client has requested close(), and there's nothing to write, then
   // let's close the socket.
   // We don't care about receiving data after the socket is closed.
-  if (closing_ && !current_write_buf_ && pending_write_bufs_.empty()) {
+  if (closing_ && !current_write_buf_.get() && pending_write_bufs_.empty()) {
     socket_->Disconnect();
     next_state_ = STATE_CLOSE;
     return OK;
   }
 
   next_state_ = STATE_READ_WRITE;
 
   // If server already closed the socket, we don't try to read.
   if (!server_closed_) {
-    if (!read_buf_) {
+    if (!read_buf_.get()) {
       // No read pending and server didn't close the socket.
       read_buf_ = new IOBuffer(kReadBufferSize);
-      result = socket_->Read(read_buf_, kReadBufferSize,
-                             base::Bind(&SocketStream::OnReadCompleted,
-                                        base::Unretained(this)));
+      result = socket_->Read(
+          read_buf_.get(),
+          kReadBufferSize,
+          base::Bind(&SocketStream::OnReadCompleted, base::Unretained(this)));
       if (result > 0) {
         return DidReceiveData(result);
       } else if (result == 0) {
         // 0 indicates end-of-file, so socket was closed.
         next_state_ = STATE_CLOSE;
         server_closed_ = true;
         return ERR_CONNECTION_CLOSED;
       }
       // If read is pending, try write as well.
       // Otherwise, return the result and do next loop (to close the
       // connection).
       if (result != ERR_IO_PENDING) {
         next_state_ = STATE_CLOSE;
         server_closed_ = true;
         return result;
       }
     }
     // Read is pending.
-    DCHECK(read_buf_);
+    DCHECK(read_buf_.get());
   }
 
   if (waiting_for_write_completion_)
     return ERR_IO_PENDING;
 
-  if (!current_write_buf_) {
+  if (!current_write_buf_.get()) {
     if (pending_write_bufs_.empty()) {
       // Nothing buffered for send.
       return ERR_IO_PENDING;
     }
 
-    current_write_buf_ =
-        new DrainableIOBuffer(pending_write_bufs_.front(),
-                              pending_write_bufs_.front()->size());
+    current_write_buf_ = new DrainableIOBuffer(
+        pending_write_bufs_.front().get(), pending_write_bufs_.front()->size());
     pending_write_bufs_.pop_front();
   }
 
-  result = socket_->Write(current_write_buf_,
-                          current_write_buf_->BytesRemaining(),
-                          base::Bind(&SocketStream::OnWriteCompleted,
-                                     base::Unretained(this)));
+  result = socket_->Write(
+      current_write_buf_.get(),
+      current_write_buf_->BytesRemaining(),
+      base::Bind(&SocketStream::OnWriteCompleted, base::Unretained(this)));
 
   if (result == ERR_IO_PENDING) {
     waiting_for_write_completion_ = true;
   } else if (result < 0) {
     // Shortcut. Enter STATE_CLOSE now by changing next_state_ here than by
     // calling DoReadWrite() again with the error code.
     next_state_ = STATE_CLOSE;
   } else if (result > 0) {
     // Write is not pending. Return OK and do next loop.
     DidSendData(result);
@@ skipping 12 matching lines @@
 int SocketStream::HandleCertificateRequest(int result, SSLConfig* ssl_config) {
   if (ssl_config->send_client_cert) {
     // We already have performed SSL client authentication once and failed.
     return result;
   }
 
   DCHECK(socket_.get());
   scoped_refptr<SSLCertRequestInfo> cert_request_info = new SSLCertRequestInfo;
   SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(socket_.get());
-  ssl_socket->GetSSLCertRequestInfo(cert_request_info);
+  ssl_socket->GetSSLCertRequestInfo(cert_request_info.get());
 
   HttpTransactionFactory* factory = context_->http_transaction_factory();
   if (!factory)
     return result;
   scoped_refptr<HttpNetworkSession> session = factory->GetSession();
   if (!session.get())
     return result;
 
   // If the user selected one of the certificates in client_certs or declined
   // to provide one for this server before, use the past decision
   // automatically.
   scoped_refptr<X509Certificate> client_cert;
   if (!session->ssl_client_auth_cache()->Lookup(
           cert_request_info->host_and_port, &client_cert)) {
     return result;
   }
 
   // Note: |client_cert| may be NULL, indicating that the caller
   // wishes to proceed anonymously (eg: continue the handshake
   // without sending a client cert)
   //
   // Check that the certificate selected is still a certificate the server
   // is likely to accept, based on the criteria supplied in the
   // CertificateRequest message.
   const std::vector<std::string>& cert_authorities =
       cert_request_info->cert_authorities;
-  if (client_cert && !cert_authorities.empty() &&
+  if (client_cert.get() && !cert_authorities.empty() &&
       !client_cert->IsIssuedByEncoded(cert_authorities)) {
     return result;
   }
 
   ssl_config->send_client_cert = true;
   ssl_config->client_cert = client_cert;
   next_state_ = STATE_TCP_CONNECT;
   return OK;
 }
 
 int SocketStream::AllowCertErrorForReconnection(SSLConfig* ssl_config) {
   DCHECK(ssl_config);
   // The SSL handshake didn't finish, or the server closed the SSL connection.
   // So, we should restart establishing connection with the certificate in
   // allowed bad certificates in |ssl_config|.
   // See also net/http/http_network_transaction.cc HandleCertificateError() and
   // RestartIgnoringLastError().
   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(socket_.get());
   SSLInfo ssl_info;
   ssl_socket->GetSSLInfo(&ssl_info);
-  if (ssl_info.cert == NULL ||
-      ssl_config->IsAllowedBadCert(ssl_info.cert, NULL)) {
+  if (ssl_info.cert.get() == NULL ||
+      ssl_config->IsAllowedBadCert(ssl_info.cert.get(), NULL)) {
     // If we already have the certificate in the set of allowed bad
     // certificates, we did try it and failed again, so we should not
     // retry again: the connection should fail at last.
     next_state_ = STATE_CLOSE;
     return ERR_UNEXPECTED;
   }
   // Add the bad certificate to the set of allowed certificates in the
   // SSL config object.
   SSLConfig::CertAndStatus bad_cert;
   if (!X509Certificate::GetDEREncoded(ssl_info.cert->os_cert_handle(),
@@ skipping 61 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net