Convert //tools to use std::unique_ptr

tools/android/forwarder2/device_forwarder_main.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 <signal.h>
 #include <stdlib.h>
 
 #include <iostream>
 #include <string>
 
@@ skipping 49 matching lines @@
   // Daemon::ServerDelegate:
   void Init() override {
     DCHECK(!g_notifier);
     g_notifier = new forwarder2::PipeNotifier();
     signal(SIGTERM, KillHandler);
     signal(SIGINT, KillHandler);
     controller_thread_.reset(new base::Thread("controller_thread"));
     controller_thread_->Start();
   }
 
-  void OnClientConnected(scoped_ptr<Socket> client_socket) override {
+  void OnClientConnected(std::unique_ptr<Socket> client_socket) override {
     if (initialized_) {
       client_socket->WriteString("OK");
       return;
     }
     controller_thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&ServerDelegate::StartController, base::Unretained(this),
                    GetExitNotifierFD(), base::Passed(&client_socket)));
     initialized_ = true;
   }
 
  private:
-  void StartController(int exit_notifier_fd, scoped_ptr<Socket> client_socket) {
+  void StartController(int exit_notifier_fd,
+                       std::unique_ptr<Socket> client_socket) {
     DCHECK(!controller_.get());
-    scoped_ptr<DeviceController> controller(
+    std::unique_ptr<DeviceController> controller(
         DeviceController::Create(kUnixDomainSocketPath, exit_notifier_fd));
     if (!controller.get()) {
       client_socket->WriteString(
           base::StringPrintf("ERROR: Could not initialize device controller "
                              "with ADB socket path: %s",
                              kUnixDomainSocketPath));
       return;
     }
     controller_.swap(controller);
     controller_->Start();
     client_socket->WriteString("OK");
     client_socket->Close();
   }
 
-  scoped_ptr<DeviceController> controller_;
-  scoped_ptr<base::Thread> controller_thread_;
+  std::unique_ptr<DeviceController> controller_;
+  std::unique_ptr<base::Thread> controller_thread_;
   bool initialized_;
 };
 
 class ClientDelegate : public Daemon::ClientDelegate {
  public:
   ClientDelegate() : has_failed_(false) {}
 
   bool has_failed() const { return has_failed_; }
 
   // Daemon::ClientDelegate:
@@ skipping 38 matching lines @@
     return 1;
   return client_delegate.has_failed();
 }
 
 }  // namespace
 }  // namespace forwarder2
 
 int main(int argc, char** argv) {
   return forwarder2::RunDeviceForwarder(argc, argv);
 }