Update CUPS settings UI to allow USB printers to be added via discovery.

chrome/browser/ui/webui/settings/chromeos/cups_printers_handler.cc

 // Copyright 2016 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/ui/webui/settings/chromeos/cups_printers_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 36 matching lines @@
 void OnRemovedPrinter(bool success) {}
 
 std::unique_ptr<base::DictionaryValue> GetPrinterInfo(const Printer& printer) {
   std::unique_ptr<base::DictionaryValue> printer_info =
       base::MakeUnique<base::DictionaryValue>();
   printer_info->SetString("printerId", printer.id());
   printer_info->SetString("printerName", printer.display_name());
   printer_info->SetString("printerDescription", printer.description());
   printer_info->SetString("printerManufacturer", printer.manufacturer());
   printer_info->SetString("printerModel", printer.model());
-
   // Get protocol, ip address and queue from the printer's URI.
   const std::string printer_uri = printer.uri();
   url::Parsed parsed;
   url::ParseStandardURL(printer_uri.c_str(), printer_uri.length(), &parsed);
 
   std::string scheme;
   std::string host;
   std::string path;
   if (parsed.scheme.len > 0)
     scheme = std::string(printer_uri, parsed.scheme.begin, parsed.scheme.len);
   if (parsed.host.len > 0)
     host = std::string(printer_uri, parsed.host.begin, parsed.host.len);
   if (parsed.path.len > 0)
     path = std::string(printer_uri, parsed.path.begin, parsed.path.len);
-
-  printer_info->SetString("printerAddress", host);
+  if (base::ToLowerASCII(scheme) == "usb") {
+    // USB has URI path (and, maybe, query) components that aren't really
+    // associated with a queue -- the mapping between printing semantics and URI
+    // semantics breaks down a bit here.  From the user's point of view, the
+    // entire host/path/query block is the printer address for USB.
+    printer_info->SetString("printerAddress",
+                            printer_uri.substr(parsed.host.begin));
+  } else {
+    printer_info->SetString("printerAddress", host);
+    if (!path.empty()) {
+      printer_info->SetString("printerQueue", path.substr(1));
+    }
+  }
   printer_info->SetString("printerProtocol", base::ToLowerASCII(scheme));
-  if (!path.empty())
-    printer_info->SetString("printerQueue", path.substr(1));
 
   return printer_info;
 }
 
 }  // namespace
 
 CupsPrintersHandler::CupsPrintersHandler(content::WebUI* webui)
     : printer_discoverer_(nullptr),
       profile_(Profile::FromWebUI(webui)),
       weak_factory_(this) {
@@ skipping 109 matching lines @@
   CHECK(printer_dict->GetString("printerDescription", &printer_description));
   CHECK(printer_dict->GetString("printerManufacturer", &printer_manufacturer));
   CHECK(printer_dict->GetString("printerModel", &printer_model));
   CHECK(printer_dict->GetString("printerAddress", &printer_address));
   CHECK(printer_dict->GetString("printerProtocol", &printer_protocol));
   // printerQueue might be null for a printer whose protocol is not 'LPD'.
   printer_dict->GetString("printerQueue", &printer_queue);
 
   // printerPPDPath might be null for an auto-discovered printer.
   printer_dict->GetString("printerPPDPath", &printer_ppd_path);
-  std::string printer_uri =
-      printer_protocol + "://" + printer_address + "/" + printer_queue;
+  std::string printer_uri = printer_protocol + "://" + printer_address;
+  if (!printer_queue.empty()) {
+    printer_uri += "/" + printer_queue;
+  }
 
   std::unique_ptr<Printer> printer = base::MakeUnique<Printer>(printer_id);
   printer->set_display_name(printer_name);
   printer->set_description(printer_description);
   printer->set_manufacturer(printer_manufacturer);
   printer->set_model(printer_model);
   printer->set_uri(printer_uri);
 
   // Verify a valid ppd path is present.
   if (!printer_ppd_path.empty()) {
@@ skipping 183 matching lines @@
                          base::Value("on-printer-discovered"), *printers_list);
 }
 
 void CupsPrintersHandler::OnDiscoveryInitialScanDone() {
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::Value("on-printer-discovery-done"));
 }
 
 }  // namespace settings
 }  // namespace chromeos