Add DeviceMonitorLinux in BrowserMainLoop.

content/browser/device_monitor_linux.cc

+// Copyright (c) 2012 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.
+
+// libudev is used for monitoring device changes.
+
+#include "content/browser/device_monitor_linux.h"
+
+#include <libudev.h>
+
+#include <string>
+
+#include "base/system_monitor/system_monitor.h"
+#include "content/browser/udev_linux.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace {
+
+struct SubsystemMap {
+  base::SystemMonitor::DeviceType device_type;
+  const char* subsystem;
+  const char* devtype;
+};
+
+const char kAudioSubsystem[] = "sound";
+const char kVideoSubsystem[] = "video4linux";
+
+// Add more subsystems here for monitoring.
+const SubsystemMap kSubsystemMap[] = {
+  { base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE, kAudioSubsystem, NULL },
+  { base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE, kVideoSubsystem, NULL },
+};
+
+}  // namespace
+
+namespace content {
+
+DeviceMonitorLinux::DeviceMonitorLinux()
+    : io_loop_(NULL) {

[jam, 2012/07/31 15:46:05]

we don't store MessageLoop pointers as a rule, since they're not safe (this is
why we have MessageLoopProxy, and TaskRunner). in this file though, it doesn't
appear you actually need to store it. the check in the destructor can be
replaced with dcheck (!BT::IsMLValid(io))

[wjia(left Chromium), 2012/07/31 18:19:08]

Done.

+  DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::IO));
+  BrowserThread::PostTask(BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&DeviceMonitorLinux::Initialize, base::Unretained(this)));
+}
+
+DeviceMonitorLinux::~DeviceMonitorLinux() {
+  DCHECK(!io_loop_);
+}
+
+void DeviceMonitorLinux::Initialize() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // We want to be notified of IO message loop destruction to delete |udev_|.
+  io_loop_ = MessageLoop::current();
+  io_loop_->AddDestructionObserver(this);
+
+  std::vector<UdevLinux::UdevMonitorFilter> filters;
+  for (size_t i = 0; i < arraysize(kSubsystemMap); ++i) {
+    filters.push_back(content::UdevLinux::UdevMonitorFilter(
+        kSubsystemMap[i].subsystem, kSubsystemMap[i].devtype));
+  }
+  udev_.reset(new UdevLinux(filters,
+      base::Bind(&DeviceMonitorLinux::OnDevicesChanged,
+                 base::Unretained(this))));
+}
+
+void DeviceMonitorLinux::WillDestroyCurrentMessageLoop() {
+  DCHECK_EQ(MessageLoop::current(), io_loop_);
+
+  udev_.reset();
+  io_loop_ = NULL;
+}
+
+void DeviceMonitorLinux::OnDevicesChanged(udev_device* device) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(device);
+
+  base::SystemMonitor::DeviceType device_type =
+      base::SystemMonitor::DEVTYPE_UNKNOWN;
+  std::string subsystem(udev_device_get_subsystem(device));
+  for (size_t i = 0; i < arraysize(kSubsystemMap); ++i) {
+    if (subsystem == kSubsystemMap[i].subsystem) {
+      device_type = kSubsystemMap[i].device_type;
+      break;
+    }
+  }
+  DCHECK_NE(device_type, base::SystemMonitor::DEVTYPE_UNKNOWN);
+
+  base::SystemMonitor::Get()->ProcessDevicesChanged(device_type);
+}
+
+}  // namespace content