chrome/browser/ash/printing/usb_printer_util.cc - chromium/src - Git at Google

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

 #include "chrome/browser/ash/printing/usb_printer_util.h"

 #include <stdint.h>

 #include <algorithm>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>

 #include "base/containers/contains.h"
 #include "base/containers/fixed_flat_set.h"
 #include "base/containers/span.h"
 #include "base/functional/callback_helpers.h"
 #include "base/numerics/byte_conversions.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/printing/printer_configuration.h"
 #include "chromeos/printing/usb_printer_id.h"
 #include "components/device_event_log/device_event_log.h"
 #include "crypto/obsolete/md5.h"
 #include "services/device/public/cpp/usb/usb_utils.h"
 #include "services/device/public/mojom/usb_device.mojom.h"
 #include "services/device/public/mojom/usb_enumeration_options.mojom.h"
 #include "services/device/public/mojom/usb_manager.mojom.h"
 #include "ui/base/l10n/l10n_util.h"

 namespace ash {

 namespace printing {
 crypto::obsolete::Md5 MakeMd5HasherForUsbPrinterUtil() {
   return {};
 }
 }  // namespace printing

 namespace {

 using device::mojom::UsbDeviceInfo;

 // Base class used for printer USB interfaces
 // (https://www.usb.org/developers/defined_class).
 constexpr uint8_t kPrinterInterfaceClass = 7;

 // Subclass used for printers
 // (http://www.usb.org/developers/docs/devclass_docs/usbprint11a021811.pdf).
 constexpr uint8_t kPrinterInterfaceSubclass = 1;

 // Protocol for ippusb printing.
 // (http://www.usb.org/developers/docs/devclass_docs/IPP.zip).
 constexpr uint8_t kPrinterIppusbProtocol = 4;

 // Configuration for a GET_DEVICE_ID Printer Class-Specific Request.
 const int kGetDeviceIdRequest = 0;

 // Generic USB make_and_model strings that are reused across device.
 bool IsGenericUsbDescription(const std::string& make_and_model) {
   static constexpr auto kGenericUsbModels =
       base::MakeFixedFlatSet<std::string_view>({
           "canon canon capt usb device",
           "epson usb1.1 mfp(hi-speed)",
           "epson usb2.0 mfp(hi-speed)",
           "epson usb2.0 printer (hi-speed)",
           "epson usb mfp",
           "epson usb printer",
           "seiko epson usb mfp",
           "oki data corp usb device",
       });
   return base::Contains(kGenericUsbModels, make_and_model);
 }

 // Callback for device.mojom.UsbDevice.ControlTransferIn.
 // Expects |data| to hold a newly queried Device ID.
 void OnControlTransfer(mojo::Remote<device::mojom::UsbDevice> device,
                        uint8_t interface_num,
                        GetDeviceIdCallback cb,
                        device::mojom::UsbTransferStatus status,
                        base::span<const uint8_t> data) {
   if (status != device::mojom::UsbTransferStatus::COMPLETED || data.empty()) {
     return std::move(cb).Run({});
   }

   // Cleanup device.
   device->ReleaseInterface(interface_num, base::DoNothing());
   device->Close(base::DoNothing());

   return std::move(cb).Run(chromeos::UsbPrinterId(data));
 }

 // Callback for device.mojom.UsbDevice.SetInterfaceAlternateSetting.
 // If interface was set successfully, attempts to query printer for a
 // Device ID.
 void OnAlternateSelected(mojo::Remote<device::mojom::UsbDevice> device,
                          const internal::PrinterInterfaceTarget& target,
                          GetDeviceIdCallback cb,
                          bool result) {
   if (!result) {
     PRINTER_LOG(ERROR) << "USB printer " << target.vidpid
                        << " failed to set interface "
                        << target.interface << " to alternate "
                        << target.alternate;
     return std::move(cb).Run({});
   }

   auto params = device::mojom::UsbControlTransferParams::New();
   params->type = device::mojom::UsbControlTransferType::CLASS;
   params->recipient = device::mojom::UsbControlTransferRecipient::INTERFACE;
   params->request = kGetDeviceIdRequest;
   params->value = target.config;
   params->index = (uint16_t(target.interface) << 8) | (target.alternate);

   // Query for IEEE1284 string.
   auto* device_raw = device.get();
   device_raw->ControlTransferIn(
       std::move(params), 255 /* max size */, 2000 /* 2 second timeout */,
       base::BindOnce(OnControlTransfer, std::move(device), target.interface,
                      std::move(cb)));
 }

 // Callback for device.mojom.UsbDevice.ClaimInterface.
 // If interface was claimed successfully, either sets the target alternate or
 // continues directly to querying Device ID.
 void OnClaimInterface(mojo::Remote<device::mojom::UsbDevice> device,
                       const internal::PrinterInterfaceTarget& target,
                       GetDeviceIdCallback cb,
                       device::mojom::UsbClaimInterfaceResult result) {
   if (result != device::mojom::UsbClaimInterfaceResult::kSuccess) {
     PRINTER_LOG(ERROR) << "USB printer " << target.vidpid
                        << " failed to claim interface "
                        << target.interface << ": " << result;
     return std::move(cb).Run({});
   }

   // Set alternate or directly proceed to next step if the interface only has
   // one alternate.
   if (target.set_alternate) {
     auto* device_raw = device.get();
     device_raw->SetInterfaceAlternateSetting(
         target.interface, target.alternate,
         base::BindOnce(OnAlternateSelected, std::move(device),
                        std::move(target), std::move(cb)));
   } else {
     OnAlternateSelected(std::move(device), std::move(target), std::move(cb),
                         true);
   }
 }

 // Callback for device.mojom.UsbDevice.Open.
 // If device was opened successfully, attempts to claim printer's default
 // interface.
 void OnDeviceOpen(mojo::Remote<device::mojom::UsbDevice> device,
                   const internal::PrinterInterfaceTarget& target,
                   GetDeviceIdCallback cb,
                   device::mojom::UsbOpenDeviceResultPtr result) {
   if (result->is_error() || !device) {
     return std::move(cb).Run({});
   }

   // Claim target interface.
   auto* device_raw = device.get();
   device_raw->ClaimInterface(target.interface,
                              base::BindOnce(OnClaimInterface, std::move(device),
                                             target, std::move(cb)));
 }

 // Incorporate the byte |val| into the incremental hash carried in |md5|.
 void Md5UpdateU8(crypto::obsolete::Md5& md5, base::StrictNumeric<uint8_t> val) {
   uint8_t tmp = val;
   md5.Update(base::span_from_ref(tmp));
 }

 // Incorporate |val| into |md5| as a big-endian value.
 void Md5UpdateU16BigEndian(crypto::obsolete::Md5& md5,
                            base::StrictNumeric<uint16_t> val) {
   md5.Update(base::U16ToBigEndian(val));
 }

 // Update the hash with the contents of |str|.
 //
 // UTF-16 strings are a bit fraught for consistency in memory representation;
 // endianness is an issue, but more importantly, there are *optional* prefix
 // codepoints to identify the endianness of the string.
 //
 // This is a long way to say "UTF-16 is hard to hash, let's just convert
 // to UTF-8 and hash that", which avoids all of these issues.
 void Md5UpdateString16(crypto::obsolete::Md5& md5, const std::u16string& str) {
   md5.Update(base::UTF16ToUTF8(str));
 }

 // Get the usb printer id for |device|.  This is used both as the identifier for
 // the printer in the user's PrintersManager and as the name of the printer in
 // CUPS, so it has to satisfy the naming restrictions of both.  CUPS in
 // particular is intolerant of much more than [a-z0-9_-], so we use that
 // character set.  This needs to be stable for a given device, but as unique as
 // possible for that device.  So we basically toss every bit of stable
 // information from the device into an MD5 hash, and then hexify the hash value
 // as a suffix to "usb-" as the final printer id.
 std::string CreateUsbPrinterId(const UsbDeviceInfo& device_info) {
   // Paranoid checks; in the unlikely event someone messes with the USB device
   // definition, our (supposedly stable) hashes will change.
   static_assert(sizeof(device_info.class_code) == 1, "Class size changed");
   static_assert(sizeof(device_info.subclass_code) == 1,
                 "Subclass size changed");
   static_assert(sizeof(device_info.protocol_code) == 1,
                 "Protocol size changed");
   static_assert(sizeof(device_info.vendor_id) == 2, "Vendor id size changed");
   static_assert(sizeof(device_info.product_id) == 2, "Product id size changed");
   static_assert(sizeof(device::GetDeviceVersion(device_info)) == 2,
                 "Version size changed");

   auto md5 = ash::printing::MakeMd5HasherForUsbPrinterUtil();
   Md5UpdateU8(md5, device_info.class_code);
   Md5UpdateU8(md5, device_info.subclass_code);
   Md5UpdateU8(md5, device_info.protocol_code);
   Md5UpdateU16BigEndian(md5, device_info.vendor_id);
   Md5UpdateU16BigEndian(md5, device_info.product_id);
   Md5UpdateU16BigEndian(md5, device::GetDeviceVersion(device_info));
   md5.Update(GetManufacturerName(device_info));
   md5.Update(GetProductName(device_info));
   Md5UpdateString16(md5, GetSerialNumber(device_info));
   return base::StringPrintf("usb-%s",
                             base::ToLowerASCII(base::HexEncode(md5.Finish())));
 }

 // Creates a mojom filter which can be used to identify a basic USB printer.
 mojo::StructPtr<device::mojom::UsbDeviceFilter> CreatePrinterFilter() {
   auto printer_filter = device::mojom::UsbDeviceFilter::New();
   printer_filter->has_class_code = true;
   printer_filter->class_code = kPrinterInterfaceClass;
   printer_filter->has_subclass_code = true;
   printer_filter->subclass_code = kPrinterInterfaceSubclass;

   return printer_filter;
 }

 bool UsbDeviceSupportsIppusb(const UsbDeviceInfo& device_info) {
   auto printer_filter = CreatePrinterFilter();
   printer_filter->has_protocol_code = true;
   printer_filter->protocol_code = kPrinterIppusbProtocol;

   return device::UsbDeviceFilterMatches(*printer_filter, device_info);
 }

 // Convert the interesting details of a device to a string, for
 // logging/debugging.
 std::string UsbPrinterDeviceDetailsAsString(const UsbDeviceInfo& device_info) {
   return base::StringPrintf(
       " guid:                %s\n"
       " usb version:         %d\n"
       " device class:        %d\n"
       " device subclass:     %d\n"
       " device protocol:     %d\n"
       " vendor id:           %04x\n"
       " product id:          %04x\n"
       " device version:      %d\n"
       " manufacturer string: %s\n"
       " product string:      %s\n"
       " serial number:       %s",
       device_info.guid.c_str(), device::GetUsbVersion(device_info),
       device_info.class_code, device_info.subclass_code,
       device_info.protocol_code, device_info.vendor_id, device_info.product_id,
       device::GetDeviceVersion(device_info),
       GetManufacturerName(device_info).c_str(),
       GetProductName(device_info).c_str(),
       base::UTF16ToUTF8(GetSerialNumber(device_info)).c_str());
 }

 // Gets the URI CUPS would use to refer to this USB device.  Assumes device
 // is a printer.
 chromeos::Uri UsbPrinterUri(const UsbDeviceInfo& device_info) {
   // Note that serial may, for some devices, be empty or bogus (all zeros, non
   // unique, or otherwise not really a serial number), but having a non-unique
   // or empty serial field in the URI still lets us print, it just means we
   // don't have a way to uniquely identify a printer if there are multiple ones
   // plugged in with the same VID/PID, so we may print to the *wrong* printer.
   // There doesn't seem to be a robust solution to this problem; if printers
   // don't supply a serial number, we don't have any reliable way to do that
   // differentiation.
   std::string serial = base::UTF16ToUTF8(GetSerialNumber(device_info));
   chromeos::Uri uri;
   uri.SetScheme("usb");
   uri.SetHost(base::StringPrintf("%04x", device_info.vendor_id));
   uri.SetPath({base::StringPrintf("%04x", device_info.product_id)});
   uri.SetQuery({{"serial", serial}});
   return uri;
 }

 }  // namespace

 namespace internal {

 // Find the best interface to send a printer-specific GET_DEVICE_ID request to.
 // Not every printer has a printer class interface at alternate 0 of interface
 // 0.  First, try to find the first interface that does have printer class
 // without any alternates.  If that fails, select the first interface that has
 // printer class on any of the alternates and mark that SET_INTERFACE will need
 // to be called.
 std::optional<PrinterInterfaceTarget> FindPrinterInterfaceTarget(
     const device::mojom::UsbDeviceInfo& device_info) {
   std::optional<PrinterInterfaceTarget> candidate;
   for (uint8_t config_idx = 0;
        const auto& config : device_info.configurations) {
     for (uint8_t iface_idx = 0; const auto& iface : config->interfaces) {
       for (uint8_t alt_idx = 0; const auto& alt : iface->alternates) {
         if (alt->class_code == kPrinterInterfaceClass &&
             alt->subclass_code == kPrinterInterfaceSubclass) {
           std::string vidpid = base::StringPrintf(
               "%04x:%04x", device_info.vendor_id, device_info.product_id);
           if (iface->alternates.size() == 1) {
             return PrinterInterfaceTarget{
                 std::move(vidpid), config_idx, iface_idx, alt_idx, false,
             };
           } else if (!candidate.has_value()) {
             candidate.emplace(std::move(vidpid), config_idx, iface_idx, alt_idx,
                               true);
           }
         }
         alt_idx++;
       }
       iface_idx++;
     }
     config_idx++;
   }

   if (candidate.has_value()) {
     return candidate;
   }

   return std::nullopt;
 }

 }  // namespace internal

 std::string GuessEffectiveMakeAndModel(
     const device::mojom::UsbDeviceInfo& device_info) {
   return base::StrCat(
       {GetManufacturerName(device_info), " ", GetProductName(device_info)});
 }

 std::string GetManufacturerName(const UsbDeviceInfo& device_info) {
   return base::UTF16ToUTF8(
       device_info.manufacturer_name.value_or(std::u16string()));
 }

 std::string GetProductName(const UsbDeviceInfo& device_info) {
   const std::string manufacturer =
       base::StrCat({GetManufacturerName(device_info), " "});
   std::string model =
       base::UTF16ToUTF8(device_info.product_name.value_or(std::u16string()));

   // Some devices have the manufacturer duplicated in the product
   // string. This needs to be removed to remain consistent with the make
   // and model strings in the ppd index.
   if (base::StartsWith(model, manufacturer,
                        base::CompareCase::INSENSITIVE_ASCII)) {
     model.erase(0, manufacturer.size());
   }
   return model;
 }

 std::u16string GetSerialNumber(const UsbDeviceInfo& device_info) {
   // If the device does not have a serial number or has an empty serial number,
   // use '?' so this matches the convention that CUPS uses for 'no serial
   // number'.
   if (!device_info.serial_number.has_value() ||
       device_info.serial_number.value().empty()) {
     return u"?";
   }
   return device_info.serial_number.value();
 }

 bool UsbDeviceIsPrinter(const UsbDeviceInfo& device_info) {
   auto printer_filter = CreatePrinterFilter();
   return device::UsbDeviceFilterMatches(*printer_filter, device_info);
 }

 // Attempt to gather all the information we need to work with this printer by
 // querying the USB device.  This should only be called using devices we believe
 // are printers, not arbitrary USB devices, as we may get weird partial results
 // from arbitrary devices. The results are saved in the second parameter.
 bool UsbDeviceToPrinter(const UsbDeviceInfo& device_info,
                         PrinterDetector::DetectedPrinter* entry) {
   DCHECK(entry);

   // Preflight all required fields and log errors if we find something wrong.
   if (device_info.vendor_id == 0 || device_info.product_id == 0) {
     LOG(ERROR) << "Failed to convert USB device to printer.  Fields were:\n"
                << UsbPrinterDeviceDetailsAsString(device_info);
     return false;
   }

   entry->ppd_search_data.usb_manufacturer = GetManufacturerName(device_info);
   entry->ppd_search_data.usb_model = GetProductName(device_info);

   const std::string& make = entry->ppd_search_data.usb_manufacturer;
   const std::string& model = entry->ppd_search_data.usb_model;

   // Synthesize make-and-model string for printer identification.
   entry->printer.set_make_and_model(GuessEffectiveMakeAndModel(device_info));

   entry->printer.set_display_name(MakeDisplayName(make, model));
   entry->printer.set_description(entry->printer.display_name());
   entry->printer.SetUri(UsbPrinterUri(device_info));
   entry->printer.set_id(CreateUsbPrinterId(device_info));
   entry->printer.set_supports_ippusb(UsbDeviceSupportsIppusb(device_info));
   return true;
 }

 void GetDeviceId(const device::mojom::UsbDeviceInfo& device_info,
                  mojo::Remote<device::mojom::UsbDevice> device,
                  GetDeviceIdCallback cb) {
   // Find printer class interface so the request can be directed to it.
   auto target = internal::FindPrinterInterfaceTarget(device_info);
   if (!target.has_value()) {
     PRINTER_LOG(ERROR) << "No printer interface found for device: "
                        << UsbPrinterDeviceDetailsAsString(device_info);
     return std::move(cb).Run({});
   }

   // Open device.
   auto* device_raw = device.get();
   device_raw->Open(base::BindOnce(OnDeviceOpen, std::move(device),
                                   std::move(target.value()), std::move(cb)));
 }

 std::string MakeDisplayName(const std::string& make, const std::string& model) {
   // Construct the display name by however much of the manufacturer/model
   // information that we have available.
   if (make.empty() && model.empty()) {
     return l10n_util::GetStringUTF8(IDS_USB_PRINTER_UNKNOWN_DISPLAY_NAME);
   } else if (!make.empty() && !model.empty()) {
     return l10n_util::GetStringFUTF8(IDS_USB_PRINTER_DISPLAY_NAME,
                                      base::UTF8ToUTF16(make),
                                      base::UTF8ToUTF16(model));
   } else {
     // Exactly one string is present.
     DCHECK_NE(make.empty(), model.empty());
     return l10n_util::GetStringFUTF8(IDS_USB_PRINTER_DISPLAY_NAME_MAKE_OR_MODEL,
                                      base::UTF8ToUTF16(make + model));
   }
 }

 void UpdateSearchDataFromDeviceId(const chromeos::UsbPrinterId& device_id,
                                   PrinterDetector::DetectedPrinter* printer) {
   // If the IEEE1284 device info looks complete and doesn't match the USB
   // string descriptors, add an additional PPD search string.  In addition, if
   // the USB make_and_model is empty or matches known generic strings, replace
   // the entire device description with the values from the IEEE1284 info.
   const std::string& usb_make = device_id.make();
   const std::string& usb_model = device_id.model();
   if (usb_make.empty() || usb_model.empty()) {
     return;
   }
   std::string usb_make_and_model = base::StrCat({usb_make, " ", usb_model});
   if (base::CompareCaseInsensitiveASCII(printer->printer.make_and_model(),
                                         usb_make_and_model) == 0) {
     return;
   }

   if (base::TrimWhitespaceASCII(printer->printer.make_and_model(),
                                 base::TRIM_ALL)
           .empty() ||
       IsGenericUsbDescription(
           base::ToLowerASCII(printer->printer.make_and_model()))) {
     PRINTER_LOG(EVENT) << printer->printer.make_and_model()
                        << " replaced with USB device info: "
                        << usb_make_and_model;
     printer->printer.set_display_name(MakeDisplayName(usb_make, usb_model));
     printer->printer.set_description(printer->printer.display_name());
     printer->printer.set_make_and_model(usb_make_and_model);
     printer->ppd_search_data.make_and_model.front() =
         base::ToLowerASCII(usb_make_and_model);
   } else {
     // Not a generic string, but still add the IEEE 1284 ID as an additional
     // possible PPD match.
     printer->ppd_search_data.make_and_model.push_back(
         base::ToLowerASCII(usb_make_and_model));
   }
 }

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

	#include "chrome/browser/ash/printing/usb_printer_util.h"

	#include <stdint.h>

	#include <algorithm>
	#include <optional>
	#include <string>
	#include <string_view>
	#include <utility>
	#include <vector>

	#include "base/containers/contains.h"
	#include "base/containers/fixed_flat_set.h"
	#include "base/containers/span.h"
	#include "base/functional/callback_helpers.h"
	#include "base/numerics/byte_conversions.h"
	#include "base/numerics/safe_conversions.h"
	#include "base/strings/strcat.h"
	#include "base/strings/string_number_conversions.h"
	#include "base/strings/string_util.h"
	#include "base/strings/stringprintf.h"
	#include "base/strings/utf_string_conversions.h"
	#include "chrome/grit/generated_resources.h"
	#include "chromeos/printing/printer_configuration.h"
	#include "chromeos/printing/usb_printer_id.h"
	#include "components/device_event_log/device_event_log.h"
	#include "crypto/obsolete/md5.h"
	#include "services/device/public/cpp/usb/usb_utils.h"
	#include "services/device/public/mojom/usb_device.mojom.h"
	#include "services/device/public/mojom/usb_enumeration_options.mojom.h"
	#include "services/device/public/mojom/usb_manager.mojom.h"
	#include "ui/base/l10n/l10n_util.h"

	namespace ash {

	namespace printing {
	crypto::obsolete::Md5 MakeMd5HasherForUsbPrinterUtil() {
	return {};
	}
	} // namespace printing

	namespace {

	using device::mojom::UsbDeviceInfo;

	// Base class used for printer USB interfaces
	// (https://www.usb.org/developers/defined_class).
	constexpr uint8_t kPrinterInterfaceClass = 7;

	// Subclass used for printers
	// (http://www.usb.org/developers/docs/devclass_docs/usbprint11a021811.pdf).
	constexpr uint8_t kPrinterInterfaceSubclass = 1;

	// Protocol for ippusb printing.
	// (http://www.usb.org/developers/docs/devclass_docs/IPP.zip).
	constexpr uint8_t kPrinterIppusbProtocol = 4;

	// Configuration for a GET_DEVICE_ID Printer Class-Specific Request.
	const int kGetDeviceIdRequest = 0;

	// Generic USB make_and_model strings that are reused across device.
	bool IsGenericUsbDescription(const std::string& make_and_model) {
	static constexpr auto kGenericUsbModels =
	base::MakeFixedFlatSet<std::string_view>({
	"canon canon capt usb device",
	"epson usb1.1 mfp(hi-speed)",
	"epson usb2.0 mfp(hi-speed)",
	"epson usb2.0 printer (hi-speed)",
	"epson usb mfp",
	"epson usb printer",
	"seiko epson usb mfp",
	"oki data corp usb device",
	});
	return base::Contains(kGenericUsbModels, make_and_model);
	}

	// Callback for device.mojom.UsbDevice.ControlTransferIn.
	// Expects \|data\| to hold a newly queried Device ID.
	void OnControlTransfer(mojo::Remote<device::mojom::UsbDevice> device,
	uint8_t interface_num,
	GetDeviceIdCallback cb,
	device::mojom::UsbTransferStatus status,
	base::span<const uint8_t> data) {
	if (status != device::mojom::UsbTransferStatus::COMPLETED \|\| data.empty()) {
	return std::move(cb).Run({});
	}

	// Cleanup device.
	device->ReleaseInterface(interface_num, base::DoNothing());
	device->Close(base::DoNothing());

	return std::move(cb).Run(chromeos::UsbPrinterId(data));
	}

	// Callback for device.mojom.UsbDevice.SetInterfaceAlternateSetting.
	// If interface was set successfully, attempts to query printer for a
	// Device ID.
	void OnAlternateSelected(mojo::Remote<device::mojom::UsbDevice> device,
	const internal::PrinterInterfaceTarget& target,
	GetDeviceIdCallback cb,
	bool result) {
	if (!result) {
	PRINTER_LOG(ERROR) << "USB printer " << target.vidpid
	<< " failed to set interface "
	<< target.interface << " to alternate "
	<< target.alternate;
	return std::move(cb).Run({});
	}

	auto params = device::mojom::UsbControlTransferParams::New();
	params->type = device::mojom::UsbControlTransferType::CLASS;
	params->recipient = device::mojom::UsbControlTransferRecipient::INTERFACE;
	params->request = kGetDeviceIdRequest;
	params->value = target.config;
	params->index = (uint16_t(target.interface) << 8) \| (target.alternate);

	// Query for IEEE1284 string.
	auto* device_raw = device.get();
	device_raw->ControlTransferIn(
	std::move(params), 255 /* max size /, 2000 / 2 second timeout */,
	base::BindOnce(OnControlTransfer, std::move(device), target.interface,
	std::move(cb)));
	}

	// Callback for device.mojom.UsbDevice.ClaimInterface.
	// If interface was claimed successfully, either sets the target alternate or
	// continues directly to querying Device ID.
	void OnClaimInterface(mojo::Remote<device::mojom::UsbDevice> device,
	const internal::PrinterInterfaceTarget& target,
	GetDeviceIdCallback cb,
	device::mojom::UsbClaimInterfaceResult result) {
	if (result != device::mojom::UsbClaimInterfaceResult::kSuccess) {
	PRINTER_LOG(ERROR) << "USB printer " << target.vidpid
	<< " failed to claim interface "
	<< target.interface << ": " << result;
	return std::move(cb).Run({});
	}

	// Set alternate or directly proceed to next step if the interface only has
	// one alternate.
	if (target.set_alternate) {
	auto* device_raw = device.get();
	device_raw->SetInterfaceAlternateSetting(
	target.interface, target.alternate,
	base::BindOnce(OnAlternateSelected, std::move(device),
	std::move(target), std::move(cb)));
	} else {
	OnAlternateSelected(std::move(device), std::move(target), std::move(cb),
	true);
	}
	}

	// Callback for device.mojom.UsbDevice.Open.
	// If device was opened successfully, attempts to claim printer's default
	// interface.
	void OnDeviceOpen(mojo::Remote<device::mojom::UsbDevice> device,
	const internal::PrinterInterfaceTarget& target,
	GetDeviceIdCallback cb,
	device::mojom::UsbOpenDeviceResultPtr result) {
	if (result->is_error() \|\| !device) {
	return std::move(cb).Run({});
	}

	// Claim target interface.
	auto* device_raw = device.get();
	device_raw->ClaimInterface(target.interface,
	base::BindOnce(OnClaimInterface, std::move(device),
	target, std::move(cb)));
	}

	// Incorporate the byte \|val\| into the incremental hash carried in \|md5\|.
	void Md5UpdateU8(crypto::obsolete::Md5& md5, base::StrictNumeric<uint8_t> val) {
	uint8_t tmp = val;
	md5.Update(base::span_from_ref(tmp));
	}

	// Incorporate \|val\| into \|md5\| as a big-endian value.
	void Md5UpdateU16BigEndian(crypto::obsolete::Md5& md5,
	base::StrictNumeric<uint16_t> val) {
	md5.Update(base::U16ToBigEndian(val));
	}

	// Update the hash with the contents of \|str\|.
	//
	// UTF-16 strings are a bit fraught for consistency in memory representation;
	// endianness is an issue, but more importantly, there are optional prefix
	// codepoints to identify the endianness of the string.
	//
	// This is a long way to say "UTF-16 is hard to hash, let's just convert
	// to UTF-8 and hash that", which avoids all of these issues.
	void Md5UpdateString16(crypto::obsolete::Md5& md5, const std::u16string& str) {
	md5.Update(base::UTF16ToUTF8(str));
	}

	// Get the usb printer id for \|device\|. This is used both as the identifier for
	// the printer in the user's PrintersManager and as the name of the printer in
	// CUPS, so it has to satisfy the naming restrictions of both. CUPS in
	// particular is intolerant of much more than [a-z0-9_-], so we use that
	// character set. This needs to be stable for a given device, but as unique as
	// possible for that device. So we basically toss every bit of stable
	// information from the device into an MD5 hash, and then hexify the hash value
	// as a suffix to "usb-" as the final printer id.
	std::string CreateUsbPrinterId(const UsbDeviceInfo& device_info) {
	// Paranoid checks; in the unlikely event someone messes with the USB device
	// definition, our (supposedly stable) hashes will change.
	static_assert(sizeof(device_info.class_code) == 1, "Class size changed");
	static_assert(sizeof(device_info.subclass_code) == 1,
	"Subclass size changed");
	static_assert(sizeof(device_info.protocol_code) == 1,
	"Protocol size changed");
	static_assert(sizeof(device_info.vendor_id) == 2, "Vendor id size changed");
	static_assert(sizeof(device_info.product_id) == 2, "Product id size changed");
	static_assert(sizeof(device::GetDeviceVersion(device_info)) == 2,
	"Version size changed");

	auto md5 = ash::printing::MakeMd5HasherForUsbPrinterUtil();
	Md5UpdateU8(md5, device_info.class_code);
	Md5UpdateU8(md5, device_info.subclass_code);
	Md5UpdateU8(md5, device_info.protocol_code);
	Md5UpdateU16BigEndian(md5, device_info.vendor_id);
	Md5UpdateU16BigEndian(md5, device_info.product_id);
	Md5UpdateU16BigEndian(md5, device::GetDeviceVersion(device_info));
	md5.Update(GetManufacturerName(device_info));
	md5.Update(GetProductName(device_info));
	Md5UpdateString16(md5, GetSerialNumber(device_info));
	return base::StringPrintf("usb-%s",
	base::ToLowerASCII(base::HexEncode(md5.Finish())));
	}

	// Creates a mojom filter which can be used to identify a basic USB printer.
	mojo::StructPtr<device::mojom::UsbDeviceFilter> CreatePrinterFilter() {
	auto printer_filter = device::mojom::UsbDeviceFilter::New();
	printer_filter->has_class_code = true;
	printer_filter->class_code = kPrinterInterfaceClass;
	printer_filter->has_subclass_code = true;
	printer_filter->subclass_code = kPrinterInterfaceSubclass;

	return printer_filter;
	}

	bool UsbDeviceSupportsIppusb(const UsbDeviceInfo& device_info) {
	auto printer_filter = CreatePrinterFilter();
	printer_filter->has_protocol_code = true;
	printer_filter->protocol_code = kPrinterIppusbProtocol;

	return device::UsbDeviceFilterMatches(*printer_filter, device_info);
	}

	// Convert the interesting details of a device to a string, for
	// logging/debugging.
	std::string UsbPrinterDeviceDetailsAsString(const UsbDeviceInfo& device_info) {
	return base::StringPrintf(
	" guid: %s\n"
	" usb version: %d\n"
	" device class: %d\n"
	" device subclass: %d\n"
	" device protocol: %d\n"
	" vendor id: %04x\n"
	" product id: %04x\n"
	" device version: %d\n"
	" manufacturer string: %s\n"
	" product string: %s\n"
	" serial number: %s",
	device_info.guid.c_str(), device::GetUsbVersion(device_info),
	device_info.class_code, device_info.subclass_code,
	device_info.protocol_code, device_info.vendor_id, device_info.product_id,
	device::GetDeviceVersion(device_info),
	GetManufacturerName(device_info).c_str(),
	GetProductName(device_info).c_str(),
	base::UTF16ToUTF8(GetSerialNumber(device_info)).c_str());
	}

	// Gets the URI CUPS would use to refer to this USB device. Assumes device
	// is a printer.
	chromeos::Uri UsbPrinterUri(const UsbDeviceInfo& device_info) {
	// Note that serial may, for some devices, be empty or bogus (all zeros, non
	// unique, or otherwise not really a serial number), but having a non-unique
	// or empty serial field in the URI still lets us print, it just means we
	// don't have a way to uniquely identify a printer if there are multiple ones
	// plugged in with the same VID/PID, so we may print to the wrong printer.
	// There doesn't seem to be a robust solution to this problem; if printers
	// don't supply a serial number, we don't have any reliable way to do that
	// differentiation.
	std::string serial = base::UTF16ToUTF8(GetSerialNumber(device_info));
	chromeos::Uri uri;
	uri.SetScheme("usb");
	uri.SetHost(base::StringPrintf("%04x", device_info.vendor_id));
	uri.SetPath({base::StringPrintf("%04x", device_info.product_id)});
	uri.SetQuery({{"serial", serial}});
	return uri;
	}

	} // namespace

	namespace internal {

	// Find the best interface to send a printer-specific GET_DEVICE_ID request to.
	// Not every printer has a printer class interface at alternate 0 of interface
	// 0. First, try to find the first interface that does have printer class
	// without any alternates. If that fails, select the first interface that has
	// printer class on any of the alternates and mark that SET_INTERFACE will need
	// to be called.
	std::optional<PrinterInterfaceTarget> FindPrinterInterfaceTarget(
	const device::mojom::UsbDeviceInfo& device_info) {
	std::optional<PrinterInterfaceTarget> candidate;
	for (uint8_t config_idx = 0;
	const auto& config : device_info.configurations) {
	for (uint8_t iface_idx = 0; const auto& iface : config->interfaces) {
	for (uint8_t alt_idx = 0; const auto& alt : iface->alternates) {
	if (alt->class_code == kPrinterInterfaceClass &&
	alt->subclass_code == kPrinterInterfaceSubclass) {
	std::string vidpid = base::StringPrintf(
	"%04x:%04x", device_info.vendor_id, device_info.product_id);
	if (iface->alternates.size() == 1) {
	return PrinterInterfaceTarget{
	std::move(vidpid), config_idx, iface_idx, alt_idx, false,
	};
	} else if (!candidate.has_value()) {
	candidate.emplace(std::move(vidpid), config_idx, iface_idx, alt_idx,
	true);
	}
	}
	alt_idx++;
	}
	iface_idx++;
	}
	config_idx++;
	}

	if (candidate.has_value()) {
	return candidate;
	}

	return std::nullopt;
	}

	} // namespace internal

	std::string GuessEffectiveMakeAndModel(
	const device::mojom::UsbDeviceInfo& device_info) {
	return base::StrCat(
	{GetManufacturerName(device_info), " ", GetProductName(device_info)});
	}

	std::string GetManufacturerName(const UsbDeviceInfo& device_info) {
	return base::UTF16ToUTF8(
	device_info.manufacturer_name.value_or(std::u16string()));
	}

	std::string GetProductName(const UsbDeviceInfo& device_info) {
	const std::string manufacturer =
	base::StrCat({GetManufacturerName(device_info), " "});
	std::string model =
	base::UTF16ToUTF8(device_info.product_name.value_or(std::u16string()));

	// Some devices have the manufacturer duplicated in the product
	// string. This needs to be removed to remain consistent with the make
	// and model strings in the ppd index.
	if (base::StartsWith(model, manufacturer,
	base::CompareCase::INSENSITIVE_ASCII)) {
	model.erase(0, manufacturer.size());
	}
	return model;
	}

	std::u16string GetSerialNumber(const UsbDeviceInfo& device_info) {
	// If the device does not have a serial number or has an empty serial number,
	// use '?' so this matches the convention that CUPS uses for 'no serial
	// number'.
	if (!device_info.serial_number.has_value() \|\|
	device_info.serial_number.value().empty()) {
	return u"?";
	}
	return device_info.serial_number.value();
	}

	bool UsbDeviceIsPrinter(const UsbDeviceInfo& device_info) {
	auto printer_filter = CreatePrinterFilter();
	return device::UsbDeviceFilterMatches(*printer_filter, device_info);
	}

	// Attempt to gather all the information we need to work with this printer by
	// querying the USB device. This should only be called using devices we believe
	// are printers, not arbitrary USB devices, as we may get weird partial results
	// from arbitrary devices. The results are saved in the second parameter.
	bool UsbDeviceToPrinter(const UsbDeviceInfo& device_info,
	PrinterDetector::DetectedPrinter* entry) {
	DCHECK(entry);

	// Preflight all required fields and log errors if we find something wrong.
	if (device_info.vendor_id == 0 \|\| device_info.product_id == 0) {
	LOG(ERROR) << "Failed to convert USB device to printer. Fields were:\n"
	<< UsbPrinterDeviceDetailsAsString(device_info);
	return false;
	}

	entry->ppd_search_data.usb_manufacturer = GetManufacturerName(device_info);
	entry->ppd_search_data.usb_model = GetProductName(device_info);

	const std::string& make = entry->ppd_search_data.usb_manufacturer;
	const std::string& model = entry->ppd_search_data.usb_model;

	// Synthesize make-and-model string for printer identification.
	entry->printer.set_make_and_model(GuessEffectiveMakeAndModel(device_info));

	entry->printer.set_display_name(MakeDisplayName(make, model));
	entry->printer.set_description(entry->printer.display_name());
	entry->printer.SetUri(UsbPrinterUri(device_info));
	entry->printer.set_id(CreateUsbPrinterId(device_info));
	entry->printer.set_supports_ippusb(UsbDeviceSupportsIppusb(device_info));
	return true;
	}

	void GetDeviceId(const device::mojom::UsbDeviceInfo& device_info,
	mojo::Remote<device::mojom::UsbDevice> device,
	GetDeviceIdCallback cb) {
	// Find printer class interface so the request can be directed to it.
	auto target = internal::FindPrinterInterfaceTarget(device_info);
	if (!target.has_value()) {
	PRINTER_LOG(ERROR) << "No printer interface found for device: "
	<< UsbPrinterDeviceDetailsAsString(device_info);
	return std::move(cb).Run({});
	}

	// Open device.
	auto* device_raw = device.get();
	device_raw->Open(base::BindOnce(OnDeviceOpen, std::move(device),
	std::move(target.value()), std::move(cb)));
	}

	std::string MakeDisplayName(const std::string& make, const std::string& model) {
	// Construct the display name by however much of the manufacturer/model
	// information that we have available.
	if (make.empty() && model.empty()) {
	return l10n_util::GetStringUTF8(IDS_USB_PRINTER_UNKNOWN_DISPLAY_NAME);
	} else if (!make.empty() && !model.empty()) {
	return l10n_util::GetStringFUTF8(IDS_USB_PRINTER_DISPLAY_NAME,
	base::UTF8ToUTF16(make),
	base::UTF8ToUTF16(model));
	} else {
	// Exactly one string is present.
	DCHECK_NE(make.empty(), model.empty());
	return l10n_util::GetStringFUTF8(IDS_USB_PRINTER_DISPLAY_NAME_MAKE_OR_MODEL,
	base::UTF8ToUTF16(make + model));
	}
	}

	void UpdateSearchDataFromDeviceId(const chromeos::UsbPrinterId& device_id,
	PrinterDetector::DetectedPrinter* printer) {
	// If the IEEE1284 device info looks complete and doesn't match the USB
	// string descriptors, add an additional PPD search string. In addition, if
	// the USB make_and_model is empty or matches known generic strings, replace
	// the entire device description with the values from the IEEE1284 info.
	const std::string& usb_make = device_id.make();
	const std::string& usb_model = device_id.model();
	if (usb_make.empty() \|\| usb_model.empty()) {
	return;
	}
	std::string usb_make_and_model = base::StrCat({usb_make, " ", usb_model});
	if (base::CompareCaseInsensitiveASCII(printer->printer.make_and_model(),
	usb_make_and_model) == 0) {
	return;
	}

	if (base::TrimWhitespaceASCII(printer->printer.make_and_model(),
	base::TRIM_ALL)
	.empty() \|\|
	IsGenericUsbDescription(
	base::ToLowerASCII(printer->printer.make_and_model()))) {
	PRINTER_LOG(EVENT) << printer->printer.make_and_model()
	<< " replaced with USB device info: "
	<< usb_make_and_model;
	printer->printer.set_display_name(MakeDisplayName(usb_make, usb_model));
	printer->printer.set_description(printer->printer.display_name());
	printer->printer.set_make_and_model(usb_make_and_model);
	printer->ppd_search_data.make_and_model.front() =
	base::ToLowerASCII(usb_make_and_model);
	} else {
	// Not a generic string, but still add the IEEE 1284 ID as an additional
	// possible PPD match.
	printer->ppd_search_data.make_and_model.push_back(
	base::ToLowerASCII(usb_make_and_model));
	}
	}

	} // namespace ash