Revert of Add code to deal with serial device disconnection detection on Windows

device/usb/usb_service_impl.cc

 // 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/usb/usb_service_impl.h"
 
 #include <list>
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_error.h"
 #include "device/usb/webusb_descriptors.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_WIN)
 #include <setupapi.h>
 #include <usbiodef.h>
 
 #include "base/strings/string_util.h"
-#include "device/core/device_info_query_win.h"
 #endif  // OS_WIN
 
 #if defined(USE_UDEV)
 #include "device/udev_linux/scoped_udev.h"
 #endif  // USE_UDEV
 
 using net::IOBufferWithSize;
 
 namespace device {
 
 namespace {
 
 // Standard USB requests and descriptor types:
 const uint16_t kUsbVersion2_1 = 0x0210;
 const uint8_t kGetDescriptorRequest = 0x06;
 const uint8_t kStringDescriptorType = 0x03;
 const uint8_t kBosDescriptorType = 0x0F;
 
 // WebUSB requests:
 const uint8_t kGetAllowedOriginsRequest = 0x01;
 const uint8_t kGetLandingPageRequest = 0x02;
 
 const int kControlTransferTimeout = 60000;  // 1 minute
 
 #if defined(OS_WIN)
 
+// Wrapper around a HDEVINFO that automatically destroys it.
+class ScopedDeviceInfoList {
+ public:
+  explicit ScopedDeviceInfoList(HDEVINFO handle) : handle_(handle) {}
+
+  ~ScopedDeviceInfoList() {
+    if (valid()) {
+      SetupDiDestroyDeviceInfoList(handle_);
+    }
+  }
+
+  bool valid() { return handle_ != INVALID_HANDLE_VALUE; }
+
+  HDEVINFO get() { return handle_; }
+
+ private:
+  HDEVINFO handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedDeviceInfoList);
+};
+
+// Wrapper around an SP_DEVINFO_DATA that initializes it properly and
+// automatically deletes it.
+class ScopedDeviceInfo {
+ public:
+  ScopedDeviceInfo() {
+    memset(&dev_info_data_, 0, sizeof(dev_info_data_));
+    dev_info_data_.cbSize = sizeof(dev_info_data_);
+  }
+
+  ~ScopedDeviceInfo() {
+    if (dev_info_set_ != INVALID_HANDLE_VALUE) {
+      SetupDiDeleteDeviceInfo(dev_info_set_, &dev_info_data_);
+    }
+  }
+
+  // Once the SP_DEVINFO_DATA has been populated it must be freed using the
+  // HDEVINFO it was created from.
+  void set_valid(HDEVINFO dev_info_set) {
+    DCHECK(dev_info_set_ == INVALID_HANDLE_VALUE);
+    DCHECK(dev_info_set != INVALID_HANDLE_VALUE);
+    dev_info_set_ = dev_info_set;
+  }
+
+  PSP_DEVINFO_DATA get() { return &dev_info_data_; }
+
+ private:
+  HDEVINFO dev_info_set_ = INVALID_HANDLE_VALUE;
+  SP_DEVINFO_DATA dev_info_data_;
+};
+
 bool IsWinUsbInterface(const std::string& device_path) {
-  DeviceInfoQueryWin device_info_query;
-  if (!device_info_query.device_info_list_valid()) {
+  ScopedDeviceInfoList dev_info_list(SetupDiCreateDeviceInfoList(NULL, NULL));
+  if (!dev_info_list.valid()) {
     USB_PLOG(ERROR) << "Failed to create a device information set";
     return false;
   }
 
-  // This will add the device so we can query driver info.
-  if (!device_info_query.AddDevice(device_path.c_str())) {
+  // This will add the device to |dev_info_list| so we can query driver info.
+  if (!SetupDiOpenDeviceInterfaceA(dev_info_list.get(), device_path.c_str(), 0,
+                                   NULL)) {
     USB_PLOG(ERROR) << "Failed to get device interface data for "
                     << device_path;
     return false;
   }
 
-  if (!device_info_query.GetDeviceInfo()) {
+  ScopedDeviceInfo dev_info;
+  if (!SetupDiEnumDeviceInfo(dev_info_list.get(), 0, dev_info.get())) {
     USB_PLOG(ERROR) << "Failed to get device info for " << device_path;
     return false;
   }
+  dev_info.set_valid(dev_info_list.get());
 
-  std::string buffer;
-  if (!device_info_query.GetDeviceStringProperty(SPDRP_SERVICE, &buffer)) {
+  DWORD reg_data_type;
+  BYTE buffer[256];
+  if (!SetupDiGetDeviceRegistryPropertyA(dev_info_list.get(), dev_info.get(),
+                                         SPDRP_SERVICE, &reg_data_type,
+                                         &buffer[0], sizeof buffer, NULL)) {
     USB_PLOG(ERROR) << "Failed to get device service property";
     return false;
   }
+  if (reg_data_type != REG_SZ) {
+    USB_LOG(ERROR) << "Unexpected data type for driver service: "
+                   << reg_data_type;
+    return false;
+  }
 
   USB_LOG(DEBUG) << "Driver for " << device_path << " is " << buffer << ".";
-  if (base::StartsWith(buffer, "WinUSB", base::CompareCase::INSENSITIVE_ASCII))
+  if (base::StartsWith(reinterpret_cast<const char*>(buffer), "WinUSB",
+                       base::CompareCase::INSENSITIVE_ASCII))
     return true;
   return false;
 }
 
 #endif  // OS_WIN
 
 void GetDeviceListOnBlockingThread(
     const std::string& new_device_path,
     scoped_refptr<UsbContext> usb_context,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
@@ skipping 697 matching lines @@
   PlatformDeviceMap::iterator it = platform_devices_.find(platform_device);
   if (it != platform_devices_.end()) {
     RemoveDevice(it->second);
   } else {
     devices_being_enumerated_.erase(platform_device);
   }
   libusb_unref_device(platform_device);
 }
 
 }  // namespace device