Implement Linux media notifier.

content/browser/media_device_notifications_linux.h

+// 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.
+
+#ifndef CONTENT_BROWSER_MEDIA_DEVICE_NOTIFICATIONS_LINUX_H_
+#define CONTENT_BROWSER_MEDIA_DEVICE_NOTIFICATIONS_LINUX_H_
+#pragma once
+
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/file_path.h"
+#include "base/files/file_path_watcher.h"
+#include "base/memory/ref_counted.h"
+#include "base/system_monitor/system_monitor.h"
+#include "content/common/content_export.h"
+
+namespace content {
+
+class CONTENT_EXPORT MediaDeviceNotificationsLinux
+    : public base::RefCountedThreadSafe<MediaDeviceNotificationsLinux> {
+ public:
+  explicit MediaDeviceNotificationsLinux(const FilePath& path);
+
+  // Must be called for MediaDeviceNotificationsLinux to work.
+  void Init();
+
+  void OnFilePathChanged(const FilePath& path);
+
+ private:
+  friend class base::RefCountedThreadSafe<MediaDeviceNotificationsLinux>;
+
+  typedef std::string MountDevice;
+  typedef std::string MountPoint;
+  typedef std::pair<MountDevice,
+                    base::SystemMonitor::DeviceIdType> MountDeviceAndId;
+  typedef std::map<MountPoint, MountDeviceAndId> MountMap;
+
+  // A simple pass-through class. MediaDeviceNotificationsLinux cannot directly
+  // inherit from FilePathWatcher::Delegate due to multiple inheritance.
+  class WatcherDelegate : public base::files::FilePathWatcher::Delegate {
+   public:
+    explicit WatcherDelegate(MediaDeviceNotificationsLinux* notifier);
+
+    // base::files::FilePathWatcher::Delegate implementation.
+    virtual void OnFilePathChanged(const FilePath& path) OVERRIDE;
+
+   private:
+    friend class base::RefCountedThreadSafe<WatcherDelegate>;
+
+    virtual ~WatcherDelegate();
+    MediaDeviceNotificationsLinux* notifier_;
+
+    DISALLOW_COPY_AND_ASSIGN(WatcherDelegate);
+  };
+
+  virtual ~MediaDeviceNotificationsLinux();
+
+  void InitOnFileThread();
+
+  // Parse the mtab file and find all changes.
+  void UpdateMtab();
+
+  // Read the mtab file entries into |mtab|.
+  void ReadMtab(MountMap* mtab);
+
+  // For a new device mounted at |mount_point|, see if it is a media device by
+  // checking for the existence of a DCIM directory.
+  // If it is a media device, return true, otherwise return false.
+  // Mac OS X behaves similarly, but this is not the only heuristic it uses.
+  // TODO(vandebo) Try to figure out how Mac OS X decides this.
+  bool IsMediaDevice(const MountPoint& mount_point);
+
+  // Add a media device with a given device and mount device. Assign it a device
+  // id as well.
+  void AddNewDevice(const MountDevice& mount_device,
+                    const MountPoint& mount_point,
+                    base::SystemMonitor::DeviceIdType* device_id);
+
+  // Remove a media device with a given device id.
+  void RemoveOldDevice(const base::SystemMonitor::DeviceIdType& device_id);
+
+  // Whether Init() has been called or not.
+  bool initialized_;
+
+  // Mtab file that lists the mount points.
+  const FilePath mtab_path_;
+  // Watcher for |mtab_path_|.
+  base::files::FilePathWatcher file_watcher_;
+  // Delegate to receive watcher notifications.
+  scoped_refptr<WatcherDelegate> watcher_delegate_;
+
+  // Mapping of relevent mount points and their corresponding mount devices.
+  // Keep in mind on Linux, a device can be mounted at multiple mount points,
+  // and multiple devices can be mounted at a mount point.
+  MountMap mtab_;
+
+  // The lowest available device id number.
+  base::SystemMonitor::DeviceIdType current_device_id_;
+
+  // Set of known file systems that we care about.
+  std::set<std::string> known_file_systems_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaDeviceNotificationsLinux);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_MEDIA_DEVICE_NOTIFICATIONS_LINUX_H_