Clean up HID backend and API.

device/hid/hid_service_win.cc

-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Copyright 2014 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 "device/hid/hid_service_win.h"
 
 #include <cstdlib>
-#include <string>
 
-#include "base/callback_helpers.h"
-#include "base/lazy_instance.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/sys_string_conversions.h"
-#include "device/hid/hid_connection.h"
 #include "device/hid/hid_connection_win.h"
-#include "device/hid/hid_service.h"
+#include "device/hid/hid_device_info.h"
 #include "net/base/io_buffer.h"
 
 #if defined(OS_WIN)
 
 #define INITGUID
 
 #include <windows.h>
 #include <hidclass.h>
 
 extern "C" {
@@ skipping 13 matching lines @@
 #pragma comment(lib, "setupapi.lib")
 #pragma comment(lib, "hid.lib")
 
 namespace device {
 namespace {
 
 const char kHIDClass[] = "HIDClass";
 
 }  // namespace
 
-HidServiceWin::HidServiceWin() {
-  initialized_ = Enumerate();
-}
+HidServiceWin::HidServiceWin() { Enumerate(); }
+
 HidServiceWin::~HidServiceWin() {}
 
-bool HidServiceWin::Enumerate() {
+void HidServiceWin::Enumerate() {
   BOOL res;
   HDEVINFO device_info_set;
   SP_DEVINFO_DATA devinfo_data;
   SP_DEVICE_INTERFACE_DATA device_interface_data;
 
   memset(&devinfo_data, 0, sizeof(SP_DEVINFO_DATA));
   devinfo_data.cbSize = sizeof(SP_DEVINFO_DATA);
   device_interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
   device_info_set = SetupDiGetClassDevs(
       &GUID_DEVINTERFACE_HID,
       NULL,
       NULL,
       DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
 
   if (device_info_set == INVALID_HANDLE_VALUE)
-    return false;
+    return;
 
   for (int device_index = 0;
       SetupDiEnumDeviceInterfaces(device_info_set,
                                   NULL,
                                   &GUID_DEVINTERFACE_HID,
                                   device_index,
                                   &device_interface_data);
       device_index++) {
     DWORD required_size = 0;
 
@@ skipping 40 matching lines @@
         char driver_name[256] = {0};
         // Get bounded driver.
         res = SetupDiGetDeviceRegistryPropertyA(device_info_set,
                                                 &devinfo_data,
                                                 SPDRP_DRIVER,
                                                 NULL,
                                                 (PBYTE) driver_name,
                                                 sizeof(driver_name) - 1,
                                                 NULL);
         if (res) {
-          // Found the drive.
+          // Found the driver.
           break;
         }
       }
     }
 
     if (!res)
       continue;
 
     PlatformAddDevice(device_interface_detail_data->DevicePath);
   }
-
-  return true;
 }
 
-void HidServiceWin::PlatformAddDevice(std::string device_path) {
+void HidServiceWin::PlatformAddDevice(const std::string& device_path) {
   HidDeviceInfo device_info;
-  device_info.device_id = device_path;
+  device_info.device_id = GenerateDeviceId();
 
   // Try to open the device.
   base::win::ScopedHandle device_handle(
       CreateFileA(device_path.c_str(),
                   0,
                   FILE_SHARE_READ | FILE_SHARE_WRITE,
                   NULL,
                   OPEN_EXISTING,
                   FILE_FLAG_OVERLAPPED,
                   0));
@@ skipping 45 matching lines @@
                                  sizeof(str_property))) {
     device_info.serial_number = base::SysWideToUTF8(str_property);
   }
 
   if (HidD_GetProductString(device_handle.Get(),
                             str_property,
                             sizeof(str_property))) {
     device_info.product_name = base::SysWideToUTF8(str_property);
   }
 
-  HidService::AddDevice(device_info);
+  if (!platform_resource_map_.Add(device_info.device_id, device_path))
+    return;
+  AddDevice(device_info);
 }
 
-void HidServiceWin::PlatformRemoveDevice(std::string device_path) {
-  HidService::RemoveDevice(device_path);
+void HidServiceWin::PlatformRemoveDevice(const std::string& device_path) {
+  HidDeviceId device_id;
+  if (!platform_resource_map_.GetIdByResource(device_path, &device_id))
+    return;
+  platform_resource_map_.RemoveById(device_id);
+  RemoveDevice(device_id);
 }
 
 void HidServiceWin::GetDevices(std::vector<HidDeviceInfo>* devices) {
   Enumerate();
   HidService::GetDevices(devices);
 }
 
-scoped_refptr<HidConnection> HidServiceWin::Connect(std::string device_id) {
-  if (!ContainsKey(devices_, device_id)) return NULL;
+scoped_refptr<HidConnection> HidServiceWin::Connect(HidDeviceId device_id) {
+  HidDeviceInfo device_info;
+  if (!GetInfo(device_id, &device_info))
+    return NULL;
+
+  std::string device_path;
+  if (!platform_resource_map_.GetResourceById(device_id, &device_path))
+    return NULL;
+
   scoped_refptr<HidConnectionWin> connection(
-      new HidConnectionWin(devices_[device_id]));
+      new HidConnectionWin(device_info, device_path));
   if (!connection->available()) {
     LOG_GETLASTERROR(ERROR) << "Failed to open device.";
     return NULL;
   }
   return connection;
 }
 
 }  // namespace device