Convert //tools to use std::unique_ptr

tools/android/forwarder2/device_listener.cc

 // Copyright (c) 2012 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 "tools/android/forwarder2/device_listener.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "tools/android/forwarder2/command.h"
 #include "tools/android/forwarder2/forwarder.h"
 #include "tools/android/forwarder2/socket.h"
 
 namespace forwarder2 {
 
 // static
-scoped_ptr<DeviceListener> DeviceListener::Create(
-    scoped_ptr<Socket> host_socket,
+std::unique_ptr<DeviceListener> DeviceListener::Create(
+    std::unique_ptr<Socket> host_socket,
     int listener_port,
     const ErrorCallback& error_callback) {
-  scoped_ptr<Socket> listener_socket(new Socket());
-  scoped_ptr<DeviceListener> device_listener;
+  std::unique_ptr<Socket> listener_socket(new Socket());
+  std::unique_ptr<DeviceListener> device_listener;
   if (!listener_socket->BindTcp("", listener_port)) {
     LOG(ERROR) << "Device could not bind and listen to local port "
                << listener_port;
     SendCommand(command::BIND_ERROR, listener_port, host_socket.get());
     return device_listener;
   }
   // In case the |listener_port_| was zero, GetPort() will return the
   // currently (non-zero) allocated port for this socket.
   listener_port = listener_socket->GetPort();
   SendCommand(command::BIND_SUCCESS, listener_port, host_socket.get());
   device_listener.reset(new DeviceListener(std::move(listener_socket),
                                            std::move(host_socket),
                                            listener_port, error_callback));
   return device_listener;
 }
 
 DeviceListener::~DeviceListener() {
   DCHECK(deletion_task_runner_->RunsTasksOnCurrentThread());
   deletion_notifier_.Notify();
 }
 
 void DeviceListener::Start() {
   thread_.Start();
   AcceptNextClientSoon();
 }
 
-void DeviceListener::SetAdbDataSocket(scoped_ptr<Socket> adb_data_socket) {
+void DeviceListener::SetAdbDataSocket(std::unique_ptr<Socket> adb_data_socket) {
   thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&DeviceListener::OnAdbDataSocketReceivedOnInternalThread,
                  base::Unretained(this), base::Passed(&adb_data_socket)));
 }
 
-DeviceListener::DeviceListener(scoped_ptr<Socket> listener_socket,
-                               scoped_ptr<Socket> host_socket,
+DeviceListener::DeviceListener(std::unique_ptr<Socket> listener_socket,
+                               std::unique_ptr<Socket> host_socket,
                                int port,
                                const ErrorCallback& error_callback)
     : self_deleter_helper_(this, error_callback),
       listener_socket_(std::move(listener_socket)),
       host_socket_(std::move(host_socket)),
       listener_port_(port),
       deletion_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       thread_("DeviceListener") {
   CHECK(host_socket_.get());
   DCHECK(deletion_task_runner_.get());
@@ skipping 35 matching lines @@
     }
     // It can continue if the host forwarder could not connect to the host
     // server but the control connection is still alive (no errors). The device
     // acknowledged that (above), and it can re-try later.
     AcceptNextClientSoon();
     return;
   }
 }
 
 void DeviceListener::OnAdbDataSocketReceivedOnInternalThread(
-    scoped_ptr<Socket> adb_data_socket) {
+    std::unique_ptr<Socket> adb_data_socket) {
   DCHECK(adb_data_socket);
   SendCommand(command::ADB_DATA_SOCKET_SUCCESS, listener_port_,
               host_socket_.get());
   forwarders_manager_.CreateAndStartNewForwarder(std::move(device_data_socket_),
                                                  std::move(adb_data_socket));
   AcceptNextClientSoon();
 }
 
 void DeviceListener::OnInternalThreadError() {
   self_deleter_helper_.MaybeSelfDeleteSoon();
 }
 
 }  // namespace forwarder