device/core/device_monitor_win.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "device/core/device_monitor_win.h"
   6
   7 #include <dbt.h>
   8 #include <map>
   9 #include <windows.h>
  10
  11 #include "base/at_exit.h"
  12 #include "base/bind.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/sys_string_conversions.h"
  15 #include "base/win/message_window.h"
  16
  17 namespace device {
  18
  19 class DeviceMonitorMessageWindow;
  20
  21 namespace {
  22
  23 const wchar_t kWindowClassName[] = L"DeviceMonitorMessageWindow";
  24 DeviceMonitorMessageWindow* g_message_window;
  25
  26 // Provides basic comparability for GUIDs so that they can be used as keys to an
  27 // STL map.
  28 struct CompareGUID {
  29   bool operator()(const GUID& a, const GUID& b) const {
  30     return memcmp(&a, &b, sizeof a) < 0;
  31   }
  32 };
  33 }
  34
  35 // This singleton class manages a shared message window for all registered
  36 // device notification observers. It vends one instance of DeviceManagerWin for
  37 // each unique GUID it sees.
  38 class DeviceMonitorMessageWindow {
  39  public:
  40   static DeviceMonitorMessageWindow* GetInstance() {
  41     if (!g_message_window) {
  42       g_message_window = new DeviceMonitorMessageWindow();
  43       if (g_message_window->Init()) {
  44         base::AtExitManager::RegisterTask(
  45           base::Bind(&base::DeletePointer<DeviceMonitorMessageWindow>,
  46                      base::Unretained(g_message_window)));
  47       } else {
  48         delete g_message_window;
  49         g_message_window = nullptr;
  50       }
  51     }
  52     return g_message_window;
  53   }
  54
  55   DeviceMonitorWin* GetForDeviceInterface(const GUID& device_interface) {
  56     scoped_ptr<DeviceMonitorWin>& device_monitor =
  57         device_monitors_[device_interface];
  58     if (!device_monitor) {
  59       device_monitor.reset(new DeviceMonitorWin());
  60     }
  61     return device_monitor.get();
  62   }
  63
  64   DeviceMonitorWin* GetForAllInterfaces() { return &all_device_monitor_; }
  65
  66  private:
  67   friend void base::DeletePointer<DeviceMonitorMessageWindow>(
  68       DeviceMonitorMessageWindow* message_window);
  69
  70   DeviceMonitorMessageWindow() {
  71   }
  72
  73   ~DeviceMonitorMessageWindow() {
  74     if (notify_handle_) {
  75       UnregisterDeviceNotification(notify_handle_);
  76     }
  77   }
  78
  79   bool Init() {
  80     window_.reset(new base::win::MessageWindow());
  81     if (!window_->CreateNamed(
  82             base::Bind(&DeviceMonitorMessageWindow::HandleMessage,
  83                        base::Unretained(this)),
  84             base::string16(kWindowClassName))) {
  85       LOG(ERROR) << "Failed to create message window: " << kWindowClassName;
  86       return false;
  87     }
  88
  89     DEV_BROADCAST_DEVICEINTERFACE db = {sizeof(DEV_BROADCAST_DEVICEINTERFACE),
  90                                         DBT_DEVTYP_DEVICEINTERFACE};
  91     notify_handle_ = RegisterDeviceNotification(
  92         window_->hwnd(), &db,
  93         DEVICE_NOTIFY_WINDOW_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);
  94     if (!notify_handle_) {
  95       PLOG(ERROR) << "Failed to register for device notifications";
  96       return false;
  97     }
  98
  99     return true;
 100   }
 101
 102   bool HandleMessage(UINT message,
 103                      WPARAM wparam,
 104                      LPARAM lparam,
 105                      LRESULT* result) {
 106     if (message == WM_DEVICECHANGE) {
 107       DeviceMonitorWin* device_monitor = nullptr;
 108       DEV_BROADCAST_DEVICEINTERFACE* db =
 109           reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE*>(lparam);
 110       const auto& map_entry = device_monitors_.find(db->dbcc_classguid);
 111       if (map_entry != device_monitors_.end()) {
 112         device_monitor = map_entry->second.get();
 113       }
 114
 115       std::string device_path(base::SysWideToUTF8(db->dbcc_name));
 116       DCHECK(base::IsStringASCII(device_path));
 117       device_path = base::ToLowerASCII(device_path);
 118
 119       if (wparam == DBT_DEVICEARRIVAL) {
 120         if (device_monitor) {
 121           device_monitor->NotifyDeviceAdded(db->dbcc_classguid, device_path);
 122         }
 123         all_device_monitor_.NotifyDeviceAdded(db->dbcc_classguid, device_path);
 124       } else if (wparam == DBT_DEVICEREMOVECOMPLETE) {
 125         if (device_monitor) {
 126           device_monitor->NotifyDeviceRemoved(db->dbcc_classguid, device_path);
 127         }
 128         all_device_monitor_.NotifyDeviceRemoved(db->dbcc_classguid,
 129                                                 device_path);
 130       } else {
 131         return false;
 132       }
 133       *result = NULL;
 134       return true;
 135     }
 136     return false;
 137   }
 138
 139   std::map<GUID, scoped_ptr<DeviceMonitorWin>, CompareGUID> device_monitors_;
 140   DeviceMonitorWin all_device_monitor_;
 141   scoped_ptr<base::win::MessageWindow> window_;
 142   HDEVNOTIFY notify_handle_ = NULL;
 143
 144   DISALLOW_COPY_AND_ASSIGN(DeviceMonitorMessageWindow);
 145 };
 146
 147 void DeviceMonitorWin::Observer::OnDeviceAdded(const GUID& class_guid,
 148                                                const std::string& device_path) {
 149 }
 150
 151 void DeviceMonitorWin::Observer::OnDeviceRemoved(
 152     const GUID& class_guid,
 153     const std::string& device_path) {
 154 }
 155
 156 // static
 157 DeviceMonitorWin* DeviceMonitorWin::GetForDeviceInterface(
 158     const GUID& device_interface) {
 159   DeviceMonitorMessageWindow* message_window =
 160       DeviceMonitorMessageWindow::GetInstance();
 161   if (message_window) {
 162     return message_window->GetForDeviceInterface(device_interface);
 163   }
 164   return nullptr;
 165 }
 166
 167 // static
 168 DeviceMonitorWin* DeviceMonitorWin::GetForAllInterfaces() {
 169   DeviceMonitorMessageWindow* message_window =
 170       DeviceMonitorMessageWindow::GetInstance();
 171   if (message_window) {
 172     return message_window->GetForAllInterfaces();
 173   }
 174   return nullptr;
 175 }
 176
 177 DeviceMonitorWin::~DeviceMonitorWin() {
 178 }
 179
 180 void DeviceMonitorWin::AddObserver(Observer* observer) {
 181   observer_list_.AddObserver(observer);
 182 }
 183
 184 void DeviceMonitorWin::RemoveObserver(Observer* observer) {
 185   observer_list_.RemoveObserver(observer);
 186 }
 187
 188 DeviceMonitorWin::DeviceMonitorWin() {
 189 }
 190
 191 void DeviceMonitorWin::NotifyDeviceAdded(const GUID& class_guid,
 192                                          const std::string& device_path) {
 193   FOR_EACH_OBSERVER(Observer, observer_list_,
 194                     OnDeviceAdded(class_guid, device_path));
 195 }
 196
 197 void DeviceMonitorWin::NotifyDeviceRemoved(const GUID& class_guid,
 198                                            const std::string& device_path) {
 199   FOR_EACH_OBSERVER(Observer, observer_list_,
 200                     OnDeviceRemoved(class_guid, device_path));
 201 }
 202
 203 }  // namespace device