Remove requirement that USB printers have a make/model metadata

chrome/browser/chromeos/printing/usb_printer_util.cc

 // Copyright 2017 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 "chrome/browser/chromeos/printing/usb_printer_util.h"
 
 #include <ctype.h>
 #include <stdint.h>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/md5.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/printing/printer_configuration.h"
 #include "device/usb/public/cpp/filter_utils.h"
 #include "device/usb/public/interfaces/device_manager.mojom.h"
 #include "device/usb/usb_device.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 namespace {
@@ skipping 113 matching lines @@
       base::UTF16ToUTF8(device.product_string()).c_str(),
       base::UTF16ToUTF8(device.serial_number()).c_str());
 }
 
 // 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.
 std::unique_ptr<Printer> UsbDeviceToPrinter(const device::UsbDevice& device) {
   // Preflight all required fields and log errors if we find something wrong.
-  if (device.vendor_id() == 0 || device.product_id() == 0 ||
-      device.manufacturer_string().empty() || device.product_string().empty()) {
+  if (device.vendor_id() == 0 || device.product_id() == 0) {
     LOG(ERROR) << "Failed to convert USB device to printer.  Fields were:\n"
                << UsbPrinterDeviceDetailsAsString(device);
     return nullptr;
   }
 
   auto printer = base::MakeUnique<Printer>();
   printer->set_manufacturer(base::UTF16ToUTF8(device.manufacturer_string()));
   printer->set_model(base::UTF16ToUTF8(device.product_string()));
-  printer->set_display_name(base::StringPrintf("%s %s (USB)",
-                                               printer->manufacturer().c_str(),
-                                               printer->model().c_str()));
+
+  // Construct the display name by however much of the manufacturer/model
+  // information that we have available.
+  std::vector<std::string> display_name_parts;
+  if (!printer->manufacturer().empty()) {
+    display_name_parts.push_back(printer->manufacturer());
+  }
+  if (!printer->model().empty()) {
+    display_name_parts.push_back(printer->model());
+  }
+  if (display_name_parts.empty()) {
+    // If we have neither manufacturer nor model, just display the name as
+    // unknown.
+    display_name_parts.push_back("Unknown Printer");
+  }
+  display_name_parts.push_back("(USB)");
+  printer->set_display_name(base::JoinString(display_name_parts, " "));
   printer->set_description(printer->display_name());
   printer->set_uri(UsbPrinterUri(device));
   printer->set_id(UsbPrinterId(device));
   return printer;
 }
 
 std::string UsbPrinterUri(const device::UsbDevice& device) {
   // 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(device.serial_number());
   return CupsURIEscape(base::StringPrintf("usb://%04x/%04x?serial=%s",
                                           device.vendor_id(),
                                           device.product_id(), serial.c_str()));
 }
 
 }  // namespace chromeos