Cleanup: Remove unnecessary ".get()" from scoped_ptrs<>.

content/browser/renderer_host/pepper/pepper_tcp_socket.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 "content/browser/renderer_host/pepper/pepper_tcp_socket.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 48 matching lines @@
       plugin_dispatcher_id_(plugin_dispatcher_id),
       socket_id_(socket_id),
       connection_state_(CONNECTED),
       end_of_file_reached_(false),
       socket_(socket) {
   DCHECK(manager);
 }
 
 PepperTCPSocket::~PepperTCPSocket() {
   // Make sure no further callbacks from socket_.
-  if (socket_.get())
+  if (socket_)
     socket_->Disconnect();
 }
 
 void PepperTCPSocket::Connect(const std::string& host, uint16_t port) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (connection_state_ != BEFORE_CONNECT) {
     SendConnectACKError();
     return;
   }
@@ skipping 53 matching lines @@
 
   net::ClientSocketHandle* handle = new net::ClientSocketHandle();
   handle->set_socket(socket_.release());
   net::ClientSocketFactory* factory =
       net::ClientSocketFactory::GetDefaultFactory();
   net::HostPortPair host_port_pair(server_name, server_port);
   net::SSLClientSocketContext ssl_context;
   ssl_context.cert_verifier = manager_->GetCertVerifier();
   socket_.reset(factory->CreateSSLClientSocket(
       handle, host_port_pair, manager_->ssl_config(), ssl_context));
-  if (!socket_.get()) {
+  if (!socket_) {
     LOG(WARNING) << "Failed to create an SSL client socket.";
     OnSSLHandshakeCompleted(net::ERR_UNEXPECTED);
     return;
   }
 
   int result = socket_->Connect(
       base::Bind(&PepperTCPSocket::OnSSLHandshakeCompleted,
                  base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnSSLHandshakeCompleted(result);
@@ skipping 130 matching lines @@
   return true;
 }
 
 // static
 bool PepperTCPSocket::GetCertificateFields(
     const char* der,
     uint32_t length,
     ppapi::PPB_X509Certificate_Fields* fields) {
   scoped_refptr<net::X509Certificate> cert =
       net::X509Certificate::CreateFromBytes(der, length);
-  if (!cert.get())
+  if (!cert)
     return false;
   return GetCertificateFields(*cert, fields);
 }
 
 void PepperTCPSocket::SendReadACKError() {
   manager_->Send(new PpapiMsg_PPBTCPSocket_ReadACK(
     routing_id_, plugin_dispatcher_id_, socket_id_, false, std::string()));
 }
 
 void PepperTCPSocket::SendWriteACKError() {
   manager_->Send(new PpapiMsg_PPBTCPSocket_WriteACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
 }
 
 void PepperTCPSocket::SendSSLHandshakeACK(bool succeeded) {
   ppapi::PPB_X509Certificate_Fields certificate_fields;
   if (succeeded) {
     // Our socket is guaranteed to be an SSL socket if we get here.
     net::SSLClientSocket* ssl_socket =
         static_cast<net::SSLClientSocket*>(socket_.get());
     net::SSLInfo ssl_info;
     ssl_socket->GetSSLInfo(&ssl_info);
-    if (ssl_info.cert.get())
+    if (ssl_info.cert)
       GetCertificateFields(*ssl_info.cert, &certificate_fields);
   }
   manager_->Send(new PpapiMsg_PPBTCPSocket_SSLHandshakeACK(
       routing_id_,
       plugin_dispatcher_id_,
       socket_id_,
       succeeded,
       certificate_fields));
 }
 
@@ skipping 116 matching lines @@
   DCHECK_GT(write_buffer_->BytesRemaining(), 0);
 
   int result = socket_->Write(write_buffer_, write_buffer_->BytesRemaining(),
                               base::Bind(&PepperTCPSocket::OnWriteCompleted,
                                          base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnWriteCompleted(result);
 }
 
 }  // namespace content