Hookup the PpdProvider in the printer setup flow.

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 190 matching lines @@
   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::unique_ptr<Printer> printer = base::MakeUnique<Printer>(printer_id);
-  printer_id = 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);
   if (!printer_ppd_path.empty()) {
     printer->mutable_ppd_reference()->user_supplied_ppd_url = printer_ppd_path;
+    bool cached = ppd_provider_->CachePpd(printer->ppd_reference(),
+                                          base::FilePath(printer_ppd_path));
+    VLOG(1) << "PPD Cached: " << cached;

[dpapad, 2016/12/05 23:09:12]

Is this VLOG useful enough to be checked in?

[skau, 2016/12/06 20:55:46]

This actually needs to be handled as an error.  I've changed it accordingly.

   } else if (!printer_manufacturer.empty() && !printer_model.empty()) {
     Printer::PpdReference* ppd = printer->mutable_ppd_reference();
     ppd->effective_manufacturer = printer_manufacturer;
     ppd->effective_model = printer_model;
   }
 
-  chromeos::DebugDaemonClient* client =
-      chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
-  client->CupsAddPrinter(
-      printer_id,                               // record id
-      printer_uri,                              // uri
-      printer_ppd_path,                         // ppd location
-      printer_ppd_path.empty() ? true : false,  // ipp everywhere
-      base::Bind(&CupsPrintersHandler::OnAddedPrinter,
-                 weak_factory_.GetWeakPtr(), base::Passed(std::move(printer))),
-      base::Bind(&CupsPrintersHandler::OnAddPrinterError,
-                 weak_factory_.GetWeakPtr()));
+  if (printer->IsIppEverywhere()) {
+    AddPrinterToCups(std::move(printer), "", true);
+    return;
+  }
+
+  // We need to save a reference to members of printer since we transfer
+  // ownership in the bind call.
+  const Printer::PpdReference& ppd_reference = printer->ppd_reference();
+  ppd_provider_->Resolve(
+      ppd_reference,
+      base::Bind(&CupsPrintersHandler::OnPPDResolved,
+                 weak_factory_.GetWeakPtr(), base::Passed(&printer)));

[xdai1, 2016/12/01 23:18:17]

Is base::Passed(&printer)) preferred over base::Passed(std::move(printer))?

[skau, 2016/12/05 20:40:51]

They are equivalent.  The post in chromium-dev that introduced unique_ptr
suggested & since it's shorter.

 }
 
 void CupsPrintersHandler::OnAddedPrinter(std::unique_ptr<Printer> printer,
                                          bool success) {
   std::string printer_name = printer->display_name();
   if (success) {
     PrinterPrefManagerFactory::GetForBrowserContext(profile_)->RegisterPrinter(
         std::move(printer));
   }
   CallJavascriptFunction(
@@ skipping 138 matching lines @@
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::StringValue("on-printer-discovered"),
                          *printers_list);
 }
 
 void CupsPrintersHandler::OnDiscoveryDone() {
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::StringValue("on-printer-discovery-done"));
 }
 
+void CupsPrintersHandler::AddPrinterToCups(std::unique_ptr<Printer> printer,
+                                           const std::string& ppd_path,
+                                           bool ipp_everywhere) {
+  std::string printer_id = printer->id();
+  std::string printer_uri = printer->uri();
+
+  chromeos::DebugDaemonClient* client =
+      chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
+  client->CupsAddPrinter(
+      printer_id, printer_uri, ppd_path, ipp_everywhere,
+      base::Bind(&CupsPrintersHandler::OnAddedPrinter,
+                 weak_factory_.GetWeakPtr(), base::Passed(&printer)),
+      base::Bind(&CupsPrintersHandler::OnAddPrinterError,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void CupsPrintersHandler::OnPPDResolved(
+    std::unique_ptr<Printer> printer,
+    printing::PpdProvider::CallbackResultCode result,
+    base::FilePath path) {
+  if (result != printing::PpdProvider::SUCCESS) {
+    // TODO(skau): Add appropriate failure modes crbug.com/670068.
+    OnAddPrinterError();
+    return;
+  }
+
+  AddPrinterToCups(std::move(printer), path.value(),
+                   false /* never ipp everywhere */);
+}
+
 }  // namespace settings
 }  // namespace chromeos