Convert //remoting to use std::unique_ptr

remoting/host/security_key/gnubby_auth_handler_linux.cc

 // Copyright 2016 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 "remoting/host/security_key/gnubby_auth_handler.h"
 
 #include <stdint.h>
 #include <unistd.h>
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 #include "net/socket/unix_domain_server_socket_posix.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/security_key/gnubby_socket.h"
@@ skipping 59 matching lines @@
   // Send an error and closes an active socket.
   void SendErrorAndCloseActiveSocket(const ActiveSockets::const_iterator& iter);
 
   // A request timed out.
   void RequestTimedOut(int gnubby_connection_id);
 
   // Ensures GnubbyAuthHandlerLinux methods are called on the same thread.
   base::ThreadChecker thread_checker_;
 
   // Socket used to listen for authorization requests.
-  scoped_ptr<net::UnixDomainServerSocket> auth_socket_;
+  std::unique_ptr<net::UnixDomainServerSocket> auth_socket_;
 
   // A temporary holder for an accepted connection.
-  scoped_ptr<net::StreamSocket> accept_socket_;
+  std::unique_ptr<net::StreamSocket> accept_socket_;
 
   // Used to pass gnubby extension messages to the client.
   SendMessageCallback send_message_callback_;
 
   // The last assigned gnubby connection id.
   int last_connection_id_;
 
   // Sockets by connection id used to process gnubbyd requests.
   ActiveSockets active_sockets_;
 
   // Timeout used for a request.
   base::TimeDelta request_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(GnubbyAuthHandlerLinux);
 };
 
-scoped_ptr<GnubbyAuthHandler> GnubbyAuthHandler::Create(
+std::unique_ptr<GnubbyAuthHandler> GnubbyAuthHandler::Create(
     const SendMessageCallback& callback) {
-  scoped_ptr<GnubbyAuthHandler> auth_handler(new GnubbyAuthHandlerLinux());
+  std::unique_ptr<GnubbyAuthHandler> auth_handler(new GnubbyAuthHandlerLinux());
   auth_handler->SetSendMessageCallback(callback);
   return auth_handler;
 }
 
 void GnubbyAuthHandler::SetGnubbySocketName(
     const base::FilePath& gnubby_socket_name) {
   g_gnubby_socket_name.Get() = gnubby_socket_name;
 }
 
 GnubbyAuthHandlerLinux::GnubbyAuthHandlerLinux()
@@ skipping 145 matching lines @@
 
 void GnubbyAuthHandlerLinux::RequestTimedOut(int gnubby_connection_id) {
   HOST_LOG << "Gnubby request timed out";
   ActiveSockets::const_iterator iter =
       active_sockets_.find(gnubby_connection_id);
   if (iter != active_sockets_.end())
     SendErrorAndCloseActiveSocket(iter);
 }
 
 }  // namespace remoting