[Extensions] Code Cleanup - Remove redundant smart-ptr get()s

extensions/browser/api/sockets_tcp/sockets_tcp_api.cc

 // Copyright 2014 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 "extensions/browser/api/sockets_tcp/sockets_tcp_api.h"
 
 #include "base/memory/ptr_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/socket_permission_request.h"
@@ skipping 50 matching lines @@
         new std::string(peerAddress.ToStringWithoutPort()));
     socket_info.peer_port.reset(new int(peerAddress.port()));
   }
 
   return socket_info;
 }
 
 void SetSocketProperties(ResumableTCPSocket* socket,
                          SocketProperties* properties) {
   if (properties->name.get()) {
-    socket->set_name(*properties->name.get());
+    socket->set_name(*properties->name);
   }
   if (properties->persistent.get()) {
-    socket->set_persistent(*properties->persistent.get());
+    socket->set_persistent(*properties->persistent);
   }
   if (properties->buffer_size.get()) {
     // buffer size is validated when issuing the actual Recv operation
     // on the socket.
-    socket->set_buffer_size(*properties->buffer_size.get());
+    socket->set_buffer_size(*properties->buffer_size);
   }
 }
 
 }  // namespace
 
 namespace extensions {
 namespace api {
 
 using content::SocketPermissionRequest;
 
@@ skipping 29 matching lines @@
 
 bool SocketsTcpCreateFunction::Prepare() {
   params_ = sockets_tcp::Create::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsTcpCreateFunction::Work() {
   ResumableTCPSocket* socket = new ResumableTCPSocket(extension_->id());
 
-  sockets_tcp::SocketProperties* properties = params_.get()->properties.get();
+  sockets_tcp::SocketProperties* properties = params_->properties.get();
   if (properties) {
     SetSocketProperties(socket, properties);
   }
 
   sockets_tcp::CreateInfo create_info;
   create_info.socket_id = AddSocket(socket);
   results_ = sockets_tcp::Create::Results::Create(create_info);
 }
 
 SocketsTcpUpdateFunction::SocketsTcpUpdateFunction() {}
 
 SocketsTcpUpdateFunction::~SocketsTcpUpdateFunction() {}
 
 bool SocketsTcpUpdateFunction::Prepare() {
   params_ = sockets_tcp::Update::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsTcpUpdateFunction::Work() {
   ResumableTCPSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
-  SetSocketProperties(socket, &params_.get()->properties);
+  SetSocketProperties(socket, &params_->properties);
   results_ = sockets_tcp::Update::Results::Create();
 }
 
 SocketsTcpSetPausedFunction::SocketsTcpSetPausedFunction()
     : socket_event_dispatcher_(NULL) {}
 
 SocketsTcpSetPausedFunction::~SocketsTcpSetPausedFunction() {}
 
 bool SocketsTcpSetPausedFunction::Prepare() {
   params_ = api::sockets_tcp::SetPaused::Params::Create(*args_);
@@ skipping 36 matching lines @@
   return true;
 }
 
 void SocketsTcpSetKeepAliveFunction::Work() {
   ResumableTCPSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
-  int delay = params_->delay ? *params_->delay.get() : 0;
+  int delay = params_->delay ? *params_->delay : 0;
 
   bool success = socket->SetKeepAlive(params_->enable, delay);
   int net_result = (success ? net::OK : net::ERR_FAILED);
   if (net_result != net::OK)
     error_ = net::ErrorToString(net_result);
   results_ = sockets_tcp::SetKeepAlive::Results::Create(net_result);
 }
 
 SocketsTcpSetNoDelayFunction::SocketsTcpSetNoDelayFunction() {}
 
@@ skipping 277 matching lines @@
   net::URLRequestContext* url_request_context =
       url_request_getter_->GetURLRequestContext();
 
   // UpgradeSocketToTLS() uses the older API's SecureOptions. Copy over the
   // only values inside -- TLSVersionConstraints's |min| and |max|,
   api::socket::SecureOptions legacy_params;
   if (params_->options.get() && params_->options->tls_version.get()) {
     legacy_params.tls_version.reset(new api::socket::TLSVersionConstraints);
     if (params_->options->tls_version->min.get()) {
       legacy_params.tls_version->min.reset(
-          new std::string(*params_->options->tls_version->min.get()));
+          new std::string(*params_->options->tls_version->min));
     }
     if (params_->options->tls_version->max.get()) {
       legacy_params.tls_version->max.reset(
-          new std::string(*params_->options->tls_version->max.get()));
+          new std::string(*params_->options->tls_version->max));
     }
   }
 
   TLSSocket::UpgradeSocketToTLS(
       socket, url_request_context->ssl_config_service(),
       url_request_context->cert_verifier(),
       url_request_context->transport_security_state(),
       url_request_context->cert_transparency_verifier(),
       url_request_context->ct_policy_enforcer(), extension_id(), &legacy_params,
       base::Bind(&SocketsTcpSecureFunction::TlsConnectDone, this));
@@ skipping 12 matching lines @@
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = api::sockets_tcp::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace api
 }  // namespace extensions