services/device/serial/serial_device_enumerator_win.cc - chromium/src.git - Git at Google

 // Copyright 2014 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "services/device/serial/serial_device_enumerator_win.h"

 #include <windows.h>  // Must be in front of other Windows header files.

 #define INITGUID
 #include <devguid.h>
 #include <devpkey.h>
 #include <ntddser.h>
 #include <setupapi.h>
 #include <stdint.h>

 #include <algorithm>
 #include <memory>
 #include <string>
 #include <string_view>
 #include <utility>

 #include "base/containers/contains.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/scoped_generic.h"
 #include "base/scoped_observation.h"
 #include "base/sequence_checker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/task/single_thread_task_runner.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_devinfo.h"
 #include "components/device_event_log/device_event_log.h"
 #include "third_party/re2/src/re2/re2.h"

 namespace device {

 namespace {

 std::optional<std::string> GetProperty(HDEVINFO dev_info,
                                        SP_DEVINFO_DATA* dev_info_data,
                                        const DEVPROPKEY& property) {
   // SetupDiGetDeviceProperty() makes an RPC which may block.
   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
                                                 base::BlockingType::MAY_BLOCK);

   DEVPROPTYPE property_type;
   DWORD required_size;
   if (SetupDiGetDeviceProperty(dev_info, dev_info_data, &property,
                                &property_type, /*PropertyBuffer=*/nullptr,
                                /*PropertyBufferSize=*/0, &required_size,
                                /*Flags=*/0) ||
       GetLastError() != ERROR_INSUFFICIENT_BUFFER ||
       property_type != DEVPROP_TYPE_STRING) {
     return std::nullopt;
   }

   std::wstring buffer;
   if (!SetupDiGetDeviceProperty(
           dev_info, dev_info_data, &property, &property_type,
           reinterpret_cast<PBYTE>(base::WriteInto(&buffer, required_size)),
           required_size, /*RequiredSize=*/nullptr, /*Flags=*/0)) {
     return std::nullopt;
   }

   return base::WideToUTF8(buffer);
 }

 // Get the port name from the registry.
 std::optional<std::string> GetPortName(HDEVINFO dev_info,
                                        SP_DEVINFO_DATA* dev_info_data) {
   HKEY key = SetupDiOpenDevRegKey(dev_info, dev_info_data, DICS_FLAG_GLOBAL, 0,
                                   DIREG_DEV, KEY_READ);
   if (key == INVALID_HANDLE_VALUE) {
     SERIAL_PLOG(ERROR) << "Could not open device registry key";
     return std::nullopt;
   }
   base::win::RegKey scoped_key(key);

   std::wstring port_name;
   LONG result = scoped_key.ReadValue(L"PortName", &port_name);
   if (result != ERROR_SUCCESS) {
     SERIAL_LOG(ERROR) << "Failed to read port name: "
                       << logging::SystemErrorCodeToString(result);
     return std::nullopt;
   }

   return base::SysWideToUTF8(port_name);
 }

 // Deduce the path for the device from the port name.
 base::FilePath GetPath(std::string port_name) {
   // For COM numbers less than 9, CreateFile is called with a string such as
   // "COM1". For numbers greater than 9, a prefix of "\\.\" must be added.
   if (port_name.length() > std::string_view("COM9").length()) {
     return base::FilePath(LR"(\\.\)").AppendASCII(port_name);
   }

   return base::FilePath::FromUTF8Unsafe(port_name);
 }

 // Searches for the display name in the device's friendly name. Returns nullopt
 // if the name does not match the expected pattern.
 std::optional<std::string> GetDisplayName(const std::string& friendly_name) {
   std::string display_name;
   if (!RE2::PartialMatch(friendly_name, R"((.*) \(COM[0-9]+\))",
                          &display_name)) {
     return std::nullopt;
   }
   return display_name;
 }

 // Searches for the vendor ID in the device's instance ID. Returns nullopt if
 // the instance ID does not match the expected pattern.
 std::optional<uint32_t> GetVendorID(const std::string& instance_id) {
   std::string vendor_id_str;
   if (!RE2::PartialMatch(instance_id, "VID_([0-9a-fA-F]+)", &vendor_id_str)) {
     return std::nullopt;
   }

   uint32_t vendor_id;
   if (!base::HexStringToUInt(vendor_id_str, &vendor_id)) {
     return std::nullopt;
   }

   return vendor_id;
 }

 // Searches for the product ID in the device's instance ID. Returns nullopt if
 // the instance ID does not match the expected pattern.
 std::optional<uint32_t> GetProductID(const std::string& instance_id) {
   std::string product_id_str;
   if (!RE2::PartialMatch(instance_id, "PID_([0-9a-fA-F]+)", &product_id_str)) {
     return std::nullopt;
   }

   uint32_t product_id;
   if (!base::HexStringToUInt(product_id_str, &product_id)) {
     return std::nullopt;
   }

   return product_id;
 }

 }  // namespace

 class SerialDeviceEnumeratorWin::UiThreadHelper
     : public DeviceMonitorWin::Observer {
  public:
   UiThreadHelper(base::WeakPtr<SerialDeviceEnumeratorWin> enumerator,
                  scoped_refptr<base::SequencedTaskRunner> task_runner)
       : enumerator_(std::move(enumerator)),
         task_runner_(std::move(task_runner)) {
     // Note that this uses GUID_DEVINTERFACE_COMPORT even though we use
     // GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR for enumeration because it
     // doesn't seem to make a difference and ports which aren't enumerable by
     // device interface don't generate WM_DEVICECHANGE events.
     device_observation_.Observe(
         DeviceMonitorWin::GetForDeviceInterface(GUID_DEVINTERFACE_COMPORT));
   }

   // Disallow copy and assignment.
   UiThreadHelper(UiThreadHelper&) = delete;
   UiThreadHelper& operator=(UiThreadHelper&) = delete;

   virtual ~UiThreadHelper() {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   }

   void OnDeviceAdded(const GUID& class_guid,
                      const std::wstring& device_path) override {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&SerialDeviceEnumeratorWin::OnPathAdded,
                                   enumerator_, device_path));
   }

   void OnDeviceRemoved(const GUID& class_guid,
                        const std::wstring& device_path) override {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&SerialDeviceEnumeratorWin::OnPathRemoved,
                                   enumerator_, device_path));
   }

  private:
   SEQUENCE_CHECKER(sequence_checker_);

   // Weak reference to the SerialDeviceEnumeratorWin that owns this object.
   // Calls on |enumerator_| must be posted to |task_runner_|.
   base::WeakPtr<SerialDeviceEnumeratorWin> enumerator_;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;

   base::ScopedObservation<DeviceMonitorWin, DeviceMonitorWin::Observer>
       device_observation_{this};
 };

 SerialDeviceEnumeratorWin::SerialDeviceEnumeratorWin(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   helper_ = base::SequenceBound<UiThreadHelper>(
       std::move(ui_task_runner), weak_factory_.GetWeakPtr(),
       base::SequencedTaskRunner::GetCurrentDefault());

   DoInitialEnumeration();
 }

 SerialDeviceEnumeratorWin::~SerialDeviceEnumeratorWin() = default;

 void SerialDeviceEnumeratorWin::OnPathAdded(const std::wstring& device_path) {
   base::win::ScopedDevInfo dev_info(
       SetupDiCreateDeviceInfoList(nullptr, nullptr));
   if (!dev_info.is_valid())
     return;

   if (!SetupDiOpenDeviceInterface(dev_info.get(), device_path.c_str(), 0,
                                   nullptr)) {
     return;
   }

   SP_DEVINFO_DATA dev_info_data = {};
   dev_info_data.cbSize = sizeof(dev_info_data);
   if (!SetupDiEnumDeviceInfo(dev_info.get(), 0, &dev_info_data))
     return;

   EnumeratePort(dev_info.get(), &dev_info_data, /*check_port_name=*/false);
 }

 void SerialDeviceEnumeratorWin::OnPathRemoved(const std::wstring& device_path) {
   base::win::ScopedDevInfo dev_info(
       SetupDiCreateDeviceInfoList(nullptr, nullptr));
   if (!dev_info.is_valid())
     return;

   if (!SetupDiOpenDeviceInterface(dev_info.get(), device_path.c_str(), 0,
                                   nullptr)) {
     return;
   }

   SP_DEVINFO_DATA dev_info_data = {};
   dev_info_data.cbSize = sizeof(dev_info_data);
   if (!SetupDiEnumDeviceInfo(dev_info.get(), 0, &dev_info_data))
     return;

   std::optional<std::string> port_name =
       GetPortName(dev_info.get(), &dev_info_data);
   if (!port_name)
     return;

   auto it = paths_.find(GetPath(*port_name));
   if (it == paths_.end())
     return;

   base::UnguessableToken token = it->second;

   paths_.erase(it);
   RemovePort(token);
 }

 void SerialDeviceEnumeratorWin::DoInitialEnumeration() {
   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
                                                 base::BlockingType::MAY_BLOCK);

   // On Windows 10 and above most COM port drivers register using the COMPORT
   // device interface class. Try to enumerate these first.
   {
     base::win::ScopedDevInfo dev_info;
     dev_info.reset(SetupDiGetClassDevs(&GUID_DEVINTERFACE_COMPORT, nullptr, 0,
                                        DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));
     if (!dev_info.is_valid())
       return;

     SP_DEVINFO_DATA dev_info_data = {.cbSize = sizeof(dev_info_data)};
     for (DWORD i = 0; SetupDiEnumDeviceInfo(dev_info.get(), i, &dev_info_data);
          i++) {
       EnumeratePort(dev_info.get(), &dev_info_data, /*check_port_name=*/false);
     }
   }

   // To detect devices which don't register with GUID_DEVINTERFACE_COMPORT also
   // enuerate all devices in the "Ports" and "Modems" device classes. These must
   // be checked to see if the port name starts with "COM" because it also
   // includes LPT ports.
   constexpr const GUID* kDeviceClasses[] = {&GUID_DEVCLASS_MODEM,
                                             &GUID_DEVCLASS_PORTS};
   for (const GUID* guid : kDeviceClasses) {
     base::win::ScopedDevInfo dev_info;
     dev_info.reset(SetupDiGetClassDevs(guid, nullptr, 0, DIGCF_PRESENT));
     if (!dev_info.is_valid())
       return;

     SP_DEVINFO_DATA dev_info_data = {.cbSize = sizeof(dev_info_data)};
     for (DWORD i = 0; SetupDiEnumDeviceInfo(dev_info.get(), i, &dev_info_data);
          i++) {
       EnumeratePort(dev_info.get(), &dev_info_data, /*check_port_name=*/true);
     }
   }
 }

 void SerialDeviceEnumeratorWin::EnumeratePort(HDEVINFO dev_info,
                                               SP_DEVINFO_DATA* dev_info_data,
                                               bool check_port_name) {
   std::optional<std::string> port_name = GetPortName(dev_info, dev_info_data);
   if (!port_name)
     return;

   if (check_port_name && !base::StartsWith(*port_name, "COM"))
     return;

   // Check whether the currently enumerating port has been seen before since
   // the method above will generate duplicate enumerations for some ports.
   base::FilePath path = GetPath(*port_name);
   if (base::Contains(paths_, path))
     return;

   std::optional<std::string> instance_id =
       GetProperty(dev_info, dev_info_data, DEVPKEY_Device_InstanceId);
   if (!instance_id)
     return;

   // Some versions of Windows pad this string with a variable number of NUL
   // bytes for no discernible reason.
   instance_id = std::string(base::TrimString(
       *instance_id, std::string_view("\0", 1), base::TRIM_TRAILING));

   base::UnguessableToken token = base::UnguessableToken::Create();
   auto info = mojom::SerialPortInfo::New();
   info->token = token;
   info->path = path;
   info->device_instance_id = *instance_id;

   // TODO(crbug.com/40653536): While the "bus reported device
   // description" is usually the USB product string this is still up to the
   // individual serial driver and could be equal to the "friendly name". It
   // would be more reliable to read the real USB strings here.
   info->display_name = GetProperty(dev_info, dev_info_data,
                                    DEVPKEY_Device_BusReportedDeviceDesc);
   if (info->display_name) {
     // This string is also sometimes padded with a variable number of NUL bytes
     // for no discernible reason.
     info->display_name = std::string(base::TrimString(
         *info->display_name, std::string_view("\0", 1), base::TRIM_TRAILING));
   } else {
     // Fall back to the "friendly name" if no "bus reported device description"
     // is available. This name will likely be the same for all devices using the
     // same driver.
     std::optional<std::string> friendly_name =
         GetProperty(dev_info, dev_info_data, DEVPKEY_Device_FriendlyName);
     if (!friendly_name)
       return;

     info->display_name = GetDisplayName(*friendly_name);
   }

   // The instance ID looks like "FTDIBUS\VID_0403+PID_6001+A703X87GA\0000".
   std::optional<uint32_t> vendor_id = GetVendorID(*instance_id);
   std::optional<uint32_t> product_id = GetProductID(*instance_id);
   std::optional<std::string> vendor_id_str, product_id_str;
   if (vendor_id) {
     info->has_vendor_id = true;
     info->vendor_id = *vendor_id;
     vendor_id_str = base::StringPrintf("%04X", *vendor_id);
   }
   if (product_id) {
     info->has_product_id = true;
     info->product_id = *product_id;
     product_id_str = base::StringPrintf("%04X", *product_id);
   }

   SERIAL_LOG(EVENT) << "Serial device added: path=" << info->path
                     << " instance_id=" << info->device_instance_id
                     << " vid=" << vendor_id_str.value_or("(none)")
                     << " pid=" << product_id_str.value_or("(none)");

   paths_.insert(std::make_pair(path, token));
   AddPort(std::move(info));
 }

 }  // namespace device
	// Copyright 2014 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "services/device/serial/serial_device_enumerator_win.h"

	#include <windows.h> // Must be in front of other Windows header files.

	#define INITGUID
	#include <devguid.h>
	#include <devpkey.h>
	#include <ntddser.h>
	#include <setupapi.h>
	#include <stdint.h>

	#include <algorithm>
	#include <memory>
	#include <string>
	#include <string_view>
	#include <utility>

	#include "base/containers/contains.h"
	#include "base/metrics/histogram_functions.h"
	#include "base/scoped_generic.h"
	#include "base/scoped_observation.h"
	#include "base/sequence_checker.h"
	#include "base/strings/string_number_conversions.h"
	#include "base/strings/string_util.h"
	#include "base/strings/stringprintf.h"
	#include "base/strings/sys_string_conversions.h"
	#include "base/strings/utf_string_conversions.h"
	#include "base/task/sequenced_task_runner.h"
	#include "base/task/single_thread_task_runner.h"
	#include "base/threading/scoped_blocking_call.h"
	#include "base/win/registry.h"
	#include "base/win/scoped_devinfo.h"
	#include "components/device_event_log/device_event_log.h"
	#include "third_party/re2/src/re2/re2.h"

	namespace device {

	namespace {

	std::optional<std::string> GetProperty(HDEVINFO dev_info,
	SP_DEVINFO_DATA* dev_info_data,
	const DEVPROPKEY& property) {
	// SetupDiGetDeviceProperty() makes an RPC which may block.
	base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
	base::BlockingType::MAY_BLOCK);

	DEVPROPTYPE property_type;
	DWORD required_size;
	if (SetupDiGetDeviceProperty(dev_info, dev_info_data, &property,
	&property_type, /PropertyBuffer=/nullptr,
	/PropertyBufferSize=/0, &required_size,
	/Flags=/0) \|\|
	GetLastError() != ERROR_INSUFFICIENT_BUFFER \|\|
	property_type != DEVPROP_TYPE_STRING) {
	return std::nullopt;
	}

	std::wstring buffer;
	if (!SetupDiGetDeviceProperty(
	dev_info, dev_info_data, &property, &property_type,
	reinterpret_cast<PBYTE>(base::WriteInto(&buffer, required_size)),
	required_size, /RequiredSize=/nullptr, /Flags=/0)) {
	return std::nullopt;
	}

	return base::WideToUTF8(buffer);
	}

	// Get the port name from the registry.
	std::optional<std::string> GetPortName(HDEVINFO dev_info,
	SP_DEVINFO_DATA* dev_info_data) {
	HKEY key = SetupDiOpenDevRegKey(dev_info, dev_info_data, DICS_FLAG_GLOBAL, 0,
	DIREG_DEV, KEY_READ);
	if (key == INVALID_HANDLE_VALUE) {
	SERIAL_PLOG(ERROR) << "Could not open device registry key";
	return std::nullopt;
	}
	base::win::RegKey scoped_key(key);

	std::wstring port_name;
	LONG result = scoped_key.ReadValue(L"PortName", &port_name);
	if (result != ERROR_SUCCESS) {
	SERIAL_LOG(ERROR) << "Failed to read port name: "
	<< logging::SystemErrorCodeToString(result);
	return std::nullopt;
	}

	return base::SysWideToUTF8(port_name);
	}

	// Deduce the path for the device from the port name.
	base::FilePath GetPath(std::string port_name) {
	// For COM numbers less than 9, CreateFile is called with a string such as
	// "COM1". For numbers greater than 9, a prefix of "\\.\" must be added.
	if (port_name.length() > std::string_view("COM9").length()) {
	return base::FilePath(LR"(\\.\)").AppendASCII(port_name);
	}

	return base::FilePath::FromUTF8Unsafe(port_name);
	}

	// Searches for the display name in the device's friendly name. Returns nullopt
	// if the name does not match the expected pattern.
	std::optional<std::string> GetDisplayName(const std::string& friendly_name) {
	std::string display_name;
	if (!RE2::PartialMatch(friendly_name, R"((.*) \(COM[0-9]+\))",
	&display_name)) {
	return std::nullopt;
	}
	return display_name;
	}

	// Searches for the vendor ID in the device's instance ID. Returns nullopt if
	// the instance ID does not match the expected pattern.
	std::optional<uint32_t> GetVendorID(const std::string& instance_id) {
	std::string vendor_id_str;
	if (!RE2::PartialMatch(instance_id, "VID_([0-9a-fA-F]+)", &vendor_id_str)) {
	return std::nullopt;
	}

	uint32_t vendor_id;
	if (!base::HexStringToUInt(vendor_id_str, &vendor_id)) {
	return std::nullopt;
	}

	return vendor_id;
	}

	// Searches for the product ID in the device's instance ID. Returns nullopt if
	// the instance ID does not match the expected pattern.
	std::optional<uint32_t> GetProductID(const std::string& instance_id) {
	std::string product_id_str;
	if (!RE2::PartialMatch(instance_id, "PID_([0-9a-fA-F]+)", &product_id_str)) {
	return std::nullopt;
	}

	uint32_t product_id;
	if (!base::HexStringToUInt(product_id_str, &product_id)) {
	return std::nullopt;
	}

	return product_id;
	}

	} // namespace

	class SerialDeviceEnumeratorWin::UiThreadHelper
	: public DeviceMonitorWin::Observer {
	public:
	UiThreadHelper(base::WeakPtr<SerialDeviceEnumeratorWin> enumerator,
	scoped_refptr<base::SequencedTaskRunner> task_runner)
	: enumerator_(std::move(enumerator)),
	task_runner_(std::move(task_runner)) {
	// Note that this uses GUID_DEVINTERFACE_COMPORT even though we use
	// GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR for enumeration because it
	// doesn't seem to make a difference and ports which aren't enumerable by
	// device interface don't generate WM_DEVICECHANGE events.
	device_observation_.Observe(
	DeviceMonitorWin::GetForDeviceInterface(GUID_DEVINTERFACE_COMPORT));
	}

	// Disallow copy and assignment.
	UiThreadHelper(UiThreadHelper&) = delete;
	UiThreadHelper& operator=(UiThreadHelper&) = delete;

	virtual ~UiThreadHelper() {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	}

	void OnDeviceAdded(const GUID& class_guid,
	const std::wstring& device_path) override {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	task_runner_->PostTask(
	FROM_HERE, base::BindOnce(&SerialDeviceEnumeratorWin::OnPathAdded,
	enumerator_, device_path));
	}

	void OnDeviceRemoved(const GUID& class_guid,
	const std::wstring& device_path) override {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	task_runner_->PostTask(
	FROM_HERE, base::BindOnce(&SerialDeviceEnumeratorWin::OnPathRemoved,
	enumerator_, device_path));
	}

	private:
	SEQUENCE_CHECKER(sequence_checker_);

	// Weak reference to the SerialDeviceEnumeratorWin that owns this object.
	// Calls on \|enumerator_\| must be posted to \|task_runner_\|.
	base::WeakPtr<SerialDeviceEnumeratorWin> enumerator_;
	scoped_refptr<base::SequencedTaskRunner> task_runner_;

	base::ScopedObservation<DeviceMonitorWin, DeviceMonitorWin::Observer>
	device_observation_{this};
	};

	SerialDeviceEnumeratorWin::SerialDeviceEnumeratorWin(
	scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
	helper_ = base::SequenceBound<UiThreadHelper>(
	std::move(ui_task_runner), weak_factory_.GetWeakPtr(),
	base::SequencedTaskRunner::GetCurrentDefault());

	DoInitialEnumeration();
	}

	SerialDeviceEnumeratorWin::~SerialDeviceEnumeratorWin() = default;

	void SerialDeviceEnumeratorWin::OnPathAdded(const std::wstring& device_path) {
	base::win::ScopedDevInfo dev_info(
	SetupDiCreateDeviceInfoList(nullptr, nullptr));
	if (!dev_info.is_valid())
	return;

	if (!SetupDiOpenDeviceInterface(dev_info.get(), device_path.c_str(), 0,
	nullptr)) {
	return;
	}

	SP_DEVINFO_DATA dev_info_data = {};
	dev_info_data.cbSize = sizeof(dev_info_data);
	if (!SetupDiEnumDeviceInfo(dev_info.get(), 0, &dev_info_data))
	return;

	EnumeratePort(dev_info.get(), &dev_info_data, /check_port_name=/false);
	}

	void SerialDeviceEnumeratorWin::OnPathRemoved(const std::wstring& device_path) {
	base::win::ScopedDevInfo dev_info(
	SetupDiCreateDeviceInfoList(nullptr, nullptr));
	if (!dev_info.is_valid())
	return;

	if (!SetupDiOpenDeviceInterface(dev_info.get(), device_path.c_str(), 0,
	nullptr)) {
	return;
	}

	SP_DEVINFO_DATA dev_info_data = {};
	dev_info_data.cbSize = sizeof(dev_info_data);
	if (!SetupDiEnumDeviceInfo(dev_info.get(), 0, &dev_info_data))
	return;

	std::optional<std::string> port_name =
	GetPortName(dev_info.get(), &dev_info_data);
	if (!port_name)
	return;

	auto it = paths_.find(GetPath(*port_name));
	if (it == paths_.end())
	return;

	base::UnguessableToken token = it->second;

	paths_.erase(it);
	RemovePort(token);
	}

	void SerialDeviceEnumeratorWin::DoInitialEnumeration() {
	base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
	base::BlockingType::MAY_BLOCK);

	// On Windows 10 and above most COM port drivers register using the COMPORT
	// device interface class. Try to enumerate these first.
	{
	base::win::ScopedDevInfo dev_info;
	dev_info.reset(SetupDiGetClassDevs(&GUID_DEVINTERFACE_COMPORT, nullptr, 0,
	DIGCF_PRESENT \| DIGCF_DEVICEINTERFACE));
	if (!dev_info.is_valid())
	return;

	SP_DEVINFO_DATA dev_info_data = {.cbSize = sizeof(dev_info_data)};
	for (DWORD i = 0; SetupDiEnumDeviceInfo(dev_info.get(), i, &dev_info_data);
	i++) {
	EnumeratePort(dev_info.get(), &dev_info_data, /check_port_name=/false);
	}
	}

	// To detect devices which don't register with GUID_DEVINTERFACE_COMPORT also
	// enuerate all devices in the "Ports" and "Modems" device classes. These must
	// be checked to see if the port name starts with "COM" because it also
	// includes LPT ports.
	constexpr const GUID* kDeviceClasses[] = {&GUID_DEVCLASS_MODEM,
	&GUID_DEVCLASS_PORTS};
	for (const GUID* guid : kDeviceClasses) {
	base::win::ScopedDevInfo dev_info;
	dev_info.reset(SetupDiGetClassDevs(guid, nullptr, 0, DIGCF_PRESENT));
	if (!dev_info.is_valid())
	return;

	SP_DEVINFO_DATA dev_info_data = {.cbSize = sizeof(dev_info_data)};
	for (DWORD i = 0; SetupDiEnumDeviceInfo(dev_info.get(), i, &dev_info_data);
	i++) {
	EnumeratePort(dev_info.get(), &dev_info_data, /check_port_name=/true);
	}
	}
	}

	void SerialDeviceEnumeratorWin::EnumeratePort(HDEVINFO dev_info,
	SP_DEVINFO_DATA* dev_info_data,
	bool check_port_name) {
	std::optional<std::string> port_name = GetPortName(dev_info, dev_info_data);
	if (!port_name)
	return;

	if (check_port_name && !base::StartsWith(*port_name, "COM"))
	return;

	// Check whether the currently enumerating port has been seen before since
	// the method above will generate duplicate enumerations for some ports.
	base::FilePath path = GetPath(*port_name);
	if (base::Contains(paths_, path))
	return;

	std::optional<std::string> instance_id =
	GetProperty(dev_info, dev_info_data, DEVPKEY_Device_InstanceId);
	if (!instance_id)
	return;

	// Some versions of Windows pad this string with a variable number of NUL
	// bytes for no discernible reason.
	instance_id = std::string(base::TrimString(
	*instance_id, std::string_view("\0", 1), base::TRIM_TRAILING));

	base::UnguessableToken token = base::UnguessableToken::Create();
	auto info = mojom::SerialPortInfo::New();
	info->token = token;
	info->path = path;
	info->device_instance_id = *instance_id;

	// TODO(crbug.com/40653536): While the "bus reported device
	// description" is usually the USB product string this is still up to the
	// individual serial driver and could be equal to the "friendly name". It
	// would be more reliable to read the real USB strings here.
	info->display_name = GetProperty(dev_info, dev_info_data,
	DEVPKEY_Device_BusReportedDeviceDesc);
	if (info->display_name) {
	// This string is also sometimes padded with a variable number of NUL bytes
	// for no discernible reason.
	info->display_name = std::string(base::TrimString(
	*info->display_name, std::string_view("\0", 1), base::TRIM_TRAILING));
	} else {
	// Fall back to the "friendly name" if no "bus reported device description"
	// is available. This name will likely be the same for all devices using the
	// same driver.
	std::optional<std::string> friendly_name =
	GetProperty(dev_info, dev_info_data, DEVPKEY_Device_FriendlyName);
	if (!friendly_name)
	return;

	info->display_name = GetDisplayName(*friendly_name);
	}

	// The instance ID looks like "FTDIBUS\VID_0403+PID_6001+A703X87GA\0000".
	std::optional<uint32_t> vendor_id = GetVendorID(*instance_id);
	std::optional<uint32_t> product_id = GetProductID(*instance_id);
	std::optional<std::string> vendor_id_str, product_id_str;
	if (vendor_id) {
	info->has_vendor_id = true;
	info->vendor_id = *vendor_id;
	vendor_id_str = base::StringPrintf("%04X", *vendor_id);
	}
	if (product_id) {
	info->has_product_id = true;
	info->product_id = *product_id;
	product_id_str = base::StringPrintf("%04X", *product_id);
	}

	SERIAL_LOG(EVENT) << "Serial device added: path=" << info->path
	<< " instance_id=" << info->device_instance_id
	<< " vid=" << vendor_id_str.value_or("(none)")
	<< " pid=" << product_id_str.value_or("(none)");

	paths_.insert(std::make_pair(path, token));
	AddPort(std::move(info));
	}

	} // namespace device