[Win, MediaGallery] Enumerate and handle mtp device attach/detach events.

chrome/browser/system_monitor/removable_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/system_monitor/removable_device_notifications_window_win.h"
 
 #include <windows.h>
 #include <dbt.h>
 #include <fileapi.h>
 
 #include "base/file_path.h"
 #include "base/win/wrapped_window_proc.h"
 #include "chrome/browser/system_monitor/media_storage_util.h"
+#include "chrome/browser/system_monitor/removable_device_constants.h"
 
 using base::SystemMonitor;
 using base::win::WrappedWindowProc;
 
 namespace chrome {
 
 namespace {
 
 const char16 kWindowClassName[] = L"Chrome_RemovableDeviceNotificationWindow";
 
 RemovableDeviceNotificationsWindowWin*
     g_removable_device_notifications_window_win = NULL;
 
 }  // namespace
 
 // static
 RemovableDeviceNotificationsWindowWin*
 RemovableDeviceNotificationsWindowWin::Create() {
-  return new RemovableDeviceNotificationsWindowWin(new VolumeMountWatcherWin());
+  return new RemovableDeviceNotificationsWindowWin(
+      new VolumeMountWatcherWin(), new PortableDeviceWatcherWin());
 }
 
 RemovableDeviceNotificationsWindowWin::
 RemovableDeviceNotificationsWindowWin(
-    VolumeMountWatcherWin* volume_mount_watcher)
+    VolumeMountWatcherWin* volume_mount_watcher,
+    PortableDeviceWatcherWin* portable_device_watcher)
     : window_class_(0),
       instance_(NULL),
       window_(NULL),
-      volume_mount_watcher_(volume_mount_watcher) {
+      volume_mount_watcher_(volume_mount_watcher),
+      portable_device_watcher_(portable_device_watcher) {
   DCHECK(volume_mount_watcher_);
+  DCHECK(portable_device_watcher_);
   DCHECK(!g_removable_device_notifications_window_win);
   g_removable_device_notifications_window_win = this;
 }
 
 RemovableDeviceNotificationsWindowWin::
 ~RemovableDeviceNotificationsWindowWin() {
   if (window_)
     DestroyWindow(window_);
 
   if (window_class_)
     UnregisterClass(MAKEINTATOM(window_class_), instance_);
 
   DCHECK_EQ(this, g_removable_device_notifications_window_win);
   g_removable_device_notifications_window_win = NULL;
 }
 
 // static
 RemovableDeviceNotificationsWindowWin*
 RemovableDeviceNotificationsWindowWin::GetInstance() {
   DCHECK(g_removable_device_notifications_window_win);
   return g_removable_device_notifications_window_win;
 }
 
 void RemovableDeviceNotificationsWindowWin::Init() {
   volume_mount_watcher_->Init();
+  portable_device_watcher_->Init();
 
   WNDCLASSEX window_class;
   base::win::InitializeWindowClass(
       kWindowClassName,
       &WrappedWindowProc<RemovableDeviceNotificationsWindowWin::WndProcThunk>,
       0, 0, 0, NULL, NULL, NULL, NULL, NULL,
       &window_class);
   instance_ = window_class.hInstance;
   window_class_ = RegisterClassEx(&window_class);
   DCHECK(window_class_);
@@ skipping 44 matching lines @@
     device_info->device_id = device_id;
     device_info->name = name;
     device_info->location = location;
   }
   return true;
 }
 
 // static
 LRESULT CALLBACK RemovableDeviceNotificationsWindowWin::WndProcThunk(
     HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+  static HDEVNOTIFY hDeviceNotify;

[Peter Kasting, 2012/10/19 21:31:12]

Overriding the WndProc and then looking for specific messages is crufty, and the
use of statics here is fragile.

Instead, have a class that uses the standard cracking macros to intercept
WM_CREATE and WM_CLOSE and can store the HDEVNOTIFY in a member.  See
OmniboxViewWin for an example of a class which uses these sorts of macros.

[kmadhusu, 2012/10/23 23:44:17]

Done. I used SystemMessageWindowWin::DeviceNotifications as a reference and
created RemovableDeviceNotificationsWindowWin::DeviceNotifications class to
register and unregister portable device notifications.

+  if (message == WM_CREATE) {
+    GUID guidDevInterface = GUID_NULL;
+    HRESULT hr = CLSIDFromString(kWPDDevInterfaceGUID, &guidDevInterface);
+    if (SUCCEEDED(hr)) {
+      DEV_BROADCAST_DEVICEINTERFACE db = {0};

[Peter Kasting, 2012/10/19 21:31:12]

Nit: Or just:

      DEV_BROADCAST_DEVICEINTERFACE db = {
          sizeof(DEV_BROADCAST_DEVICEINTERFACE), DBT_DEVTYP_DEVICEINTERFACE, 0,
          guidDevInterface };

[kmadhusu, 2012/10/23 23:44:17]

Done.

+      db.dbcc_size = sizeof(db);
+      db.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+      db.dbcc_classguid = guidDevInterface;
+      hDeviceNotify = RegisterDeviceNotification(hwnd, &db,
+                                                 DEVICE_NOTIFY_WINDOW_HANDLE);
+    }
+  } else if (message == WM_CLOSE) {
+    UnregisterDeviceNotification(hDeviceNotify);
+  }
   RemovableDeviceNotificationsWindowWin* msg_wnd =
       reinterpret_cast<RemovableDeviceNotificationsWindowWin*>(
           GetWindowLongPtr(hwnd, GWLP_USERDATA));
   if (msg_wnd)
     return msg_wnd->WndProc(hwnd, message, wparam, lparam);
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 LRESULT CALLBACK RemovableDeviceNotificationsWindowWin::WndProc(
     HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
   switch (message) {
     case WM_DEVICECHANGE:
       OnDeviceChange(static_cast<UINT>(wparam), lparam);
       return TRUE;
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
 bool RemovableDeviceNotificationsWindowWin::GetDeviceInfo(
     const FilePath& device_path, string16* device_location,
     std::string* unique_id, string16* name, bool* removable) {
-  return volume_mount_watcher_->GetDeviceInfo(device_path, device_location,
-                                              unique_id, name, removable);
+  bool result = volume_mount_watcher_->GetDeviceInfo(device_path,

[Peter Kasting, 2012/10/19 21:31:12]

Nit: Shorter:

  return volume_mount_watcher_->GetDeviceInfo(device_path, device_location,
                                              unique_id, name, removable) ||
      portable_device_watcher_->GetDeviceInfo(device_path, device_location,
                                              unique_id, name, removable);

[kmadhusu, 2012/10/23 23:44:17]

Done.

+                                                     device_location, unique_id,
+                                                     name, removable);
+  if (!result) {
+    result = portable_device_watcher_->GetDeviceInfo(device_path,
+                                                     device_location, unique_id,
+                                                     name, removable);
+  }
+  return result;
 }
 
 void RemovableDeviceNotificationsWindowWin::OnDeviceChange(UINT event_type,
                                                            LPARAM data) {
   volume_mount_watcher_->OnWindowMessage(event_type, data);
+  portable_device_watcher_->OnWindowMessage(event_type, data);
 }
 
 }  // namespace chrome