Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/devtools/protocol/tethering_handler.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 "content/browser/devtools/protocol/tethering_handler.h"
 
 #include "base/stl_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/socket/server_socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/socket/tcp_server_socket.h"
 
 namespace content {
 namespace devtools {
 namespace tethering {
 
 namespace {
 
 const int kListenBacklog = 5;
 const int kBufferSize = 16 * 1024;
 
 const int kMinTetheringPort = 1024;
 const int kMaxTetheringPort = 32767;
 
 using Response = DevToolsProtocolClient::Response;
 using CreateServerSocketCallback =
-    base::Callback<scoped_ptr<net::ServerSocket>(std::string*)>;
+    base::Callback<std::unique_ptr<net::ServerSocket>(std::string*)>;
 
 class SocketPump {
  public:
   SocketPump(net::StreamSocket* client_socket)
       : client_socket_(client_socket),
         pending_writes_(0),
         pending_destruction_(false) {
   }
 
   std::string Init(const CreateServerSocketCallback& socket_callback) {
@@ skipping 98 matching lines @@
   void SelfDestruct() {
     if (pending_writes_ > 0) {
       pending_destruction_ = true;
       return;
     }
     delete this;
   }
 
 
  private:
-  scoped_ptr<net::StreamSocket> client_socket_;
-  scoped_ptr<net::ServerSocket> server_socket_;
-  scoped_ptr<net::StreamSocket> accepted_socket_;
+  std::unique_ptr<net::StreamSocket> client_socket_;
+  std::unique_ptr<net::ServerSocket> server_socket_;
+  std::unique_ptr<net::StreamSocket> accepted_socket_;
   int pending_writes_;
   bool pending_destruction_;
 };
 
 class BoundSocket {
  public:
   typedef base::Callback<void(uint16_t, const std::string&)> AcceptedCallback;
 
   BoundSocket(AcceptedCallback accepted_callback,
               const CreateServerSocketCallback& socket_callback)
@@ skipping 48 matching lines @@
       return;
 
     SocketPump* pump = new SocketPump(accept_socket_.release());
     std::string name = pump->Init(socket_callback_);
     if (!name.empty())
       accepted_callback_.Run(port_, name);
   }
 
   AcceptedCallback accepted_callback_;
   CreateServerSocketCallback socket_callback_;
-  scoped_ptr<net::ServerSocket> socket_;
-  scoped_ptr<net::StreamSocket> accept_socket_;
+  std::unique_ptr<net::ServerSocket> socket_;
+  std::unique_ptr<net::StreamSocket> accept_socket_;
   uint16_t port_;
 };
 
 }  // namespace
 
 // TetheringHandler::TetheringImpl -------------------------------------------
 
 class TetheringHandler::TetheringImpl {
  public:
   TetheringImpl(
@@ skipping 29 matching lines @@
 
 void TetheringHandler::TetheringImpl::Bind(DevToolsCommandId command_id,
                                            uint16_t port) {
   if (bound_sockets_.find(port) != bound_sockets_.end()) {
     SendInternalError(command_id, "Port already bound");
     return;
   }
 
   BoundSocket::AcceptedCallback callback = base::Bind(
       &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this));
-  scoped_ptr<BoundSocket> bound_socket(
+  std::unique_ptr<BoundSocket> bound_socket(
       new BoundSocket(callback, socket_callback_));
   if (!bound_socket->Listen(port)) {
     SendInternalError(command_id, "Could not bind port");
     return;
   }
 
   bound_sockets_[port] = bound_socket.release();
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
@@ skipping 49 matching lines @@
       weak_factory_(this) {
 }
 
 TetheringHandler::~TetheringHandler() {
   if (is_active_) {
     task_runner_->DeleteSoon(FROM_HERE, impl_);
     impl_ = nullptr;
   }
 }
 
-void TetheringHandler::SetClient(scoped_ptr<Client> client) {
+void TetheringHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
 void TetheringHandler::Accepted(uint16_t port, const std::string& name) {
   client_->Accepted(AcceptedParams::Create()->set_port(port)
                                             ->set_connection_id(name));
 }
 
 bool TetheringHandler::Activate() {
   if (is_active_)
@@ skipping 39 matching lines @@
 }
 
 void TetheringHandler::SendInternalError(DevToolsCommandId command_id,
                                          const std::string& message) {
   client_->SendError(command_id, Response::InternalError(message));
 }
 
 }  // namespace tethering
 }  // namespace devtools
 }  // namespace content