Query printers for autoconf info during setup.

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/metrics/histogram_macros.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_configurer.h"
 #include "chrome/browser/chromeos/printing/printer_discoverer.h"
+#include "chrome/browser/chromeos/printing/printer_info.h"
 #include "chrome/browser/chromeos/printing/printers_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/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/base/filename_util.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 {
 
+const char kIppScheme[] = "ipp";
+const char kIppsScheme[] = "ipps";
+
 void OnRemovedPrinter(bool success) {}
 
 std::unique_ptr<base::DictionaryValue> GetPrinterInfo(const Printer& printer) {
   std::unique_ptr<base::DictionaryValue> printer_info =
       base::MakeUnique<base::DictionaryValue>();
   printer_info->SetString("printerId", printer.id());
   printer_info->SetString("printerName", printer.display_name());
   printer_info->SetString("printerDescription", printer.description());
   printer_info->SetString("printerManufacturer", printer.manufacturer());
   printer_info->SetString("printerModel", printer.model());
@@ skipping 51 matching lines @@
       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(
+      "getPrinterInfo", base::Bind(&CupsPrintersHandler::HandleGetPrinterInfo,
+                                   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)));
@@ skipping 49 matching lines @@
   CHECK(args->GetString(1, &printer_name));
   PrintersManagerFactory::GetForBrowserContext(profile_)->RemovePrinter(
       printer_id);
 
   chromeos::DebugDaemonClient* client =
       chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
   client->CupsRemovePrinter(printer_name, base::Bind(&OnRemovedPrinter),
                             base::Bind(&base::DoNothing));
 }
 
+void CupsPrintersHandler::HandleGetPrinterInfo(const base::ListValue* args) {
+  DCHECK(args);
+  std::string callback_id;
+  if (!args->GetString(0, &callback_id)) {
+    NOTREACHED() << "Expected request for a promise";
+    return;
+  }
+
+  const base::DictionaryValue* printer_dict = nullptr;
+  if (!args->GetDictionary(1, &printer_dict)) {
+    NOTREACHED() << "Dictionary missing";
+    return;
+  }
+
+  AllowJavascript();
+
+  std::string printer_address;
+  if (!printer_dict->GetString("printerAddress", &printer_address)) {
+    NOTREACHED() << "Address missing";
+    return;
+  }
+
+  if (printer_address.empty()) {
+    // Run the failure callback.

[Carlson, 2017/05/31 16:58:52]

I'm confused about when you do and don't run the failure callback.  For the
NOTREACHED conditions above, if you reach them, what's the effect?  We'll hang
forever waiting for the promise?

[skau, 2017/06/01 21:50:29]

We run the failure callback for expected failures.  The NOTREACHED() sections
indicate places where there's been a violation of expected calling conditions.

+    OnPrinterInfo(callback_id, false, "", "", false);
+    return;
+  }
+
+  std::string printer_queue;
+  printer_dict->GetString("printerQueue", &printer_queue);
+
+  std::string printer_protocol;
+  if (!printer_dict->GetString("printerProtocol", &printer_protocol)) {
+    NOTREACHED() << "Protocol missing";
+    return;
+  }
+
+  std::string printer_uri = printer_protocol + url::kStandardSchemeSeparator +
+                            printer_address + "/" + printer_queue;

[Carlson, 2017/05/31 16:58:52]

I don't understand why you assemble a uri and then parse it back out again.  Is
it so you can pull out the port?  Could use some commenting

Also, do you need to be paranoid about badly-formed printer_address input making
things like parsed.path.len -1?

[skau, 2017/06/01 21:50:29]

It is just for the port so the whole uri doesn't need to be constructed then
deconstructed.  Lengths won't be negative for any of the Components as
ParseStandardURL will attempt to extract all components.  len could be 0, but it
won't be -1.

[skau, 2017/06/07 23:55:39]

So, I was wrong.  If there's no scheme (aka protocol) the parsing falls over.

+  const char* uri_ptr = printer_uri.c_str();
+  url::Parsed parsed;
+  url::ParseStandardURL(uri_ptr, printer_uri.length(), &parsed);
+  base::StringPiece host(&uri_ptr[parsed.host.begin], parsed.host.len);
+  base::StringPiece path(&uri_ptr[parsed.path.begin], parsed.path.len);
+
+  int port = ParsePort(uri_ptr, parsed.port);
+  if (port == url::SpecialPort::PORT_UNSPECIFIED ||
+      port == url::SpecialPort::PORT_INVALID) {
+    // imply port from protocol
+    if (printer_protocol == kIppScheme) {
+      port = 631;
+    } else if (printer_protocol == kIppsScheme) {
+      // ipps is ipp over https so it uses the https port.
+      port = 443;
+    } else {
+      NOTREACHED() << "Unrecognized protocol.  Port was not set.";
+    }
+  }
+
+  ::chromeos::QueryIppPrinter(
+      host.as_string(), port, path.as_string(),
+      base::Bind(&CupsPrintersHandler::OnPrinterInfo,
+                 weak_factory_.GetWeakPtr(), callback_id));
+}
+
 void CupsPrintersHandler::HandleAddCupsPrinter(const base::ListValue* args) {
   AllowJavascript();
 
   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_queue;
   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;
+  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.
+  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);
 
-  // Verify a valid ppd path is present.
-  if (!printer_ppd_path.empty()) {
+  bool autoconf = false;
+  printer_dict->GetBoolean("autoconf", &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()) {
     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()) {
     // Using the manufacturer and model, get a ppd reference.
     if (!ppd_provider_->GetPpdReference(printer_manufacturer, printer_model,
@@ skipping 173 matching lines @@
   }
 
   FireWebUIListener("on-printer-discovered", *printers_list);
 }
 
 void CupsPrintersHandler::OnDiscoveryInitialScanDone(int printer_count) {
   UMA_HISTOGRAM_COUNTS_100("Printing.CUPS.PrintersDiscovered", printer_count);
   FireWebUIListener("on-printer-discovery-done");
 }
 
+void CupsPrintersHandler::OnPrinterInfo(const std::string& callback_id,
+                                        bool success,
+                                        const std::string& make,
+                                        const std::string& model,
+                                        bool ipp_everywhere) {
+  if (!success) {
+    base::DictionaryValue reject;
+    reject.SetString("message", "Querying printer failed");
+    RejectJavascriptCallback(base::Value(callback_id), reject);
+    return;
+  }
+
+  base::DictionaryValue info;
+  info.SetString("manufacturer", make);
+  info.SetString("model", model);
+  info.SetBoolean("autoconf", ipp_everywhere);
+  ResolveJavascriptCallback(base::Value(callback_id), info);
+}
+
 }  // namespace settings
 }  // namespace chromeos