Add PIN printing support check for CUPS IPP backend.

Bug: 848942
Change-Id: Icf6d930686264edf14970d38f58485c4310f5ecf
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1474750
Commit-Queue: Nikita Podguzov <nikitapodguzov@google.com>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Vladislav Kuzkokov <vkuzkokov@chromium.org>
Reviewed-by: Sean Kau <skau@chromium.org>
Reviewed-by: Rebekah Potter <rbpotter@chromium.org>
Cr-Commit-Position: refs/heads/master@{#638179}

chrome/browser/resources/print_preview/data/destination.js

@@ -115,6 +115,8 @@ print_preview.VendorCapability;
 
 /**
  * Capabilities of a print destination represented in a CDD.
+ * Pin capability is not a part of standard CDD description and is defined only
+ * on Chrome OS.
  *
  * @typedef {{
  *   vendor_capability: !Array<!print_preview.VendorCapability>,
@@ -150,7 +152,8 @@ print_preview.VendorCapability;
  *       vertical_dpi: number,
  *       is_default: (boolean|undefined)
  *     }>
- *   }|undefined)
+ *   }|undefined),
+ *   pin: ({supported: (boolean|undefined)}|undefined)
  * }}
  */
 print_preview.CddCapabilities;

components/cloud_devices/common/printer_description.cc

@@ -60,6 +60,9 @@ extern const char kOptionRangeCapability[] = "range_cap";
 extern const char kOptionSelectCapability[] = "select_cap";
 extern const char kOptionTypedValueCapability[] = "typed_value_cap";
 extern const char kOptionVendorCapability[] = "vendor_capability";
+#if defined(OS_CHROMEOS)
+extern const char kOptionPin[] = "pin";
+#endif  // defined(OS_CHROMEOS)
 
 const char kMarginBottom[] = "bottom_microns";
 const char kMarginLeft[] = "left_microns";
@@ -86,6 +89,10 @@ const char kVendorCapabilityMinValue[] = "min";
 const char kVendorCapabilityMaxValue[] = "max";
 const char kVendorCapabilityDefaultValue[] = "default";
 
+#if defined(OS_CHROMEOS)
+const char kPinSupported[] = "supported";
+#endif  // defined(OS_CHROMEOS)
+
 const char kTypeRangeVendorCapabilityFloat[] = "FLOAT";
 const char kTypeRangeVendorCapabilityInteger[] = "INTEGER";
 
@@ -1346,6 +1353,23 @@ class ReverseTraits : public NoValueValidation,
   }
 };
 
+#if defined(OS_CHROMEOS)
+class PinTraits : public NoValueValidation, public ItemsTraits<kOptionPin> {
+ public:
+  static bool Load(const base::Value& dict, bool* option) {
+    base::Optional<bool> supported = dict.FindBoolKey(kPinSupported);
+    if (!supported)
+      return false;
+    *option = supported.value();
+    return true;
+  }
+
+  static void Save(bool option, base::Value* dict) {
+    dict->SetKey(kPinSupported, base::Value(option));
+  }
+};
+#endif  // defined(OS_CHROMEOS)
+
 }  // namespace printer
 
 using namespace printer;
@@ -1366,6 +1390,9 @@ template class EmptyCapability<class CopiesTraits>;
 template class EmptyCapability<class PageRangeTraits>;
 template class BooleanCapability<class CollateTraits>;
 template class BooleanCapability<class ReverseTraits>;
+#if defined(OS_CHROMEOS)
+template class ValueCapability<bool, class PinTraits>;
+#endif  // defined(OS_CHROMEOS)
 
 template class TicketItem<PwgRasterConfig, PwgRasterConfigTraits>;
 template class TicketItem<Color, ColorTraits>;

components/cloud_devices/common/printer_description.h

@@ -12,6 +12,7 @@
 
 #include "base/logging.h"
 #include "base/optional.h"
+#include "build/build_config.h"
 #include "components/cloud_devices/common/description_items.h"
 
 // Defines printer options, CDD and CJT items.
@@ -510,6 +511,11 @@ typedef EmptyCapability<class CopiesTraits> CopiesCapability;
 typedef EmptyCapability<class PageRangeTraits> PageRangeCapability;
 typedef BooleanCapability<class CollateTraits> CollateCapability;
 typedef BooleanCapability<class ReverseTraits> ReverseCapability;
+#if defined(OS_CHROMEOS)
+// This capability is not a part of standard CDD description. It's used for
+// providing PIN printing opportunity in Chrome OS native printing.
+typedef ValueCapability<bool, class PinTraits> PinCapability;
+#endif  // defined(OS_CHROMEOS)
 
 typedef TicketItem<PwgRasterConfig, PwgRasterConfigTraits>
     PwgRasterConfigTicketItem;

components/cloud_devices/common/printer_description_unittest.cc

@@ -519,6 +519,18 @@ const char kSeveralInnerCapabilitiesVendorCapabilityCdd[] =
     "  }"
     "}";
 
+#if defined(OS_CHROMEOS)
+const char kPinOnlyCdd[] =
+    "{"
+    "  'version': '1.0',"
+    "  'printer': {"
+    "    'pin': {"
+    "      'supported': true"
+    "    }"
+    "  }"
+    "}";
+#endif  // defined(OS_CHROMEOS)
+
 const char kCjt[] =
     "{"
     "  'version': '1.0',"
@@ -1083,6 +1095,34 @@ TEST(PrinterDescriptionTest, CddSetVendorCapability) {
             NormalizeJson(description.ToString()));
 }
 
+#if defined(OS_CHROMEOS)
+TEST(PrinterDescriptionTest, CddGetPin) {
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(description.InitFromString(NormalizeJson(kPinOnlyCdd)));
+
+    PinCapability pin_capability;
+    EXPECT_TRUE(pin_capability.LoadFrom(description));
+    EXPECT_TRUE(pin_capability.value());
+  }
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(description.InitFromString(NormalizeJson(kDefaultCdd)));
+    PinCapability pin_capability;
+    EXPECT_FALSE(pin_capability.LoadFrom(description));
+  }
+}
+
+TEST(PrinterDescriptionTest, CddSetPin) {
+  CloudDeviceDescription description;
+
+  PinCapability pin_capability;
+  pin_capability.set_value(true);
+  pin_capability.SaveTo(&description);
+  EXPECT_EQ(NormalizeJson(kPinOnlyCdd), NormalizeJson(description.ToString()));
+}
+#endif  // defined(OS_CHROMEOS)
+
 TEST(PrinterDescriptionTest, CddGetAll) {
   CloudDeviceDescription description;
   ASSERT_TRUE(description.InitFromString(NormalizeJson(kCdd)));

components/printing/common/cloud_print_cdd_conversion.cc

@@ -141,6 +141,12 @@ base::Value PrinterSemanticCapsAndDefaultsToCdd(
   orientation.AddOption(OrientationType::AUTO_ORIENTATION);
   orientation.SaveTo(&description);
 
+#if defined(OS_CHROMEOS)
+  PinCapability pin;
+  pin.set_value(semantic_info.pin_supported);
+  pin.SaveTo(&description);
+#endif  // defined(OS_CHROMEOS)
+
   return std::move(description).ToValue();
 }
 

printing/backend/cups_ipp_util.cc

@@ -32,11 +32,16 @@ constexpr char kIppDuplex[] = CUPS_SIDES;
 constexpr char kIppResolution[] = "printer-resolution";  // RFC 2911
 constexpr char kIppDocumentName[] = "document-name";     // RFC 8011
 constexpr char kIppRequestingUserName[] = "requesting-user-name";  // RFC 8011
+constexpr char kIppPin[] = "job-password";                       // PWG 5100.11
+constexpr char kIppPinEncryption[] = "job-password-encryption";  // PWG 5100.11
 
 // collation values
 constexpr char kCollated[] = "collated";
 constexpr char kUncollated[] = "uncollated";
 
+constexpr int kPinMinimumLength = 4;
+constexpr char kPinEncryptionNone[] = "none";
+
 namespace {
 
 constexpr int kMicronsPerMM = 1000;
@@ -308,8 +313,7 @@ void CopiesRange(const CupsOptionProvider& printer,
 bool CollateCapable(const CupsOptionProvider& printer) {
   std::vector<base::StringPiece> values =
       printer.GetSupportedOptionValueStrings(kIppCollate);
-  auto iter = std::find(values.begin(), values.end(), kCollated);
-  return iter != values.end();
+  return base::ContainsValue(values, kCollated);
 }
 
 bool CollateDefault(const CupsOptionProvider& printer) {
@@ -321,6 +325,19 @@ bool CollateDefault(const CupsOptionProvider& printer) {
   return name.compare(kCollated) == 0;
 }
 
+bool PinSupported(const CupsOptionProvider& printer) {
+  ipp_attribute_t* attr = printer.GetSupportedOptionValues(kIppPin);
+  if (!attr)
+    return false;
+  int password_maximum_length_supported = ippGetInteger(attr, 0);
+  if (password_maximum_length_supported < kPinMinimumLength)
+    return false;
+
+  std::vector<base::StringPiece> values =
+      printer.GetSupportedOptionValueStrings(kIppPinEncryption);
+  return base::ContainsValue(values, kPinEncryptionNone);
+}
+
 void CapsAndDefaultsFromPrinter(const CupsOptionProvider& printer,
                                 PrinterSemanticCapsAndDefaults* printer_info) {
   // collate
@@ -331,6 +348,10 @@ void CapsAndDefaultsFromPrinter(const CupsOptionProvider& printer,
   printer_info->default_paper = DefaultPaper(printer);
   printer_info->papers = SupportedPapers(printer);
 
+#if defined(OS_CHROMEOS)
+  printer_info->pin_supported = PinSupported(printer);
+#endif  // defined(OS_CHROMEOS)
+
   ExtractCopies(printer, printer_info);
   ExtractColor(printer, printer_info);
   ExtractDuplexModes(printer, printer_info);

printing/backend/cups_ipp_util_unittest.cc

@@ -81,6 +81,11 @@ class PrintBackendCupsIppUtilTest : public ::testing::Test {
   std::unique_ptr<MockCupsOptionProvider> printer_;
 };
 
+ipp_attribute_t* MakeInteger(ipp_t* ipp, int value) {
+  return ippAddInteger(ipp, IPP_TAG_PRINTER, IPP_TAG_INTEGER, "TEST_DATA",
+                       value);
+}
+
 ipp_attribute_t* MakeRange(ipp_t* ipp, int lower_bound, int upper_bound) {
   return ippAddRange(ipp, IPP_TAG_PRINTER, "TEST_DATA", lower_bound,
                      upper_bound);
@@ -194,4 +199,43 @@ TEST_F(PrintBackendCupsIppUtilTest, LegalPaperDefault) {
   EXPECT_EQ(355600, caps.default_paper.size_um.height());
 }
 
+TEST_F(PrintBackendCupsIppUtilTest, PinSupported) {
+  printer_->SetSupportedOptions("job-password", MakeInteger(ipp_, 4));
+  printer_->SetSupportedOptions("job-password-encryption",
+                                MakeStringCollection(ipp_, {"none"}));
+
+  PrinterSemanticCapsAndDefaults caps;
+  CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_TRUE(caps.pin_supported);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, PinNotSupported) {
+  // Pin support missing, no setup.
+  PrinterSemanticCapsAndDefaults caps;
+  CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_FALSE(caps.pin_supported);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, PinEncryptionNotSupported) {
+  printer_->SetSupportedOptions("job-password", MakeInteger(ipp_, 4));
+
+  PrinterSemanticCapsAndDefaults caps;
+  CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_FALSE(caps.pin_supported);
+}
+
+TEST_F(PrintBackendCupsIppUtilTest, PinTooShort) {
+  printer_->SetSupportedOptions("job-password", MakeInteger(ipp_, 3));
+  printer_->SetSupportedOptions("job-password-encryption",
+                                MakeStringCollection(ipp_, {"none"}));
+
+  PrinterSemanticCapsAndDefaults caps;
+  CapsAndDefaultsFromPrinter(*printer_, &caps);
+
+  EXPECT_FALSE(caps.pin_supported);
+}
+
 }  // namespace printing

printing/backend/print_backend.h

@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "base/memory/ref_counted.h"
+#include "build/build_config.h"
 #include "printing/print_job_constants.h"
 #include "printing/printing_export.h"
 #include "ui/gfx/geometry/size.h"
@@ -67,6 +68,10 @@ struct PRINTING_EXPORT PrinterSemanticCapsAndDefaults {
 
   std::vector<gfx::Size> dpis;
   gfx::Size default_dpi;
+
+#if defined(OS_CHROMEOS)
+  bool pin_supported = false;
+#endif  // defined(OS_CHROMEOS)
 };
 
 struct PRINTING_EXPORT PrinterCapsAndDefaults {