Remove DeviceMonitorLinux::WillDestroyCurrentMessageLoop().

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/memory/ptr_util.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/base/device_monitor_linux.h"
 #include "device/hid/hid_connection_linux.h"
 #include "device/hid/hid_device_info_linux.h"
@@ skipping 32 matching lines @@
   ConnectCallback callback;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner;
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner;
   base::File device_file;
 };
 
 class HidServiceLinux::FileThreadHelper : public DeviceMonitorLinux::Observer {
  public:
   FileThreadHelper(base::WeakPtr<HidServiceLinux> service,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-      : observer_(this), service_(service), task_runner_(task_runner) {}
+      : observer_(this), service_(service), task_runner_(task_runner) {
+    thread_checker_.DetachFromThread();
+  }
 
   ~FileThreadHelper() override {
     DCHECK(thread_checker_.CalledOnValidThread());
   }
 
-  static void Start(std::unique_ptr<FileThreadHelper> self) {
+  void Start() {
     base::ThreadRestrictions::AssertIOAllowed();
-    self->thread_checker_.DetachFromThread();
+    DCHECK(thread_checker_.CalledOnValidThread());
 
     DeviceMonitorLinux* monitor = DeviceMonitorLinux::GetInstance();
-    self->observer_.Add(monitor);
-    monitor->Enumerate(base::Bind(&FileThreadHelper::OnDeviceAdded,
-                                  base::Unretained(self.get())));
-    self->task_runner_->PostTask(
+    observer_.Add(monitor);
+    monitor->Enumerate(
+        base::Bind(&FileThreadHelper::OnDeviceAdded, base::Unretained(this)));
+    task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&HidServiceLinux::FirstEnumerationComplete, self->service_));
-
-    // |self| is now owned by the current message loop.
-    ignore_result(self.release());
+        base::Bind(&HidServiceLinux::FirstEnumerationComplete, service_));
   }
 
  private:
   // DeviceMonitorLinux::Observer:
   void OnDeviceAdded(udev_device* device) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     const char* device_path = udev_device_get_syspath(device);
     if (!device_path) {
       return;
     }
@@ skipping 77 matching lines @@
   void OnDeviceRemoved(udev_device* device) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     const char* device_path = udev_device_get_syspath(device);
     if (device_path) {
       task_runner_->PostTask(
           FROM_HERE, base::Bind(&HidServiceLinux::RemoveDevice, service_,
                                 std::string(device_path)));
     }
   }
 
-  void WillDestroyMonitorMessageLoop() override {
-    DCHECK(thread_checker_.CalledOnValidThread());
-    delete this;
-  }
-
   base::ThreadChecker thread_checker_;
   ScopedObserver<DeviceMonitorLinux, DeviceMonitorLinux::Observer> observer_;
 
   // This weak pointer is only valid when checked on this task runner.
   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) {
+    : file_task_runner_(std::move(file_task_runner)), weak_factory_(this) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
-  std::unique_ptr<FileThreadHelper> helper(
-      new FileThreadHelper(weak_factory_.GetWeakPtr(), task_runner_));
-  helper_ = helper.get();
+  helper_ = base::MakeUnique<FileThreadHelper>(weak_factory_.GetWeakPtr(),
+                                               task_runner_);
   file_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&FileThreadHelper::Start, base::Passed(&helper)));
+      FROM_HERE,
+      base::Bind(&FileThreadHelper::Start, base::Unretained(helper_.get())));
 }
 
 HidServiceLinux::~HidServiceLinux() {
-  file_task_runner_->DeleteSoon(FROM_HERE, helper_);
+  DCHECK(!helper_);
+}
+
+void HidServiceLinux::Shutdown() {
+  const bool did_post_task =
+      file_task_runner_->DeleteSoon(FROM_HERE, helper_.release());
+  DCHECK(did_post_task);
+  HidService::Shutdown();
 }
 
 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;
@@ skipping 98 matching lines @@
 
 // static
 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