Add Media device notification to SystemMonitor and Mac impl

base/system_monitor/system_monitor_mac.mm

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
 // Implementation based on sample code from
 // http://developer.apple.com/library/mac/#qa/qa1340/_index.html.
 
 #include "base/system_monitor/system_monitor.h"
 
+#include <Carbon/Carbon.h>
+#include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
 #include <IOKit/IOMessage.h>
 
+#include "base/file_path.h"
+#include "base/mac/foundation_util.h"
+#include "base/sys_string_conversions.h"
+
 namespace base {
 
 namespace {
 
 io_connect_t g_system_power_io_port = 0;
 IONotificationPortRef g_notification_port_ref = 0;
 io_object_t g_notifier_object = 0;
 
 void SystemPowerEventCallback(void*,
                               io_service_t service,
                               natural_t message_type,
                               void* message_argument) {
   SystemMonitor* sys_monitor = SystemMonitor::Get();
   DCHECK(sys_monitor);
   switch (message_type) {
     case kIOMessageSystemWillSleep:
       sys_monitor->ProcessPowerMessage(SystemMonitor::SUSPEND_EVENT);
       IOAllowPowerChange(g_system_power_io_port,
           reinterpret_cast<int>(message_argument));
       break;
 
     case kIOMessageSystemWillPowerOn:
       sys_monitor->ProcessPowerMessage(SystemMonitor::RESUME_EVENT);
       break;
   }
 }
 
+bool GetDeviceInfo(unsigned long device_number, std::string* name,
+                   FilePath* location) {
+  ICACopyObjectPropertyDictionaryPB properties_request;
+  properties_request.object = device_number;
+  CFDictionaryRef device_properties;
+  properties_request.theDict = &device_properties;
+  OSErr ret = ICACopyObjectPropertyDictionary(&properties_request, NULL);
+  CHECK_EQ(ret, noErr);
+
+  // For now, we only support mass storage media devices.
+  CFStringRef volume = mac::GetValueFromDictionary<CFStringRef>(
+      device_properties, CFSTR("volume"));
+  if (volume == NULL) {
+    CFRelease(device_properties);
+    return false;
+  }
+  *location = FilePath("/Volumes/").Append(SysCFStringRefToUTF8(volume));
+
+  CFStringRef device_name = mac::GetValueFromDictionary<CFStringRef>(
+      device_properties, CFSTR("ICAUserAssignedDeviceNameKey"));
+  if (device_name == NULL) {
+    device_name = mac::GetValueFromDictionary<CFStringRef>(
+        device_properties, CFSTR("ifil"));
+  }
+  if (device_name == NULL) {
+    CFRelease(device_properties);
+    return false;
+  }
+  *name = SysCFStringRefToUTF8(device_name);
+
+  CFRelease(device_properties);
+  return true;
+}
+
+void MediaDeviceNotificationCallback(CFStringRef notification_type,
+                                     CFDictionaryRef notification_dictionary) {
+  bool attach = false;
+  if (CFStringCompare(notification_type, kICANotificationTypeDeviceAdded, 0) ==
+      kCFCompareEqualTo) {
+    attach = true;
+  } else if (CFStringCompare(notification_type,
+                             kICANotificationTypeDeviceRemoved, 0) !=
+             kCFCompareEqualTo) {
+    return;
+  }
+  CFNumberRef refcon_object = mac::GetValueFromDictionary<CFNumberRef>(
+      notification_dictionary, kICARefconKey);
+  unsigned long refcon;
+  CFNumberGetValue(refcon_object, kCFNumberLongType, &refcon);
+  SystemMonitor* system_monitor = reinterpret_cast<SystemMonitor*>(refcon);
+
+  CFNumberRef device_number_object = mac::GetValueFromDictionary<CFNumberRef>(
+      notification_dictionary, kICANotificationDeviceICAObjectKey);
+  unsigned long device_number;
+  CFNumberGetValue(device_number_object, kCFNumberIntType, &device_number);
+  if (attach) {
+    std::string device_name;
+    FilePath location;
+    if (GetDeviceInfo(device_number, &device_name, &location)) {
+      system_monitor->ProcessMediaDeviceAttached(device_number, device_name,
+                                                 location);
+    }
+  } else {
+    system_monitor->ProcessMediaDeviceDetached(device_number);
+  }
+}
+
 }  // namespace
 
 // The reason we can't include this code in the constructor is because
 // PlatformInit() requires an active runloop and the IO port needs to be
 // allocated at sandbox initialization time, before there's a runloop.
 // See crbug.com/83783 .
 
 // static
 void SystemMonitor::AllocateSystemIOPorts() {
   DCHECK_EQ(g_system_power_io_port, 0u);
@@ skipping 12 matching lines @@
   // object.
   DCHECK_NE(g_system_power_io_port, 0u);
   if (g_system_power_io_port == 0)
     return;
 
   // Add the notification port to the application runloop
   CFRunLoopAddSource(
       CFRunLoopGetCurrent(),
       IONotificationPortGetRunLoopSource(g_notification_port_ref),
       kCFRunLoopCommonModes);
+
+  ICARegisterForEventNotificationPB notification_request;
+  notification_request.header.refcon = reinterpret_cast<unsigned long>(this);
+  notification_request.objectOfInterest = 0;  // Zero means all objects
+  CFStringRef events_of_interest_array[] = {kICANotificationTypeDeviceAdded,
+                                            kICANotificationTypeDeviceRemoved};
+  CFArrayRef events_of_interest =
+      CFArrayCreate(NULL, (const void**)&events_of_interest_array, 2,
+                    &kCFTypeArrayCallBacks);
+  notification_request.eventsOfInterest = events_of_interest;
+  notification_request.notificationProc = &MediaDeviceNotificationCallback;
+  notification_request.options = NULL;
+  OSErr err = ICARegisterForEventNotification(&notification_request, NULL);
+  CHECK_EQ(err, noErr);
 }
 
 void SystemMonitor::PlatformDestroy() {
   DCHECK_NE(g_system_power_io_port, 0u);
   if (g_system_power_io_port == 0)
     return;
 
   // Remove the sleep notification port from the application runloop
   CFRunLoopRemoveSource(
       CFRunLoopGetCurrent(),
       IONotificationPortGetRunLoopSource(g_notification_port_ref),
       kCFRunLoopCommonModes);
 
   // Deregister for system sleep notifications
   IODeregisterForSystemPower(&g_notifier_object);
 
   // IORegisterForSystemPower implicitly opens the Root Power Domain IOService,
   // so we close it here.
   IOServiceClose(g_system_power_io_port);
 
   g_system_power_io_port = 0;
 
   // Destroy the notification port allocated by IORegisterForSystemPower.
   IONotificationPortDestroy(g_notification_port_ref);
 }
 
 }  // namespace base