Remove DeviceMonitorLinux::WillDestroyCurrentMessageLoop().

device/usb/usb_service_linux.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 "device/usb/usb_service_linux.h"
 
 #include <stdint.h>
 
+#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/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.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"
@@ skipping 39 matching lines @@
 }
 
 }  // namespace
 
 class UsbServiceLinux::FileThreadHelper : public DeviceMonitorLinux::Observer {
  public:
   FileThreadHelper(base::WeakPtr<UsbServiceLinux> service,
                    scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~FileThreadHelper() override;
 
-  static void Start(std::unique_ptr<FileThreadHelper> self);
+  void Start();
 
  private:
   // DeviceMonitorLinux::Observer:
   void OnDeviceAdded(udev_device* udev_device) override;
   void OnDeviceRemoved(udev_device* device) override;
-  void WillDestroyMonitorMessageLoop() override;
 
   base::ThreadChecker thread_checker_;
   ScopedObserver<DeviceMonitorLinux, DeviceMonitorLinux::Observer> observer_;
 
   // |service_| can only be checked for validity on |task_runner_|'s thread.
   base::WeakPtr<UsbServiceLinux> service_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(FileThreadHelper);
 };
 
 UsbServiceLinux::FileThreadHelper::FileThreadHelper(
     base::WeakPtr<UsbServiceLinux> service,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : observer_(this), service_(service), task_runner_(task_runner) {}
+    : observer_(this), service_(service), task_runner_(std::move(task_runner)) {
+  thread_checker_.DetachFromThread();
+}
 
 UsbServiceLinux::FileThreadHelper::~FileThreadHelper() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 // static
-void UsbServiceLinux::FileThreadHelper::Start(
-    std::unique_ptr<FileThreadHelper> self) {
+void UsbServiceLinux::FileThreadHelper::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(
-      FROM_HERE, base::Bind(&UsbServiceLinux::HelperStarted, self->service_));
-
-  // |self| is now owned by the current message loop.
-  ignore_result(self.release());
+  observer_.Add(monitor);
+  monitor->Enumerate(
+      base::Bind(&FileThreadHelper::OnDeviceAdded, base::Unretained(this)));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&UsbServiceLinux::HelperStarted, service_));
 }
 
 void UsbServiceLinux::FileThreadHelper::OnDeviceAdded(
     udev_device* udev_device) {
   const char* subsystem = udev_device_get_subsystem(udev_device);
   if (!subsystem || strcmp(subsystem, "usb") != 0)
     return;
 
   const char* value = udev_device_get_devnode(udev_device);
   if (!value)
@@ skipping 50 matching lines @@
 void UsbServiceLinux::FileThreadHelper::OnDeviceRemoved(udev_device* device) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const char* device_path = udev_device_get_devnode(device);
   if (device_path) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&UsbServiceLinux::OnDeviceRemoved, service_,
                               std::string(device_path)));
   }
 }
 
-void UsbServiceLinux::FileThreadHelper::WillDestroyMonitorMessageLoop() {
-  delete this;
-}
-
 UsbServiceLinux::UsbServiceLinux(
-    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-    : UsbService(base::ThreadTaskRunnerHandle::Get(), blocking_task_runner),
+    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_in)
+    : UsbService(base::ThreadTaskRunnerHandle::Get(),
+                 std::move(blocking_task_runner_in)),
       weak_factory_(this) {
-  std::unique_ptr<FileThreadHelper> helper(
-      new FileThreadHelper(weak_factory_.GetWeakPtr(), task_runner()));
-  helper_ = helper.get();
-  blocking_task_runner->PostTask(
-      FROM_HERE, base::Bind(&FileThreadHelper::Start, base::Passed(&helper)));
+  helper_ = base::MakeUnique<FileThreadHelper>(weak_factory_.GetWeakPtr(),
+                                               task_runner());
+  blocking_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&FileThreadHelper::Start, base::Unretained(helper_.get())));
 }
 
 UsbServiceLinux::~UsbServiceLinux() {
-  blocking_task_runner()->DeleteSoon(FROM_HERE, helper_);
+  DCHECK(!helper_);
+}
+
+void UsbServiceLinux::Shutdown() {
+  const bool did_post_task =
+      blocking_task_runner()->DeleteSoon(FROM_HERE, helper_.release());
+  DCHECK(did_post_task);
+  UsbService::Shutdown();
 }
 
 void UsbServiceLinux::GetDevices(const GetDevicesCallback& callback) {
   DCHECK(CalledOnValidThread());
   if (enumeration_ready())
     UsbService::GetDevices(callback);
   else
     enumeration_callbacks_.push_back(callback);
 }
 
@@ skipping 100 matching lines @@
     result.reserve(devices().size());
     for (const auto& map_entry : devices())
       result.push_back(map_entry.second);
     for (const auto& callback : enumeration_callbacks_)
       callback.Run(result);
     enumeration_callbacks_.clear();
   }
 }
 
 }  // namespace device