Separate manufacturer and model fields from PPD info

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 310 matching lines @@
   const base::DictionaryValue* printer_dict = nullptr;
   CHECK(args->GetDictionary(0, &printer_dict));
 
   std::string printer_id;
   std::string printer_name;
   std::string printer_description;
   std::string printer_manufacturer;
   std::string printer_model;
   std::string printer_address;
   std::string printer_protocol;
-  std::string printer_ppd_path;
   CHECK(printer_dict->GetString("printerId", &printer_id));
   CHECK(printer_dict->GetString("printerName", &printer_name));
   CHECK(printer_dict->GetString("printerDescription", &printer_description));
   CHECK(printer_dict->GetString("printerManufacturer", &printer_manufacturer));

[xdai1, 2017/07/01 00:00:11]

printer_manufacturer and printer_model won't have value any more after this
change, right? 

[skau, 2017/07/01 00:11:49]

We still need them since we'll have old clients floating around.
go/bolton-make-model-migration

   CHECK(printer_dict->GetString("printerModel", &printer_model));
   CHECK(printer_dict->GetString("printerAddress", &printer_address));
   CHECK(printer_dict->GetString("printerProtocol", &printer_protocol));
 
   std::string printer_queue = GetPrinterQueue(*printer_dict);
 
   std::string printer_uri =
       printer_protocol + url::kStandardSchemeSeparator + printer_address;
   if (!printer_queue.empty()) {
     printer_uri += "/" + printer_queue;
   }
 
-  // printerPPDPath might be null for an auto-discovered printer.
+  // Read PPD selection if it was used.
+  std::string ppd_manufacturer;
+  std::string ppd_model;
+  printer_dict->GetString("ppdManufacturer", &ppd_manufacturer);
+  printer_dict->GetString("ppdModel", &ppd_model);
+
+  // Read user provided PPD if it was used.
+  std::string printer_ppd_path;
   printer_dict->GetString("printerPPDPath", &printer_ppd_path);
 
   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);
 
   bool autoconf = false;
   printer_dict->GetBoolean("printerAutoconf", &autoconf);
 
   // Verify that the printer is autoconf or a valid ppd path is present.
   if (autoconf) {
     printer->mutable_ppd_reference()->autoconf = true;
   } else if (!printer_ppd_path.empty()) {
     RecordPpdSource(kUser);
     GURL tmp = net::FilePathToFileURL(base::FilePath(printer_ppd_path));
     if (!tmp.is_valid()) {
       LOG(ERROR) << "Invalid ppd path: " << printer_ppd_path;
       OnAddPrinterError();
       return;
     }
     printer->mutable_ppd_reference()->user_supplied_ppd_url = tmp.spec();
-  } else if (!printer_manufacturer.empty() && !printer_model.empty()) {
+  } else if (!ppd_manufacturer.empty() && !ppd_model.empty()) {
     RecordPpdSource(kScs);
     // Using the manufacturer and model, get a ppd reference.
-    if (!ppd_provider_->GetPpdReference(printer_manufacturer, printer_model,
+    if (!ppd_provider_->GetPpdReference(ppd_manufacturer, ppd_model,
                                         printer->mutable_ppd_reference())) {
       LOG(ERROR) << "Failed to get ppd reference";
       OnAddPrinterError();
       return;
     }
+
+    if (printer->make_and_model().empty()) {
+      // In lieu of more accurate information, populate the make and model
+      // fields with the PPD information.
+      printer->set_manufacturer(ppd_manufacturer);
+      printer->set_model(ppd_model);
+      // PPD Model names are actually make and model.
+      printer->set_make_and_model(ppd_model);
+    }
+  } else {
+    // TODO(crbug.com/738514): Support PPD guessing for non-autoconf printers.
+    // i.e. !autoconf && !manufacturer.empty() && !model.empty()
+    NOTREACHED()
+        << "A configuration option must have been selected to add a printer";
   }
 
   // Copy the printer for the configurer.  Ownership needs to be transfered to
   // the receiver of the callback.
   const Printer printer_copy = *printer;
   printer_configurer_->SetUpPrinter(
       printer_copy,
       base::Bind(&CupsPrintersHandler::OnAddedPrinter,
                  weak_factory_.GetWeakPtr(), base::Passed(&printer)));
 }
@@ skipping 175 matching lines @@
 }
 
 void CupsPrintersHandler::OnPrinterScanComplete() {
   UMA_HISTOGRAM_COUNTS_100("Printing.CUPS.PrintersDiscovered",
                            printer_detector_->GetPrinters().size());
   FireWebUIListener("on-printer-discovery-done");
 }
 
 }  // namespace settings
 }  // namespace chromeos