[Extensions] Convert APIs to use movable types [13]

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 "content/public/browser/browser_context.h"
 #include "content/public/common/socket_permission_request.h"
 #include "extensions/browser/api/socket/tcp_socket.h"
 #include "extensions/browser/api/socket/tls_socket.h"
 #include "extensions/browser/api/sockets_tcp/tcp_socket_event_dispatcher.h"
 #include "extensions/common/api/sockets/sockets_manifest_data.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using extensions::ResumableTCPSocket;
 using extensions::api::sockets_tcp::SocketInfo;
 using extensions::api::sockets_tcp::SocketProperties;
 
 namespace {
 
 const char kSocketNotFoundError[] = "Socket not found";
 const char kPermissionError[] = "Does not have permission";
 const char kInvalidSocketStateError[] =
     "Socket must be a connected client TCP socket.";
 const char kSocketNotConnectedError[] = "Socket not connected";
 
-linked_ptr<SocketInfo> CreateSocketInfo(int socket_id,
-                                        ResumableTCPSocket* socket) {
-  linked_ptr<SocketInfo> socket_info(new SocketInfo());
+SocketInfo CreateSocketInfo(int socket_id, ResumableTCPSocket* socket) {
+  SocketInfo socket_info;
   // This represents what we know about the socket, and does not call through
   // to the system.
-  socket_info->socket_id = socket_id;
+  socket_info.socket_id = socket_id;
   if (!socket->name().empty()) {
-    socket_info->name.reset(new std::string(socket->name()));
+    socket_info.name.reset(new std::string(socket->name()));
   }
-  socket_info->persistent = socket->persistent();
+  socket_info.persistent = socket->persistent();
   if (socket->buffer_size() > 0) {
-    socket_info->buffer_size.reset(new int(socket->buffer_size()));
+    socket_info.buffer_size.reset(new int(socket->buffer_size()));
   }
-  socket_info->paused = socket->paused();
-  socket_info->connected = socket->IsConnected();
+  socket_info.paused = socket->paused();
+  socket_info.connected = socket->IsConnected();
 
   // Grab the local address as known by the OS.
   net::IPEndPoint localAddress;
   if (socket->GetLocalAddress(&localAddress)) {
-    socket_info->local_address.reset(
+    socket_info.local_address.reset(
         new std::string(localAddress.ToStringWithoutPort()));
-    socket_info->local_port.reset(new int(localAddress.port()));
+    socket_info.local_port.reset(new int(localAddress.port()));
   }
 
   // Grab the peer address as known by the OS. This and the call below will
   // always succeed while the socket is connected, even if the socket has
   // been remotely closed by the peer; only reading the socket will reveal
   // that it should be closed locally.
   net::IPEndPoint peerAddress;
   if (socket->GetPeerAddress(&peerAddress)) {
-    socket_info->peer_address.reset(
+    socket_info.peer_address.reset(
         new std::string(peerAddress.ToStringWithoutPort()));
-    socket_info->peer_port.reset(new int(peerAddress.port()));
+    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());
   }
@@ skipping 342 matching lines @@
   return true;
 }
 
 void SocketsTcpGetInfoFunction::Work() {
   ResumableTCPSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
-  linked_ptr<sockets_tcp::SocketInfo> socket_info =
+  sockets_tcp::SocketInfo socket_info =
       CreateSocketInfo(params_->socket_id, socket);
-  results_ = sockets_tcp::GetInfo::Results::Create(*socket_info);
+  results_ = sockets_tcp::GetInfo::Results::Create(socket_info);
 }
 
 SocketsTcpGetSocketsFunction::SocketsTcpGetSocketsFunction() {}
 
 SocketsTcpGetSocketsFunction::~SocketsTcpGetSocketsFunction() {}
 
 bool SocketsTcpGetSocketsFunction::Prepare() { return true; }
 
 void SocketsTcpGetSocketsFunction::Work() {
-  std::vector<linked_ptr<sockets_tcp::SocketInfo> > socket_infos;
+  std::vector<sockets_tcp::SocketInfo> socket_infos;
   base::hash_set<int>* resource_ids = GetSocketIds();
   if (resource_ids != NULL) {
-    for (base::hash_set<int>::iterator it = resource_ids->begin();
-         it != resource_ids->end();
-         ++it) {
-      int socket_id = *it;
+    for (int socket_id : *resource_ids) {
       ResumableTCPSocket* socket = GetTcpSocket(socket_id);
       if (socket) {
         socket_infos.push_back(CreateSocketInfo(socket_id, socket));
       }
     }
   }
   results_ = sockets_tcp::GetSockets::Results::Create(socket_infos);
 }
 
 SocketsTcpSecureFunction::SocketsTcpSecureFunction() {
@@ skipping 84 matching lines @@
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = api::sockets_tcp::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace api
 }  // namespace extensions