Leak DeviceMonitorLinux on shutdown.

device/base/device_monitor_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/base/device_monitor_linux.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/thread_restrictions.h"
 #include "device/udev_linux/udev.h"
 
 namespace device {
 
 namespace {
 
 const char kUdevName[] = "udev";
 const char kUdevActionAdd[] = "add";
 const char kUdevActionRemove[] = "remove";
 
 // The instance will be reset when message loop destroys.
-base::LazyInstance<std::unique_ptr<DeviceMonitorLinux>>::Leaky
-    g_device_monitor_linux_ptr = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<DeviceMonitorLinux>::Leaky g_device_monitor_linux =
+    LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 DeviceMonitorLinux::DeviceMonitorLinux() : monitor_fd_(-1) {
   base::ThreadRestrictions::AssertIOAllowed();
   base::MessageLoop::current()->AddDestructionObserver(this);
 
   udev_.reset(udev_new());
   if (!udev_) {
     LOG(ERROR) << "Failed to create udev.";
@@ skipping 18 matching lines @@
   }
 
   monitor_watch_controller_ = base::FileDescriptorWatcher::WatchReadable(
       monitor_fd_,
       base::Bind(&DeviceMonitorLinux::OnMonitorCanReadWithoutBlocking,
                  base::Unretained(this)));
 }
 
 // static
 DeviceMonitorLinux* DeviceMonitorLinux::GetInstance() {
-  if (!g_device_monitor_linux_ptr.Get().get())
-    g_device_monitor_linux_ptr.Get().reset(new DeviceMonitorLinux());
-  return g_device_monitor_linux_ptr.Get().get();
+  return g_device_monitor_linux.Pointer();
 }
 
 void DeviceMonitorLinux::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.AddObserver(observer);
 }
 
 void DeviceMonitorLinux::RemoveObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observers_.RemoveObserver(observer);
@@ skipping 29 matching lines @@
         udev_device_new_from_syspath(udev_.get(), udev_list_entry_get_name(i)));
     if (device)
       callback.Run(device.get());
   }
 }
 
 void DeviceMonitorLinux::WillDestroyCurrentMessageLoop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (auto& observer : observers_)
     observer.WillDestroyMonitorMessageLoop();
-  g_device_monitor_linux_ptr.Get().reset(nullptr);
 }
 
 DeviceMonitorLinux::~DeviceMonitorLinux() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  base::MessageLoop::current()->RemoveDestructionObserver(this);
-  close(monitor_fd_);
+  // A leaky LazyInstance is never destroyed.
+  NOTREACHED();
 }
 
 void DeviceMonitorLinux::OnMonitorCanReadWithoutBlocking() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ScopedUdevDevicePtr device(udev_monitor_receive_device(monitor_.get()));
   if (!device)
     return;
 
   std::string action(udev_device_get_action(device.get()));
   if (action == kUdevActionAdd) {
     for (auto& observer : observers_)
       observer.OnDeviceAdded(device.get());
   } else if (action == kUdevActionRemove) {
     for (auto& observer : observers_)
       observer.OnDeviceRemoved(device.get());
   }
 }
 
 }  // namespace device