Convert device to std::unique_ptr

device/hid/hid_service_linux.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 "device/hid/hid_service_linux.h"
 
 #include <fcntl.h>
 #include <stdint.h>
+
 #include <limits>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/scoped_observer.h"
@@ skipping 50 matching lines @@
  public:
   FileThreadHelper(base::WeakPtr<HidServiceLinux> service,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : observer_(this), service_(service), task_runner_(task_runner) {}
 
   ~FileThreadHelper() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     base::MessageLoop::current()->RemoveDestructionObserver(this);
   }
 
-  static void Start(scoped_ptr<FileThreadHelper> self) {
+  static void Start(std::unique_ptr<FileThreadHelper> self) {
     base::ThreadRestrictions::AssertIOAllowed();
     self->thread_checker_.DetachFromThread();
     // |self| must be added as a destruction observer first so that it will be
     // notified before DeviceMonitorLinux.
     base::MessageLoop::current()->AddDestructionObserver(self.get());
 
     DeviceMonitorLinux* monitor = DeviceMonitorLinux::GetInstance();
     self->observer_.Add(monitor);
     monitor->Enumerate(base::Bind(&FileThreadHelper::OnDeviceAdded,
                                   base::Unretained(self.get())));
@@ skipping 113 matching lines @@
   base::WeakPtr<HidServiceLinux> service_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(FileThreadHelper);
 };
 
 HidServiceLinux::HidServiceLinux(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : file_task_runner_(file_task_runner), weak_factory_(this) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
-  scoped_ptr<FileThreadHelper> helper(
+  std::unique_ptr<FileThreadHelper> helper(
       new FileThreadHelper(weak_factory_.GetWeakPtr(), task_runner_));
   helper_ = helper.get();
   file_task_runner_->PostTask(
       FROM_HERE, base::Bind(&FileThreadHelper::Start, base::Passed(&helper)));
 }
 
 HidServiceLinux::~HidServiceLinux() {
   file_task_runner_->DeleteSoon(FROM_HERE, helper_);
 }
 
 void HidServiceLinux::Connect(const HidDeviceId& device_id,
                               const ConnectCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const auto& map_entry = devices().find(device_id);
   if (map_entry == devices().end()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
   scoped_refptr<HidDeviceInfoLinux> device_info =
       static_cast<HidDeviceInfoLinux*>(map_entry->second.get());
 
-  scoped_ptr<ConnectParams> params(new ConnectParams(
+  std::unique_ptr<ConnectParams> params(new ConnectParams(
       device_info, callback, task_runner_, file_task_runner_));
 
 #if defined(OS_CHROMEOS)
   chromeos::PermissionBrokerClient* client =
       chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
   DCHECK(client) << "Could not get permission broker client.";
   chromeos::PermissionBrokerClient::ErrorCallback error_callback =
       base::Bind(&HidServiceLinux::OnPathOpenError,
                  params->device_info->device_node(), params->callback);
   client->OpenPath(
       device_info->device_node(),
       base::Bind(&HidServiceLinux::OnPathOpenComplete, base::Passed(&params)),
       error_callback);
 #else
   file_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&HidServiceLinux::OpenOnBlockingThread,
                                          base::Passed(&params)));
 #endif  // defined(OS_CHROMEOS)
 }
 
 #if defined(OS_CHROMEOS)
 
 // static
-void HidServiceLinux::OnPathOpenComplete(scoped_ptr<ConnectParams> params,
+void HidServiceLinux::OnPathOpenComplete(std::unique_ptr<ConnectParams> params,
                                          dbus::FileDescriptor fd) {
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       params->file_task_runner;
   file_task_runner->PostTask(
       FROM_HERE, base::Bind(&HidServiceLinux::ValidateFdOnBlockingThread,
                             base::Passed(&params), base::Passed(&fd)));
 }
 
 // static
 void HidServiceLinux::OnPathOpenError(const std::string& device_path,
                                       const ConnectCallback& callback,
                                       const std::string& error_name,
                                       const std::string& error_message) {
   HID_LOG(EVENT) << "Permission broker failed to open '" << device_path
                  << "': " << error_name << ": " << error_message;
   callback.Run(nullptr);
 }
 
 // static
 void HidServiceLinux::ValidateFdOnBlockingThread(
-    scoped_ptr<ConnectParams> params,
+    std::unique_ptr<ConnectParams> params,
     dbus::FileDescriptor fd) {
   base::ThreadRestrictions::AssertIOAllowed();
   fd.CheckValidity();
   DCHECK(fd.is_valid());
   params->device_file = base::File(fd.TakeValue());
   FinishOpen(std::move(params));
 }
 
 #else
 
 // static
-void HidServiceLinux::OpenOnBlockingThread(scoped_ptr<ConnectParams> params) {
+void HidServiceLinux::OpenOnBlockingThread(
+    std::unique_ptr<ConnectParams> params) {
   base::ThreadRestrictions::AssertIOAllowed();
   scoped_refptr<base::SingleThreadTaskRunner> task_runner = params->task_runner;
 
   base::FilePath device_path(params->device_info->device_node());
   base::File& device_file = params->device_file;
   int flags =
       base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE;
   device_file.Initialize(device_path, flags);
   if (!device_file.IsValid()) {
     base::File::Error file_error = device_file.error_details();
@@ skipping 12 matching lines @@
     task_runner->PostTask(FROM_HERE, base::Bind(params->callback, nullptr));
     return;
   }
 
   FinishOpen(std::move(params));
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 // static
-void HidServiceLinux::FinishOpen(scoped_ptr<ConnectParams> params) {
+void HidServiceLinux::FinishOpen(std::unique_ptr<ConnectParams> params) {
   base::ThreadRestrictions::AssertIOAllowed();
   scoped_refptr<base::SingleThreadTaskRunner> task_runner = params->task_runner;
 
   if (!base::SetNonBlocking(params->device_file.GetPlatformFile())) {
     HID_PLOG(ERROR) << "Failed to set the non-blocking flag on the device fd";
     task_runner->PostTask(FROM_HERE, base::Bind(params->callback, nullptr));
     return;
   }
 
   task_runner->PostTask(
       FROM_HERE,
       base::Bind(&HidServiceLinux::CreateConnection, base::Passed(&params)));
 }
 
 // static
-void HidServiceLinux::CreateConnection(scoped_ptr<ConnectParams> params) {
+void HidServiceLinux::CreateConnection(std::unique_ptr<ConnectParams> params) {
   DCHECK(params->device_file.IsValid());
   params->callback.Run(make_scoped_refptr(new HidConnectionLinux(
       params->device_info, std::move(params->device_file),
       params->file_task_runner)));
 }
 
 }  // namespace device