Convert //remoting to use std::unique_ptr

remoting/host/security_key/gnubby_socket.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_socket.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/timer/timer.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
 namespace remoting {
 
 namespace {
 
 const size_t kRequestSizeBytes = 4;
 const size_t kMaxRequestLength = 16384;
 const size_t kRequestReadBufferLength = kRequestSizeBytes + kMaxRequestLength;
 
 // SSH Failure Code
 const char kSshError[] = {0x05};
 
 }  // namespace
 
-GnubbySocket::GnubbySocket(scoped_ptr<net::StreamSocket> socket,
+GnubbySocket::GnubbySocket(std::unique_ptr<net::StreamSocket> socket,
                            base::TimeDelta timeout,
                            const base::Closure& timeout_callback)
     : socket_(std::move(socket)),
       read_completed_(false),
       read_buffer_(new net::IOBufferWithSize(kRequestReadBufferLength)) {
   timer_.reset(new base::Timer(false, false));
   timer_->Start(FROM_HERE, timeout, timeout_callback);
 }
 
 GnubbySocket::~GnubbySocket() {}
@@ skipping 12 matching lines @@
   request_data_.clear();
   return true;
 }
 
 void GnubbySocket::SendResponse(const std::string& response_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!write_buffer_);
 
   std::string response_length_string = GetResponseLengthAsBytes(response_data);
   int response_len = response_length_string.size() + response_data.size();
-  scoped_ptr<std::string> response(
+  std::unique_ptr<std::string> response(
       new std::string(response_length_string + response_data));
   write_buffer_ = new net::DrainableIOBuffer(
       new net::StringIOBuffer(std::move(response)), response_len);
   DoWrite();
 }
 
 void GnubbySocket::SendSshError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SendResponse(std::string(kSshError, arraysize(kSshError)));
@@ skipping 106 matching lines @@
 
   return response_len;
 }
 
 void GnubbySocket::ResetTimer() {
   if (timer_->IsRunning())
     timer_->Reset();
 }
 
 }  // namespace remoting