Completely rewrite the PpdProvider/PpdCache to use the SCS backend. Along the way, clean it up a l…

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"
 #include "base/files/file_util.h"
+#include "base/json/json_string_value_serializer.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/printing/ppd_provider_factory.h"
 #include "chrome/browser/chromeos/printing/printer_pref_manager_factory.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 168 matching lines @@
   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));
   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::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);
   if (!printer_ppd_path.empty()) {
-    printer->mutable_ppd_reference()->user_supplied_ppd_url = printer_ppd_path;
-    if (!ppd_provider_->CachePpd(printer->ppd_reference(),
-                                 base::FilePath(printer_ppd_path))) {
-      LOG(WARNING) << "PPD could not be stored in the cache";
+    printer->mutable_ppd_reference()->user_supplied_ppd_url =
+        "file:///" + printer_ppd_path;
+  } else if (!printer_manufacturer.empty() && !printer_model.empty()) {

[skau, 2017/01/27 01:37:00]

Didn't we remove the effective_manufacturer field?

[Carlson, 2017/01/27 18:48:43]

This is in the dialog, not the ppd reference; we still present to the user as
select a make, then select a model, and we use those pieces of information
together to derive the effective_make_and_model string.

+    // Using the manufacturer and model, get a ppd reference.
+    if (!ppd_provider_->GetPpdReference(printer_manufacturer, printer_model,
+                                        printer->mutable_ppd_reference())) {
+      LOG(ERROR) << "Failed to get ppd reference!";
       OnAddPrinterError();
       return;
     }
-  } 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;
   }
 
   if (printer->IsIppEverywhere()) {
-    AddPrinterToCups(std::move(printer), base::FilePath(), true);
-    return;
+    std::string printer_id = printer->id();
+    std::string printer_uri = printer->uri();
+
+    chromeos::DebugDaemonClient* client =
+        chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
+
+    client->CupsAddAutoConfiguredPrinter(
+        printer_id, printer_uri,
+        base::Bind(&CupsPrintersHandler::OnAddedPrinter,
+                   weak_factory_.GetWeakPtr(), base::Passed(&printer)),
+        base::Bind(&CupsPrintersHandler::OnAddPrinterError,
+                   weak_factory_.GetWeakPtr()));
+  } else {
+    // 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_->ResolvePpd(
+        ppd_reference,
+        base::Bind(&CupsPrintersHandler::ResolvePpdDone,
+                   weak_factory_.GetWeakPtr(), base::Passed(&printer)));
   }
-
-  // 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)));
 }
 
 void CupsPrintersHandler::OnAddedPrinter(std::unique_ptr<Printer> printer,
-                                         bool success) {
+                                         int32_t result_code) {
   std::string printer_name = printer->display_name();
+  bool success = (result_code == 0);
   if (success) {
     PrinterPrefManagerFactory::GetForBrowserContext(profile_)->RegisterPrinter(
         std::move(printer));
   }
   CallJavascriptFunction(
       "cr.webUIListenerCallback", base::StringValue("on-add-cups-printer"),
       base::FundamentalValue(success), base::StringValue(printer_name));
 }
 
 void CupsPrintersHandler::OnAddPrinterError() {
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::StringValue("on-add-cups-printer"),
                          base::FundamentalValue(false), base::StringValue(""));
 }
 
 void CupsPrintersHandler::HandleGetCupsPrinterManufacturers(
     const base::ListValue* args) {
+  AllowJavascript();
   std::string js_callback;
   CHECK_EQ(1U, args->GetSize());
   CHECK(args->GetString(0, &js_callback));
-  ppd_provider_->QueryAvailable(
-      base::Bind(&CupsPrintersHandler::QueryAvailableManufacturersDone,
-                 weak_factory_.GetWeakPtr(),
-                 js_callback));
+  ppd_provider_->ResolveManufacturers(
+      base::Bind(&CupsPrintersHandler::ResolveManufacturersDone,
+                 weak_factory_.GetWeakPtr(), js_callback));
 }
 
 void CupsPrintersHandler::HandleGetCupsPrinterModels(
     const base::ListValue* args) {
+  AllowJavascript();
   std::string js_callback;
   std::string manufacturer;
   CHECK_EQ(2U, args->GetSize());
   CHECK(args->GetString(0, &js_callback));
   CHECK(args->GetString(1, &manufacturer));
-  // Special case the "asked with no manufacturer case" since the UI sometimes
-  // triggers this and it should yield a trivial (empty) result
+
+  // Empty manufacturer queries may be triggered as a part of the ui
+  // initialization, and should just return empty results.
   if (manufacturer.empty()) {
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&CupsPrintersHandler::QueryAvailableModelsDone,
-                   weak_factory_.GetWeakPtr(), js_callback, manufacturer,
-                   chromeos::printing::PpdProvider::SUCCESS,
-                   chromeos::printing::PpdProvider::AvailablePrintersMap()));
-  } else {
-    ppd_provider_->QueryAvailable(
-        base::Bind(&CupsPrintersHandler::QueryAvailableModelsDone,
-                   weak_factory_.GetWeakPtr(), js_callback, manufacturer));
+    base::DictionaryValue response;
+    response.SetBoolean("success", true);
+    response.Set("models", base::MakeUnique<base::ListValue>());
+    ResolveJavascriptCallback(base::StringValue(js_callback), response);
+    return;
   }
+
+  ppd_provider_->ResolvePrinters(
+      manufacturer, base::Bind(&CupsPrintersHandler::ResolvePrintersDone,
+                               weak_factory_.GetWeakPtr(), js_callback));
 }
 
 void CupsPrintersHandler::HandleSelectPPDFile(const base::ListValue* args) {
   CHECK_EQ(1U, args->GetSize());
   CHECK(args->GetString(0, &webui_callback_id_));
 
-  base::FilePath downloads_path = DownloadPrefs::FromDownloadManager(
-      content::BrowserContext::GetDownloadManager(profile_))->DownloadPath();
+  base::FilePath downloads_path =
+      DownloadPrefs::FromDownloadManager(
+          content::BrowserContext::GetDownloadManager(profile_))
+          ->DownloadPath();
 
   select_file_dialog_ = ui::SelectFileDialog::Create(
       this, new ChromeSelectFilePolicy(web_ui()->GetWebContents()));
   gfx::NativeWindow owning_window =
       chrome::FindBrowserWithWebContents(web_ui()->GetWebContents())
           ->window()
           ->GetNativeWindow();
   select_file_dialog_->SelectFile(
       ui::SelectFileDialog::SELECT_OPEN_FILE, base::string16(), downloads_path,
       nullptr, 0, FILE_PATH_LITERAL(""), owning_window, nullptr);
 }
 
-void CupsPrintersHandler::QueryAvailableManufacturersDone(
+void CupsPrintersHandler::ResolveManufacturersDone(
     const std::string& js_callback,
     chromeos::printing::PpdProvider::CallbackResultCode result_code,
-    const chromeos::printing::PpdProvider::AvailablePrintersMap& available) {
-  auto manufacturers = base::MakeUnique<base::ListValue>();
+    const std::vector<std::string>& manufacturers) {
+  auto manufacturers_value = base::MakeUnique<base::ListValue>();
   if (result_code == chromeos::printing::PpdProvider::SUCCESS) {
-    for (const auto& entry : available) {
-      manufacturers->AppendString(entry.first);
-    }
+    manufacturers_value->AppendStrings(manufacturers);
   }
   base::DictionaryValue response;
   response.SetBoolean("success",
                       result_code == chromeos::printing::PpdProvider::SUCCESS);
-  response.Set("manufacturers", std::move(manufacturers));
+  response.Set("manufacturers", std::move(manufacturers_value));
   ResolveJavascriptCallback(base::StringValue(js_callback), response);
 }
 
-void CupsPrintersHandler::QueryAvailableModelsDone(
+void CupsPrintersHandler::ResolvePrintersDone(
     const std::string& js_callback,
-    const std::string& manufacturer,
     chromeos::printing::PpdProvider::CallbackResultCode result_code,
-    const chromeos::printing::PpdProvider::AvailablePrintersMap& available) {
-  auto models = base::MakeUnique<base::ListValue>();
+    const std::vector<std::string>& printers) {
+  auto printers_value = base::MakeUnique<base::ListValue>();
   if (result_code == chromeos::printing::PpdProvider::SUCCESS) {
-    const auto it = available.find(manufacturer);
-    if (it != available.end()) {
-      // Everything looks good.
-      models->AppendStrings(it->second);
-    }
+    printers_value->AppendStrings(printers);
   }
   base::DictionaryValue response;
   response.SetBoolean("success",
-                       result_code == chromeos::printing::PpdProvider::SUCCESS);
-  response.Set("models", std::move(models));
+                      result_code == chromeos::printing::PpdProvider::SUCCESS);
+  response.Set("models", std::move(printers_value));
   ResolveJavascriptCallback(base::StringValue(js_callback), response);
 }
 
 void CupsPrintersHandler::FileSelected(const base::FilePath& path,
                                        int index,
                                        void* params) {
   DCHECK(!webui_callback_id_.empty());
   ResolveJavascriptCallback(base::StringValue(webui_callback_id_),
                             base::StringValue(path.value()));
   webui_callback_id_.clear();
@@ skipping 32 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 base::FilePath& ppd_path,
-                                           bool ipp_everywhere) {
+void CupsPrintersHandler::ResolvePpdDone(
+    std::unique_ptr<Printer> printer,
+    printing::PpdProvider::CallbackResultCode result,
+    const std::string& ppd_contents) {
+  if (result != printing::PpdProvider::SUCCESS) {
+    // TODO(skau): Add appropriate failure modes crbug.com/670068.
+    LOG(ERROR) << "Error resolving";
+    OnAddPrinterError();
+    return;
+  }
+
   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.value(), ipp_everywhere,
+
+  client->CupsAddManuallyConfiguredPrinter(
+      printer_id, printer_uri, ppd_contents,
       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, false /* never ipp everywhere */);
-}
-
 }  // namespace settings
 }  // namespace chromeos