Convert device to std::unique_ptr

device/serial/serial_io_handler.h

 // 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.
 
 #ifndef DEVICE_SERIAL_SERIAL_IO_HANDLER_H_
 #define DEVICE_SERIAL_SERIAL_IO_HANDLER_H_
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/non_thread_safe.h"
 #include "build/build_config.h"
 #include "device/serial/buffer.h"
 #include "device/serial/serial.mojom.h"
@@ skipping 42 matching lines @@
       dbus::FileDescriptor fd);
 
   // Reports the open error from the permission broker.
   void ReportPathOpenError(const std::string& error_name,
                            const std::string& error_message);
 #endif  // defined(OS_CHROMEOS)
 
   // Performs an async Read operation. Behavior is undefined if this is called
   // while a Read is already pending. Otherwise, the Done or DoneWithError
   // method on |buffer| will eventually be called with a result.
-  void Read(scoped_ptr<WritableBuffer> buffer);
+  void Read(std::unique_ptr<WritableBuffer> buffer);
 
   // Performs an async Write operation. Behavior is undefined if this is called
   // while a Write is already pending. Otherwise, the Done or DoneWithError
   // method on |buffer| will eventually be called with a result.
-  void Write(scoped_ptr<ReadOnlyBuffer> buffer);
+  void Write(std::unique_ptr<ReadOnlyBuffer> buffer);
 
   // Indicates whether or not a read is currently pending.
   bool IsReadPending() const;
 
   // Indicates whether or not a write is currently pending.
   bool IsWritePending() const;
 
   // Attempts to cancel a pending read operation.
   void CancelRead(serial::ReceiveError reason);
 
@@ skipping 143 matching lines @@
   // Continues a Close operation on the FILE thread.
   static void DoClose(base::File port);
 
   // File for the opened serial device. This value is only modified from the IO
   // thread.
   base::File file_;
 
   // Currently applied connection options.
   serial::ConnectionOptions options_;
 
-  scoped_ptr<WritableBuffer> pending_read_buffer_;
+  std::unique_ptr<WritableBuffer> pending_read_buffer_;
   serial::ReceiveError read_cancel_reason_;
   bool read_canceled_;
 
-  scoped_ptr<ReadOnlyBuffer> pending_write_buffer_;
+  std::unique_ptr<ReadOnlyBuffer> pending_write_buffer_;
   serial::SendError write_cancel_reason_;
   bool write_canceled_;
 
   // Callback to handle the completion of a pending Open() request.
   OpenCompleteCallback open_complete_;
 
   scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner_;
   // On Chrome OS, PermissionBrokerClient should be called on the UI thread.
   scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner_;
 
   std::string port_;
 
   DISALLOW_COPY_AND_ASSIGN(SerialIoHandler);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_SERIAL_SERIAL_IO_HANDLER_H_