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;
   } 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()));
+  const Printer::PpdReference& ppd_reference = printer->ppd_reference();

[Carlson, 2016/12/01 01:58:44]

Add a comment about why you're doing this?  Someone, someday is going to say
"Hey this is sort of a pointless temporary", remove it, and write
printer->ppd_reference() in the Resolve() below and there will be much
puzzlement and gnashing of teeth.

(At first glance *I* thought this was a pretty pointless temporary.  And I was
just bitten by this same sort of bug 2 weeks ago...)

[skau, 2016/12/01 21:45:12]

I really wish this was a compiler warning.  I've added a comment but the wording
isn't great.

+  ppd_provider_->Resolve(
+      ppd_reference,
+      base::Bind(&CupsPrintersHandler::OnPPDResolved,
+                 weak_factory_.GetWeakPtr(), base::Passed(&printer)));
 }
 
 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::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;
+  }
+
+  bool ipp_everywhere = Printer::IsIppEverywhere(*printer);
+  std::string ppd_path = ipp_everywhere ? "" : path.value();

[Carlson, 2016/12/01 01:58:44]

Wait, what?  So if it's an ipp everywhere printer we go out and try to resolve
it and then if we do resolve it successfully, we ignore the result?  I don't
understand what you're doing here.

[skau, 2016/12/01 21:45:12]

What I'm doing here makes no sense.  I've moved the IPP Everywhere check to
before the resolve call since IPP Everwhere should be keyed by
effective_manufacturer and effective_model and doesn't require a Resolve call.

+  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()));
+}
+
 }  // namespace settings
 }  // namespace chromeos