Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

extensions/browser/api/serial/serial_connection.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 "extensions/browser/api/serial/serial_connection.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "device/serial/buffer.h"
 #include "extensions/browser/api/api_resource_manager.h"
 #include "extensions/common/api/serial.h"
 
 namespace extensions {
 
 namespace {
 
 const int kDefaultBufferSize = 4096;
@@ skipping 193 matching lines @@
   io_handler_->Open(port_, *device::serial::ConnectionOptions::From(options),
                     callback);
 }
 
 bool SerialConnection::Receive(const ReceiveCompleteCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!receive_complete_.is_null())
     return false;
   receive_complete_ = callback;
   receive_buffer_ = new net::IOBuffer(buffer_size_);
-  io_handler_->Read(make_scoped_ptr(new device::ReceiveBuffer(
+  io_handler_->Read(base::WrapUnique(new device::ReceiveBuffer(
       receive_buffer_, buffer_size_,
       base::Bind(&SerialConnection::OnAsyncReadComplete, AsWeakPtr()))));
   receive_timeout_task_.reset();
   if (receive_timeout_ > 0) {
     receive_timeout_task_.reset(new TimeoutTask(
         base::Bind(&SerialConnection::OnReceiveTimeout, AsWeakPtr()),
         base::TimeDelta::FromMilliseconds(receive_timeout_)));
   }
   return true;
 }
 
 bool SerialConnection::Send(const std::vector<char>& data,
                             const SendCompleteCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!send_complete_.is_null())
     return false;
   send_complete_ = callback;
-  io_handler_->Write(make_scoped_ptr(new device::SendBuffer(
+  io_handler_->Write(base::WrapUnique(new device::SendBuffer(
       data, base::Bind(&SerialConnection::OnAsyncWriteComplete, AsWeakPtr()))));
   send_timeout_task_.reset();
   if (send_timeout_ > 0) {
     send_timeout_task_.reset(new TimeoutTask(
         base::Bind(&SerialConnection::OnSendTimeout, AsWeakPtr()),
         base::TimeDelta::FromMilliseconds(send_timeout_)));
   }
   return true;
 }
 
@@ skipping 157 matching lines @@
   output->parity_bit = extensions::ConvertParityBitToMojo(input.parity_bit);
   output->stop_bits = extensions::ConvertStopBitsToMojo(input.stop_bits);
   if (input.cts_flow_control.get()) {
     output->has_cts_flow_control = true;
     output->cts_flow_control = *input.cts_flow_control;
   }
   return output;
 }
 
 }  // namespace mojo