Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/socket/tcp_socket.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/socket/tcp_socket.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "extensions/browser/api/api_resource.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace extensions {
 
 const char kTCPSocketTypeInvalidError[] =
@@ skipping 18 matching lines @@
 // static
 template <>
 BrowserContextKeyedAPIFactory<ApiResourceManager<ResumableTCPServerSocket> >*
 ApiResourceManager<ResumableTCPServerSocket>::GetFactoryInstance() {
   return g_server_factory.Pointer();
 }
 
 TCPSocket::TCPSocket(const std::string& owner_extension_id)
     : Socket(owner_extension_id), socket_mode_(UNKNOWN) {}
 
-TCPSocket::TCPSocket(scoped_ptr<net::TCPClientSocket> tcp_client_socket,
+TCPSocket::TCPSocket(std::unique_ptr<net::TCPClientSocket> tcp_client_socket,
                      const std::string& owner_extension_id,
                      bool is_connected)
     : Socket(owner_extension_id),
       socket_(std::move(tcp_client_socket)),
       socket_mode_(CLIENT) {
   this->is_connected_ = is_connected;
 }
 
-TCPSocket::TCPSocket(scoped_ptr<net::TCPServerSocket> tcp_server_socket,
+TCPSocket::TCPSocket(std::unique_ptr<net::TCPServerSocket> tcp_server_socket,
                      const std::string& owner_extension_id)
     : Socket(owner_extension_id),
       server_socket_(std::move(tcp_server_socket)),
       socket_mode_(SERVER) {}
 
 // static
 TCPSocket* TCPSocket::CreateSocketForTesting(
-    scoped_ptr<net::TCPClientSocket> tcp_client_socket,
+    std::unique_ptr<net::TCPClientSocket> tcp_client_socket,
     const std::string& owner_extension_id,
     bool is_connected) {
   return new TCPSocket(std::move(tcp_client_socket), owner_extension_id,
                        is_connected);
 }
 
 // static
 TCPSocket* TCPSocket::CreateServerSocketForTesting(
-    scoped_ptr<net::TCPServerSocket> tcp_server_socket,
+    std::unique_ptr<net::TCPServerSocket> tcp_server_socket,
     const std::string& owner_extension_id) {
   return new TCPSocket(std::move(tcp_server_socket), owner_extension_id);
 }
 
 TCPSocket::~TCPSocket() { Disconnect(); }
 
 void TCPSocket::Connect(const net::AddressList& address,
                         const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
@@ skipping 207 matching lines @@
                                int result) {
   DCHECK(!read_callback_.is_null());
   read_callback_.Run(result, io_buffer);
   read_callback_.Reset();
 }
 
 void TCPSocket::OnAccept(int result) {
   DCHECK(!accept_callback_.is_null());
   if (result == net::OK && accept_socket_.get()) {
     accept_callback_.Run(result,
-                         make_scoped_ptr(static_cast<net::TCPClientSocket*>(
+                         base::WrapUnique(static_cast<net::TCPClientSocket*>(
                              accept_socket_.release())));
   } else {
     accept_callback_.Run(result, NULL);
   }
   accept_callback_.Reset();
 }
 
 void TCPSocket::Release() {
   // Release() is only invoked when the underlying sockets are taken (via
   // ClientStream()) by TLSSocket. TLSSocket only supports CLIENT-mode
@@ skipping 24 matching lines @@
   return !read_callback_.is_null();
 }
 
 ResumableTCPSocket::ResumableTCPSocket(const std::string& owner_extension_id)
     : TCPSocket(owner_extension_id),
       persistent_(false),
       buffer_size_(0),
       paused_(false) {}
 
 ResumableTCPSocket::ResumableTCPSocket(
-    scoped_ptr<net::TCPClientSocket> tcp_client_socket,
+    std::unique_ptr<net::TCPClientSocket> tcp_client_socket,
     const std::string& owner_extension_id,
     bool is_connected)
     : TCPSocket(std::move(tcp_client_socket), owner_extension_id, is_connected),
       persistent_(false),
       buffer_size_(0),
       paused_(false) {}
 
 bool ResumableTCPSocket::IsPersistent() const { return persistent(); }
 
 ResumableTCPServerSocket::ResumableTCPServerSocket(
     const std::string& owner_extension_id)
     : TCPSocket(owner_extension_id), persistent_(false), paused_(false) {}
 
 bool ResumableTCPServerSocket::IsPersistent() const { return persistent(); }
 
 }  // namespace extensions