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

extensions/browser/api/socket/socket_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/socket/socket_api.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 57 matching lines @@
 
 SocketAsyncApiFunction::~SocketAsyncApiFunction() {}
 
 bool SocketAsyncApiFunction::PrePrepare() {
   manager_ = CreateSocketResourceManager();
   return manager_->SetBrowserContext(browser_context());
 }
 
 bool SocketAsyncApiFunction::Respond() { return error_.empty(); }
 
-scoped_ptr<SocketResourceManagerInterface>
+std::unique_ptr<SocketResourceManagerInterface>
 SocketAsyncApiFunction::CreateSocketResourceManager() {
-  return scoped_ptr<SocketResourceManagerInterface>(
+  return std::unique_ptr<SocketResourceManagerInterface>(
       new SocketResourceManager<Socket>());
 }
 
 int SocketAsyncApiFunction::AddSocket(Socket* socket) {
   return manager_->Add(socket);
 }
 
 Socket* SocketAsyncApiFunction::GetSocket(int api_resource_id) {
   return manager_->Get(extension_->id(), api_resource_id);
 }
@@ skipping 41 matching lines @@
 
 #if defined(OS_CHROMEOS)
 
 void SocketAsyncApiFunction::OpenFirewallHoleOnUIThread(
     AppFirewallHole::PortType type,
     uint16_t port,
     int socket_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AppFirewallHoleManager* manager =
       AppFirewallHoleManager::Get(browser_context());
-  scoped_ptr<AppFirewallHole, BrowserThread::DeleteOnUIThread> hole(
+  std::unique_ptr<AppFirewallHole, BrowserThread::DeleteOnUIThread> hole(
       manager->Open(type, port, extension_id()).release());
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&SocketAsyncApiFunction::OnFirewallHoleOpened, this, socket_id,
                  base::Passed(&hole)));
 }
 
 void SocketAsyncApiFunction::OnFirewallHoleOpened(
     int socket_id,
-    scoped_ptr<AppFirewallHole, BrowserThread::DeleteOnUIThread> hole) {
+    std::unique_ptr<AppFirewallHole, BrowserThread::DeleteOnUIThread> hole) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!hole) {
     error_ = kFirewallFailure;
     SetResult(new base::FundamentalValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   Socket* socket = GetSocket(socket_id);
   if (!socket) {
@@ skipping 291 matching lines @@
 void SocketAcceptFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     socket->Accept(base::Bind(&SocketAcceptFunction::OnAccept, this));
   } else {
     error_ = kSocketNotFoundError;
     OnAccept(-1, NULL);
   }
 }
 
-void SocketAcceptFunction::OnAccept(int result_code,
-                                    scoped_ptr<net::TCPClientSocket> socket) {
+void SocketAcceptFunction::OnAccept(
+    int result_code,
+    std::unique_ptr<net::TCPClientSocket> socket) {
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, result_code);
   if (socket) {
     Socket* client_socket =
         new TCPSocket(std::move(socket), extension_id(), true);
     result->SetInteger(kSocketIdKey, AddSocket(client_socket));
   }
   SetResult(result);
 
   AsyncWorkCompleted();
@@ skipping 575 matching lines @@
   TLSSocket::UpgradeSocketToTLS(
       socket,
       url_request_context->ssl_config_service(),
       url_request_context->cert_verifier(),
       url_request_context->transport_security_state(),
       extension_id(),
       params_->options.get(),
       base::Bind(&SocketSecureFunction::TlsConnectDone, this));
 }
 
-void SocketSecureFunction::TlsConnectDone(scoped_ptr<TLSSocket> socket,
+void SocketSecureFunction::TlsConnectDone(std::unique_ptr<TLSSocket> socket,
                                           int result) {
   // if an error occurred, socket MUST be NULL.
   DCHECK(result == net::OK || socket == NULL);
 
   if (socket && result == net::OK) {
     ReplaceSocket(params_->socket_id, socket.release());
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = api::socket::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions