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

extensions/browser/api/sockets_tcp_server/sockets_tcp_server_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_server/sockets_tcp_server_api.h"
 
 #include "content/public/common/socket_permission_request.h"
 #include "extensions/browser/api/socket/tcp_socket.h"
 #include "extensions/browser/api/sockets_tcp_server/tcp_server_socket_event_dispatcher.h"
 #include "extensions/common/api/sockets/sockets_manifest_data.h"
@@ skipping 30 matching lines @@
         new std::string(localAddress.ToStringWithoutPort()));
     socket_info.local_port.reset(new int(localAddress.port()));
   }
 
   return socket_info;
 }
 
 void SetSocketProperties(ResumableTCPServerSocket* 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);
   }
 }
 
 }  // namespace
 
 namespace extensions {
 namespace api {
 
 TCPServerSocketAsyncApiFunction::~TCPServerSocketAsyncApiFunction() {}
 
@@ skipping 15 matching lines @@
 bool SocketsTcpServerCreateFunction::Prepare() {
   params_ = sockets_tcp_server::Create::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsTcpServerCreateFunction::Work() {
   ResumableTCPServerSocket* socket =
       new ResumableTCPServerSocket(extension_->id());
 
-  sockets_tcp_server::SocketProperties* properties =
-      params_.get()->properties.get();
+  sockets_tcp_server::SocketProperties* properties = params_->properties.get();
   if (properties) {
     SetSocketProperties(socket, properties);
   }
 
   sockets_tcp_server::CreateInfo create_info;
   create_info.socket_id = AddSocket(socket);
   results_ = sockets_tcp_server::Create::Results::Create(create_info);
 }
 
 SocketsTcpServerUpdateFunction::SocketsTcpServerUpdateFunction() {}
 
 SocketsTcpServerUpdateFunction::~SocketsTcpServerUpdateFunction() {}
 
 bool SocketsTcpServerUpdateFunction::Prepare() {
   params_ = sockets_tcp_server::Update::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsTcpServerUpdateFunction::Work() {
   ResumableTCPServerSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
-  SetSocketProperties(socket, &params_.get()->properties);
+  SetSocketProperties(socket, &params_->properties);
   results_ = sockets_tcp_server::Update::Results::Create();
 }
 
 SocketsTcpServerSetPausedFunction::SocketsTcpServerSetPausedFunction()
     : socket_event_dispatcher_(NULL) {}
 
 SocketsTcpServerSetPausedFunction::~SocketsTcpServerSetPausedFunction() {}
 
 bool SocketsTcpServerSetPausedFunction::Prepare() {
   params_ = api::sockets_tcp_server::SetPaused::Params::Create(*args_);
@@ skipping 56 matching lines @@
 
   SocketPermissionRequest param(
       SocketPermissionRequest::TCP_LISTEN, params_->address, params_->port);
   if (!SocketsManifestData::CheckRequest(extension(), param)) {
     error_ = kPermissionError;
     AsyncWorkCompleted();
     return;
   }
 
   int net_result = socket->Listen(
-      params_->address,
-      params_->port,
-      params_->backlog.get() ? *params_->backlog.get() : kDefaultListenBacklog,
+      params_->address, params_->port,
+      params_->backlog.get() ? *params_->backlog : kDefaultListenBacklog,
       &error_);
   results_ = sockets_tcp_server::Listen::Results::Create(net_result);
   if (net_result == net::OK) {
     socket_event_dispatcher_->OnServerSocketListen(extension_->id(),
                                                    params_->socket_id);
   } else {
     error_ = net::ErrorToString(net_result);
     AsyncWorkCompleted();
     return;
   }
@@ skipping 80 matching lines @@
       if (socket) {
         socket_infos.push_back(CreateSocketInfo(socket_id, socket));
       }
     }
   }
   results_ = sockets_tcp_server::GetSockets::Results::Create(socket_infos);
 }
 
 }  // namespace api
 }  // namespace extensions