Isolated FS for media devices.

chrome/browser/media_gallery/media_device_notifications_window_win.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.
 
 #include "chrome/browser/media_gallery/media_device_notifications_window_win.h"
 
 #include <windows.h>
 #include <dbt.h>
-
+#include <ObjBase.h>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/sys_string_conversions.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/win/wrapped_window_proc.h"
 #include "chrome/browser/media_gallery/media_device_notifications_utils.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const wchar_t WindowClassName[] = L"Chrome_MediaDeviceNotificationWindow";
 
+// The WPD device interface GUID
+const wchar_t WPDDevInterfaceGUID[] = L"{6ac27878-a6fa-4155-ba85-f98f491d4f33}";        
+
 LRESULT GetVolumeName(LPCWSTR drive,
                       LPWSTR volume_name,
                       unsigned int volume_name_len) {
   return GetVolumeInformation(drive, volume_name, volume_name_len, NULL, NULL,
       NULL, NULL, 0);
 }
 
 // Returns 0 if the devicetype is not volume.
 DWORD GetVolumeBitMaskFromBroadcastHeader(DWORD data) {
   PDEV_BROADCAST_HDR dev_broadcast_hdr =
@@ skipping 50 matching lines @@
 
   if (atom_)
     UnregisterClass(MAKEINTATOM(atom_), instance_);
 }
 
 LRESULT MediaDeviceNotificationsWindowWin::OnDeviceChange(UINT event_type,
                                                           DWORD data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   switch (event_type) {
     case DBT_DEVICEARRIVAL: {
-      DWORD unitmask = GetVolumeBitMaskFromBroadcastHeader(data);
-      for (int i = 0; unitmask; ++i, unitmask >>= 1) {
-        if (unitmask & 0x01) {
-          FilePath::StringType drive(L"_:\\");
-          drive[0] = L'A' + i;
-          WCHAR volume_name[MAX_PATH + 1];
-          if ((*volume_name_func_)(drive.c_str(), volume_name, MAX_PATH + 1)) {
-            BrowserThread::PostTask(
-                BrowserThread::FILE, FROM_HERE,
-                base::Bind(&MediaDeviceNotificationsWindowWin::
-                    CheckDeviceTypeOnFileThread, this, i,
-                    FilePath::StringType(volume_name), FilePath(drive)));
+      PDEV_BROADCAST_HDR dev_broadcast_hdr =
+          reinterpret_cast<PDEV_BROADCAST_HDR>(data);
+      if (dev_broadcast_hdr->dbch_devicetype == DBT_DEVTYP_VOLUME) {
+        DWORD unitmask = GetVolumeBitMaskFromBroadcastHeader(data);
+        for (int i = 0; unitmask; ++i, unitmask >>= 1) {
+          if (unitmask & 0x01) {
+            FilePath::StringType drive(L"_:\\");
+            drive[0] = L'A' + i;
+            WCHAR volume_name[MAX_PATH + 1];
+            if ((*volume_name_func_)(drive.c_str(), volume_name, MAX_PATH + 1)) {
+              BrowserThread::PostTask(
+                  BrowserThread::FILE, FROM_HERE,
+                  base::Bind(&MediaDeviceNotificationsWindowWin::
+                      CheckDeviceTypeOnFileThread, this, i,
+                      FilePath::StringType(volume_name), FilePath(drive)));
+            }
           }
         }
+      } 
+#if defined(DBT_DEVTYP_DEVICEINTERFACE)
+      else if (dev_broadcast_hdr != NULL &&
+                 dev_broadcast_hdr->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {
+        GUID guidDevInterface            = GUID_NULL;
+        CLSIDFromString(WPDDevInterfaceGUID, &guidDevInterface);
+        DEV_BROADCAST_DEVICEINTERFACE* pdbi =
+            reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE*>(data);
+        if (!IsEqualGUID(pdbi->dbcc_classguid, guidDevInterface))
+          return 0;
+        ProcessMediaDeviceAttachedOnUIThread(1, FilePath::StringType(pdbi->dbcc_name), FilePath(pdbi->dbcc_name));    
       }
+#endif
       break;
     }
     case DBT_DEVICEREMOVECOMPLETE: {
       DWORD unitmask = GetVolumeBitMaskFromBroadcastHeader(data);
       for (int i = 0; unitmask; ++i, unitmask >>= 1) {
         if (unitmask & 0x01) {
           base::SystemMonitor* monitor = base::SystemMonitor::Get();
           monitor->ProcessMediaDeviceDetached(i);
         }
       }
+      // FIX for MTP Device.
       break;
     }
   }
   return TRUE;
 }
 
 void MediaDeviceNotificationsWindowWin::CheckDeviceTypeOnFileThread(
     unsigned int id,
     const FilePath::StringType& device_name,
     const FilePath& path) {
@@ skipping 32 matching lines @@
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 // static
 LRESULT CALLBACK MediaDeviceNotificationsWindowWin::WndProcThunk(
     HWND hwnd,
     UINT message,
     WPARAM wparam,
     LPARAM lparam) {
+#if defined(DBT_DEVTYP_DEVICEINTERFACE) && defined(DEVICE_NOTIFY_WINDOW_HANDLE)
+  if (message == WM_CREATE) {    
+    GUID guidDevInterface            = GUID_NULL;
+    HRESULT hr = CLSIDFromString(WPDDevInterfaceGUID, &guidDevInterface);
+    if (SUCCEEDED(hr)) {
+      static HDEVNOTIFY hDeviceNotify;
+      DEV_BROADCAST_DEVICEINTERFACE db = {0};
+      db.dbcc_size = sizeof(db);
+      db.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+      db.dbcc_classguid  = guidDevInterface;
+      hDeviceNotify = RegisterDeviceNotification(hwnd, &db, DEVICE_NOTIFY_WINDOW_HANDLE);

[kinuko, 2012/07/18 10:33:24]

nit: over 80 cols (here and elsewhere; maybe you can run cpplint)

+    }
+  }
+#endif
+
   MediaDeviceNotificationsWindowWin* msg_wnd =
       reinterpret_cast<MediaDeviceNotificationsWindowWin*>(
           GetWindowLongPtr(hwnd, GWLP_USERDATA));
   if (msg_wnd)
     return msg_wnd->WndProc(hwnd, message, wparam, lparam);
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 }  // namespace chrome