Initial hookup of PpdProvider.

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 <memory>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
+#include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/printing/printer_pref_manager_factory.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
+#include "chrome/common/chrome_paths.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/debug_daemon_client.h"
 #include "chromeos/printing/fake_printer_discoverer.h"
+#include "chromeos/printing/ppd_cache.h"
+#include "chromeos/printing/ppd_provider.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_ui.h"
+#include "google_apis/google_api_keys.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "printing/backend/print_backend.h"
 #include "url/third_party/mozilla/url_parse.h"
 
 namespace chromeos {
 namespace settings {
 
 namespace {
 
 void OnRemovedPrinter(bool success) {}
 
@@ skipping 27 matching lines @@
     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) {}
+      weak_factory_(this) {
+  base::FilePath ppd_cache_path;
+  CHECK(
+      base::PathService::Get(chrome::DIR_CHROMEOS_PPD_CACHE, &ppd_cache_path));
+  ppd_provider_ = chromeos::printing::PpdProvider::Create(
+      google_apis::GetAPIKey(), g_browser_process->system_request_context(),
+      chromeos::printing::PpdCache::Create(ppd_cache_path));
+}
 
 CupsPrintersHandler::~CupsPrintersHandler() {}
 
 void CupsPrintersHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "getCupsPrintersList",
       base::Bind(&CupsPrintersHandler::HandleGetCupsPrintersList,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "updateCupsPrinter",
       base::Bind(&CupsPrintersHandler::HandleUpdateCupsPrinter,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "removeCupsPrinter",
       base::Bind(&CupsPrintersHandler::HandleRemoveCupsPrinter,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "addCupsPrinter", base::Bind(&CupsPrintersHandler::HandleAddCupsPrinter,
                                    base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
+      "getCupsPrinterManufacturersList",
+      base::Bind(&CupsPrintersHandler::HandleGetCupsPrinterManufacturers,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "getCupsPrinterModelsList",
+      base::Bind(&CupsPrintersHandler::HandleGetCupsPrinterModels,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
       "selectPPDFile", base::Bind(&CupsPrintersHandler::HandleSelectPPDFile,
                                   base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "startDiscoveringPrinters",
       base::Bind(&CupsPrintersHandler::HandleStartDiscovery,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "stopDiscoveringPrinters",
       base::Bind(&CupsPrintersHandler::HandleStopDiscovery,
                  base::Unretained(this)));
@@ skipping 109 matching lines @@
       "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) {
+  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));
+}
+
+void CupsPrintersHandler::HandleGetCupsPrinterModels(
+    const base::ListValue* args) {
+  std::string js_callback;
+  std::string manufacturer;
+  CHECK_EQ(2U, args->GetSize());
+  CHECK(args->GetString(0, &js_callback));
+  CHECK(args->GetString(1, &manufacturer));
+  ppd_provider_->QueryAvailable(
+      base::Bind(&CupsPrintersHandler::QueryAvailableModelsDone,
+                 weak_factory_.GetWeakPtr(), js_callback, manufacturer));
+}
+
 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();
 
   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(
+    const std::string& js_callback,
+    chromeos::printing::PpdProvider::CallbackResultCode result_code,
+    const chromeos::printing::PpdProvider::AvailablePrintersMap& available) {
+  auto manufacturers = base::MakeUnique<base::ListValue>();
+  if (result_code == chromeos::printing::PpdProvider::SUCCESS) {
+    for (const auto& entry : available) {
+      manufacturers->AppendString(entry.first);
+    }
+  }
+  base::DictionaryValue response;
+  response.SetBoolean("success",
+                      result_code == chromeos::printing::PpdProvider::SUCCESS);
+  response.Set("manufacturers", std::move(manufacturers));
+  ResolveJavascriptCallback(base::StringValue(js_callback), response);
+}
+
+void CupsPrintersHandler::QueryAvailableModelsDone(
+    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>();
+  if (result_code == chromeos::printing::PpdProvider::SUCCESS) {
+    const auto it = available.find(manufacturer);
+    if (it != available.end()) {
+      // Everything looks good.
+      models->AppendStrings(it->second);
+    }
+  }
+  base::DictionaryValue response;
+  response.SetBoolean("success",
+                       result_code == chromeos::printing::PpdProvider::SUCCESS);
+  response.Set("models", std::move(models));
+  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();
 }
 
 void CupsPrintersHandler::HandleStartDiscovery(const base::ListValue* args) {
@@ skipping 31 matching lines @@
                          *printers_list);
 }
 
 void CupsPrintersHandler::OnDiscoveryDone() {
   CallJavascriptFunction("cr.webUIListenerCallback",
                          base::StringValue("on-printer-discovery-done"));
 }
 
 }  // namespace settings
 }  // namespace chromeos