BASELINE: Update Chromium to 74.0.3729.159

Change-Id: I8d2497da544c275415aedd94dd25328d555de811
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

1 files changed, 868 insertions, 342 deletions

diff --git a/chromium/components/cloud_devices/common/printer_description.cc b/chromium/components/cloud_devices/common/printer_description.cc
index 733c1dc1ea6..f96b8f9eef4 100644
--- a/chromium/components/cloud_devices/common/printer_description.cc
+++ b/chromium/components/cloud_devices/common/printer_description.cc
@@ -9,10 +9,13 @@
 #include <algorithm>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "components/cloud_devices/common/cloud_device_description_consts.h"
@@ -29,10 +32,14 @@ const int32_t kMaxPageNumber = 1000000;
 const char kSectionPrint[] = "print";
 const char kSectionPrinter[] = "printer";
 
-const char kCustomName[] = "custom_display_name";
+const char kKeyCustomDisplayName[] = "custom_display_name";
 const char kKeyContentType[] = "content_type";
+const char kKeyDisplayName[] = "display_name";
+const char kKeyId[] = "id";
 const char kKeyName[] = "name";
 const char kKeyType[] = "type";
+const char kKeyValue[] = "value";
+const char kKeyValueType[] = "value_type";
 const char kKeyVendorId[] = "vendor_id";
 
 // extern is required to be used in templates.
@@ -49,6 +56,13 @@ extern const char kOptionPageOrientation[] = "page_orientation";
 extern const char kOptionPageRange[] = "page_range";
 extern const char kOptionReverse[] = "reverse_order";
 extern const char kOptionPwgRasterConfig[] = "pwg_raster_config";
+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";
@@ -71,6 +85,26 @@ const char kPwgRasterDocumentSheetBack[] = "document_sheet_back";
 const char kPwgRasterReverseOrderStreaming[] = "reverse_order_streaming";
 const char kPwgRasterRotateAllPages[] = "rotate_all_pages";
 
+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";
+
+const char kTypeTypedValueVendorCapabilityBoolean[] = "BOOLEAN";
+const char kTypeTypedValueVendorCapabilityFloat[] = "FLOAT";
+const char kTypeTypedValueVendorCapabilityInteger[] = "INTEGER";
+const char kTypeTypedValueVendorCapabilityString[] = "STRING";
+
+const char kTypeVendorCapabilityRange[] = "RANGE";
+const char kTypeVendorCapabilitySelect[] = "SELECT";
+const char kTypeVendorCapabilityTypedValue[] = "TYPED_VALUE";
+
 const char kTypeColorColor[] = "STANDARD_COLOR";
 const char kTypeColorMonochrome[] = "STANDARD_MONOCHROME";
 const char kTypeColorCustomColor[] = "CUSTOM_COLOR";
@@ -103,72 +137,107 @@ const char kTypeDocumentSheetBackRotated[] = "ROTATED";
 const char kTypeDocumentSheetBackManualTumble[] = "MANUAL_TUMBLE";
 const char kTypeDocumentSheetBackFlipped[] = "FLIPPED";
 
+const struct RangeVendorCapabilityTypeNames {
+  RangeVendorCapability::ValueType id;
+  const char* json_name;
+} kRangeVendorCapabilityTypeNames[] = {
+    {RangeVendorCapability::ValueType::FLOAT, kTypeRangeVendorCapabilityFloat},
+    {RangeVendorCapability::ValueType::INTEGER,
+     kTypeRangeVendorCapabilityInteger},
+};
+
+const struct TypedValueVendorCapabilityTypeNames {
+  TypedValueVendorCapability::ValueType id;
+  const char* json_name;
+} kTypedValueVendorCapabilityTypeNames[] = {
+    {TypedValueVendorCapability::ValueType::BOOLEAN,
+     kTypeTypedValueVendorCapabilityBoolean},
+    {TypedValueVendorCapability::ValueType::FLOAT,
+     kTypeTypedValueVendorCapabilityFloat},
+    {TypedValueVendorCapability::ValueType::INTEGER,
+     kTypeTypedValueVendorCapabilityInteger},
+    {TypedValueVendorCapability::ValueType::STRING,
+     kTypeTypedValueVendorCapabilityString},
+};
+
+const struct VendorCapabilityTypeNames {
+  VendorCapability::Type id;
+  const char* json_name;
+} kVendorCapabilityTypeNames[] = {
+    {VendorCapability::Type::RANGE, kTypeVendorCapabilityRange},
+    {VendorCapability::Type::SELECT, kTypeVendorCapabilitySelect},
+    {VendorCapability::Type::TYPED_VALUE, kTypeVendorCapabilityTypedValue},
+};
+
 const struct ColorNames {
   ColorType id;
   const char* const json_name;
 } kColorNames[] = {
-      {STANDARD_COLOR, kTypeColorColor},
-      {STANDARD_MONOCHROME, kTypeColorMonochrome},
-      {CUSTOM_COLOR, kTypeColorCustomColor},
-      {CUSTOM_MONOCHROME, kTypeColorCustomMonochrome},
-      {AUTO_COLOR, kTypeColorAuto},
+    {ColorType::STANDARD_COLOR, kTypeColorColor},
+    {ColorType::STANDARD_MONOCHROME, kTypeColorMonochrome},
+    {ColorType::CUSTOM_COLOR, kTypeColorCustomColor},
+    {ColorType::CUSTOM_MONOCHROME, kTypeColorCustomMonochrome},
+    {ColorType::AUTO_COLOR, kTypeColorAuto},
 };
 
 const struct DuplexNames {
   DuplexType id;
   const char* const json_name;
 } kDuplexNames[] = {
-      {NO_DUPLEX, kTypeDuplexNoDuplex},
-      {LONG_EDGE, kTypeDuplexLongEdge},
-      {SHORT_EDGE, kTypeDuplexShortEdge},
+    {DuplexType::NO_DUPLEX, kTypeDuplexNoDuplex},
+    {DuplexType::LONG_EDGE, kTypeDuplexLongEdge},
+    {DuplexType::SHORT_EDGE, kTypeDuplexShortEdge},
 };
 
 const struct OrientationNames {
   OrientationType id;
   const char* const json_name;
 } kOrientationNames[] = {
-      {PORTRAIT, kTypeOrientationPortrait},
-      {LANDSCAPE, kTypeOrientationLandscape},
-      {AUTO_ORIENTATION, kTypeOrientationAuto},
+    {OrientationType::PORTRAIT, kTypeOrientationPortrait},
+    {OrientationType::LANDSCAPE, kTypeOrientationLandscape},
+    {OrientationType::AUTO_ORIENTATION, kTypeOrientationAuto},
 };
 
 const struct MarginsNames {
   MarginsType id;
   const char* const json_name;
 } kMarginsNames[] = {
-      {NO_MARGINS, kTypeMarginsBorderless},
-      {STANDARD_MARGINS, kTypeMarginsStandard},
-      {CUSTOM_MARGINS, kTypeMarginsCustom},
+    {MarginsType::NO_MARGINS, kTypeMarginsBorderless},
+    {MarginsType::STANDARD_MARGINS, kTypeMarginsStandard},
+    {MarginsType::CUSTOM_MARGINS, kTypeMarginsCustom},
 };
 
 const struct FitToPageNames {
   FitToPageType id;
   const char* const json_name;
 } kFitToPageNames[] = {
-      {NO_FITTING, kTypeFitToPageNoFitting},
-      {FIT_TO_PAGE, kTypeFitToPageFitToPage},
-      {GROW_TO_PAGE, kTypeFitToPageGrowToPage},
-      {SHRINK_TO_PAGE, kTypeFitToPageShrinkToPage},
-      {FILL_PAGE, kTypeFitToPageFillPage},
+    {FitToPageType::NO_FITTING, kTypeFitToPageNoFitting},
+    {FitToPageType::FIT_TO_PAGE, kTypeFitToPageFitToPage},
+    {FitToPageType::GROW_TO_PAGE, kTypeFitToPageGrowToPage},
+    {FitToPageType::SHRINK_TO_PAGE, kTypeFitToPageShrinkToPage},
+    {FitToPageType::FILL_PAGE, kTypeFitToPageFillPage},
 };
 
 const struct DocumentSheetBackNames {
   DocumentSheetBack id;
   const char* const json_name;
 } kDocumentSheetBackNames[] = {
-      {NORMAL, kTypeDocumentSheetBackNormal},
-      {ROTATED, kTypeDocumentSheetBackRotated},
-      {MANUAL_TUMBLE, kTypeDocumentSheetBackManualTumble},
-      {FLIPPED, kTypeDocumentSheetBackFlipped}};
+    {DocumentSheetBack::NORMAL, kTypeDocumentSheetBackNormal},
+    {DocumentSheetBack::ROTATED, kTypeDocumentSheetBackRotated},
+    {DocumentSheetBack::MANUAL_TUMBLE, kTypeDocumentSheetBackManualTumble},
+    {DocumentSheetBack::FLIPPED, kTypeDocumentSheetBackFlipped}};
 
 const int32_t kInchToUm = 25400;
 const int32_t kMmToUm = 1000;
 const int32_t kSizeTrasholdUm = 1000;
 
+// Json name of media type is constructed by removing "MediaType::" enum class
+// prefix from it.
 #define MAP_CLOUD_PRINT_MEDIA_TYPE(type, width, height, unit_um) \
   {                                                              \
-    type, #type, static_cast<int>(width* unit_um + 0.5),         \
-        static_cast<int>(height* unit_um + 0.5)                  \
+    type, &#type[strlen("MediaType::")],                         \
+        static_cast<int>(width * unit_um + 0.5),                 \
+        static_cast<int>(height * unit_um + 0.5)                 \
   }
 
 const struct MediaDefinition {
@@ -177,171 +246,189 @@ const struct MediaDefinition {
   int width_um;
   int height_um;
 } kMediaDefinitions[] = {
-      {CUSTOM_MEDIA, "CUSTOM", 0, 0},
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_INDEX_3X5, 3, 5, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_PERSONAL, 3.625f, 6.5f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_MONARCH, 3.875f, 7.5f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_NUMBER_9, 3.875f, 8.875f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_INDEX_4X6, 4, 6, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_NUMBER_10, 4.125f, 9.5f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_A2, 4.375f, 5.75f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_NUMBER_11, 4.5f, 10.375f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_NUMBER_12, 4.75f, 11, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_5X7, 5, 7, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_INDEX_5X8, 5, 8, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_NUMBER_14, 5, 11.5f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_INVOICE, 5.5f, 8.5f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_INDEX_4X6_EXT, 6, 8, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_6X9, 6, 9, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_C5, 6.5f, 9.5f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_7X9, 7, 9, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_EXECUTIVE, 7.25f, 10.5f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_GOVT_LETTER, 8, 10, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_GOVT_LEGAL, 8, 13, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_QUARTO, 8.5f, 10.83f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_LETTER, 8.5f, 11, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_FANFOLD_EUR, 8.5f, 12, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_LETTER_PLUS, 8.5f, 12.69f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_FOOLSCAP, 8.5f, 13, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_LEGAL, 8.5f, 14, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_SUPER_A, 8.94f, 14, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_9X11, 9, 11, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_ARCH_A, 9, 12, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_LETTER_EXTRA, 9.5f, 12, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_LEGAL_EXTRA, 9.5f, 15, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_10X11, 10, 11, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_10X13, 10, 13, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_10X14, 10, 14, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_10X15, 10, 15, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_11X12, 11, 12, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_EDP, 11, 14, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_FANFOLD_US, 11, 14.875f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_11X15, 11, 15, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_LEDGER, 11, 17, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_EUR_EDP, 12, 14, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_ARCH_B, 12, 18, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_12X19, 12, 19, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_B_PLUS, 12, 19.17f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_SUPER_B, 13, 19, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_C, 17, 22, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_ARCH_C, 18, 24, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_D, 22, 34, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_ARCH_D, 24, 36, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_ASME_F, 28, 40, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_WIDE_FORMAT, 30, 42, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_E, 34, 44, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_ARCH_E, 36, 48, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(NA_F, 44, 68, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ROC_16K, 7.75f, 10.75f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ROC_8K, 10.75f, 15.5f, kInchToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_32K, 97, 151, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_1, 102, 165, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_2, 102, 176, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_4, 110, 208, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_5, 110, 220, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_8, 120, 309, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_6, 120, 230, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_3, 125, 176, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_16K, 146, 215, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_7, 160, 230, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_JUURO_KU_KAI, 198, 275, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_PA_KAI, 267, 389, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_DAI_PA_KAI, 275, 395, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(PRC_10, 324, 458, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A10, 26, 37, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A9, 37, 52, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A8, 52, 74, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A7, 74, 105, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A6, 105, 148, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A5, 148, 210, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A5_EXTRA, 174, 235, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4, 210, 297, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4_TAB, 225, 297, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4_EXTRA, 235, 322, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A3, 297, 420, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4X3, 297, 630, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4X4, 297, 841, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4X5, 297, 1051, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4X6, 297, 1261, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4X7, 297, 1471, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4X8, 297, 1682, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A4X9, 297, 1892, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A3_EXTRA, 322, 445, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A2, 420, 594, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A3X3, 420, 891, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A3X4, 420, 1189, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A3X5, 420, 1486, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A3X6, 420, 1783, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A3X7, 420, 2080, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A1, 594, 841, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A2X3, 594, 1261, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A2X4, 594, 1682, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A2X5, 594, 2102, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A0, 841, 1189, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A1X3, 841, 1783, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A1X4, 841, 2378, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_2A0, 1189, 1682, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_A0X3, 1189, 2523, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B10, 31, 44, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B9, 44, 62, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B8, 62, 88, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B7, 88, 125, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B6, 125, 176, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B6C4, 125, 324, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B5, 176, 250, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B5_EXTRA, 201, 276, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B4, 250, 353, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B3, 353, 500, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B2, 500, 707, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B1, 707, 1000, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_B0, 1000, 1414, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C10, 28, 40, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C9, 40, 57, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C8, 57, 81, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C7, 81, 114, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C7C6, 81, 162, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C6, 114, 162, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C6C5, 114, 229, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C5, 162, 229, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C4, 229, 324, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C3, 324, 458, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C2, 458, 648, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C1, 648, 917, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_C0, 917, 1297, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_DL, 110, 220, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_RA2, 430, 610, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_SRA2, 450, 640, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_RA1, 610, 860, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_SRA1, 640, 900, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_RA0, 860, 1220, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(ISO_SRA0, 900, 1280, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B10, 32, 45, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B9, 45, 64, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B8, 64, 91, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B7, 91, 128, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B6, 128, 182, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B5, 182, 257, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B4, 257, 364, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B3, 364, 515, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B2, 515, 728, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B1, 728, 1030, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_B0, 1030, 1456, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JIS_EXEC, 216, 330, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JPN_CHOU4, 90, 205, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JPN_HAGAKI, 100, 148, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JPN_YOU4, 105, 235, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JPN_CHOU2, 111.1f, 146, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JPN_CHOU3, 120, 235, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JPN_OUFUKU, 148, 200, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JPN_KAHU, 240, 322.1f, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(JPN_KAKU2, 240, 332, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_SMALL_PHOTO, 100, 150, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_ITALIAN, 110, 230, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_POSTFIX, 114, 229, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_LARGE_PHOTO, 200, 300, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_FOLIO, 210, 330, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_FOLIO_SP, 215, 315, kMmToUm),
-      MAP_CLOUD_PRINT_MEDIA_TYPE(OM_INVITE, 220, 220, kMmToUm)};
+    {MediaType::CUSTOM_MEDIA, "CUSTOM", 0, 0},
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_INDEX_3X5, 3, 5, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_PERSONAL, 3.625f, 6.5f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_MONARCH, 3.875f, 7.5f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_NUMBER_9,
+                               3.875f,
+                               8.875f,
+                               kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_INDEX_4X6, 4, 6, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_NUMBER_10,
+                               4.125f,
+                               9.5f,
+                               kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_A2, 4.375f, 5.75f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_NUMBER_11,
+                               4.5f,
+                               10.375f,
+                               kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_NUMBER_12, 4.75f, 11, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_5X7, 5, 7, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_INDEX_5X8, 5, 8, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_NUMBER_14, 5, 11.5f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_INVOICE, 5.5f, 8.5f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_INDEX_4X6_EXT, 6, 8, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_6X9, 6, 9, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_C5, 6.5f, 9.5f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_7X9, 7, 9, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_EXECUTIVE,
+                               7.25f,
+                               10.5f,
+                               kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_GOVT_LETTER, 8, 10, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_GOVT_LEGAL, 8, 13, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_QUARTO, 8.5f, 10.83f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_LETTER, 8.5f, 11, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_FANFOLD_EUR, 8.5f, 12, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_LETTER_PLUS,
+                               8.5f,
+                               12.69f,
+                               kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_FOOLSCAP, 8.5f, 13, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_LEGAL, 8.5f, 14, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_SUPER_A, 8.94f, 14, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_9X11, 9, 11, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_ARCH_A, 9, 12, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_LETTER_EXTRA, 9.5f, 12, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_LEGAL_EXTRA, 9.5f, 15, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_10X11, 10, 11, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_10X13, 10, 13, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_10X14, 10, 14, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_10X15, 10, 15, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_11X12, 11, 12, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_EDP, 11, 14, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_FANFOLD_US,
+                               11,
+                               14.875f,
+                               kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_11X15, 11, 15, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_LEDGER, 11, 17, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_EUR_EDP, 12, 14, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_ARCH_B, 12, 18, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_12X19, 12, 19, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_B_PLUS, 12, 19.17f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_SUPER_B, 13, 19, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_C, 17, 22, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_ARCH_C, 18, 24, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_D, 22, 34, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_ARCH_D, 24, 36, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_ASME_F, 28, 40, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_WIDE_FORMAT, 30, 42, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_E, 34, 44, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_ARCH_E, 36, 48, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::NA_F, 44, 68, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ROC_16K, 7.75f, 10.75f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ROC_8K, 10.75f, 15.5f, kInchToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_32K, 97, 151, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_1, 102, 165, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_2, 102, 176, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_4, 110, 208, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_5, 110, 220, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_8, 120, 309, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_6, 120, 230, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_3, 125, 176, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_16K, 146, 215, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_7, 160, 230, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_JUURO_KU_KAI, 198, 275, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_PA_KAI, 267, 389, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_DAI_PA_KAI, 275, 395, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::PRC_10, 324, 458, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A10, 26, 37, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A9, 37, 52, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A8, 52, 74, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A7, 74, 105, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A6, 105, 148, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A5, 148, 210, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A5_EXTRA, 174, 235, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4, 210, 297, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4_TAB, 225, 297, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4_EXTRA, 235, 322, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A3, 297, 420, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4X3, 297, 630, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4X4, 297, 841, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4X5, 297, 1051, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4X6, 297, 1261, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4X7, 297, 1471, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4X8, 297, 1682, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A4X9, 297, 1892, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A3_EXTRA, 322, 445, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A2, 420, 594, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A3X3, 420, 891, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A3X4, 420, 1189, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A3X5, 420, 1486, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A3X6, 420, 1783, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A3X7, 420, 2080, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A1, 594, 841, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A2X3, 594, 1261, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A2X4, 594, 1682, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A2X5, 594, 2102, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A0, 841, 1189, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A1X3, 841, 1783, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A1X4, 841, 2378, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_2A0, 1189, 1682, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_A0X3, 1189, 2523, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B10, 31, 44, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B9, 44, 62, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B8, 62, 88, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B7, 88, 125, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B6, 125, 176, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B6C4, 125, 324, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B5, 176, 250, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B5_EXTRA, 201, 276, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B4, 250, 353, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B3, 353, 500, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B2, 500, 707, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B1, 707, 1000, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_B0, 1000, 1414, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C10, 28, 40, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C9, 40, 57, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C8, 57, 81, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C7, 81, 114, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C7C6, 81, 162, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C6, 114, 162, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C6C5, 114, 229, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C5, 162, 229, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C4, 229, 324, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C3, 324, 458, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C2, 458, 648, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C1, 648, 917, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_C0, 917, 1297, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_DL, 110, 220, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_RA2, 430, 610, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_SRA2, 450, 640, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_RA1, 610, 860, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_SRA1, 640, 900, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_RA0, 860, 1220, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::ISO_SRA0, 900, 1280, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B10, 32, 45, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B9, 45, 64, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B8, 64, 91, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B7, 91, 128, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B6, 128, 182, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B5, 182, 257, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B4, 257, 364, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B3, 364, 515, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B2, 515, 728, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B1, 728, 1030, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_B0, 1030, 1456, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JIS_EXEC, 216, 330, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JPN_CHOU4, 90, 205, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JPN_HAGAKI, 100, 148, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JPN_YOU4, 105, 235, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JPN_CHOU2, 111.1f, 146, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JPN_CHOU3, 120, 235, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JPN_OUFUKU, 148, 200, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JPN_KAHU, 240, 322.1f, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::JPN_KAKU2, 240, 332, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_SMALL_PHOTO, 100, 150, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_ITALIAN, 110, 230, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_POSTFIX, 114, 229, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_LARGE_PHOTO, 200, 300, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_FOLIO, 210, 330, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_FOLIO_SP, 215, 315, kMmToUm),
+    MAP_CLOUD_PRINT_MEDIA_TYPE(MediaType::OM_INVITE, 220, 220, kMmToUm)};
 #undef MAP_CLOUD_PRINT_MEDIA_TYPE
 
 const MediaDefinition& FindMediaByType(MediaType type) {
@@ -389,16 +476,341 @@ bool TypeFromString(const T& names, const std::string& type, IdType* id) {
 }  // namespace
 
 PwgRasterConfig::PwgRasterConfig()
-    : document_sheet_back(ROTATED),
+    : document_sheet_back(DocumentSheetBack::ROTATED),
       reverse_order_streaming(false),
-      rotate_all_pages(false) {
-}
+      rotate_all_pages(false) {}
 
 PwgRasterConfig::~PwgRasterConfig() {}
 
-Color::Color() : type(AUTO_COLOR) {
+RangeVendorCapability::RangeVendorCapability() = default;
+
+RangeVendorCapability::RangeVendorCapability(ValueType value_type,
+                                             const std::string& min_value,
+                                             const std::string& max_value)
+    : RangeVendorCapability(value_type,
+                            min_value,
+                            max_value,
+                            /*default_value=*/"") {}
+
+RangeVendorCapability::RangeVendorCapability(ValueType value_type,
+                                             const std::string& min_value,
+                                             const std::string& max_value,
+                                             const std::string& default_value)
+    : value_type_(value_type),
+      min_value_(min_value),
+      max_value_(max_value),
+      default_value_(default_value) {}
+
+RangeVendorCapability::RangeVendorCapability(RangeVendorCapability&& other) =
+    default;
+
+RangeVendorCapability::~RangeVendorCapability() = default;
+
+RangeVendorCapability& RangeVendorCapability::operator=(
+    RangeVendorCapability&& other) = default;
+
+bool RangeVendorCapability::operator==(
+    const RangeVendorCapability& other) const {
+  return value_type_ == other.value_type_ && min_value_ == other.min_value_ &&
+         max_value_ == other.max_value_ &&
+         default_value_ == other.default_value_;
+}
+
+bool RangeVendorCapability::IsValid() const {
+  if (min_value_.empty() || max_value_.empty())
+    return false;
+  switch (value_type_) {
+    case ValueType::FLOAT: {
+      double min_value;
+      double max_value;
+      if (!base::StringToDouble(min_value_, &min_value) ||
+          !base::StringToDouble(max_value_, &max_value) ||
+          min_value > max_value) {
+        return false;
+      }
+      if (!default_value_.empty()) {
+        double default_value;
+        if (!base::StringToDouble(default_value_, &default_value) ||
+            default_value < min_value || default_value > max_value) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case ValueType::INTEGER: {
+      int min_value;
+      int max_value;
+      if (!base::StringToInt(min_value_, &min_value) ||
+          !base::StringToInt(max_value_, &max_value) || min_value > max_value) {
+        return false;
+      }
+      if (!default_value_.empty()) {
+        int default_value;
+        if (!base::StringToInt(default_value_, &default_value) ||
+            default_value < min_value || default_value > max_value) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+  NOTREACHED() << "Bad range capability value type";
+  return false;
+}
+
+bool RangeVendorCapability::LoadFrom(const base::Value& dict) {
+  const std::string* value_type_str = dict.FindStringKey(kKeyValueType);
+  if (!value_type_str || !TypeFromString(kRangeVendorCapabilityTypeNames,
+                                         *value_type_str, &value_type_)) {
+    return false;
+  }
+  const std::string* min_value_str =
+      dict.FindStringKey(kVendorCapabilityMinValue);
+  if (!min_value_str)
+    return false;
+  min_value_ = *min_value_str;
+  const std::string* max_value_str =
+      dict.FindStringKey(kVendorCapabilityMaxValue);
+  if (!max_value_str)
+    return false;
+  max_value_ = *max_value_str;
+  const std::string* default_value_str =
+      dict.FindStringKey(kVendorCapabilityDefaultValue);
+  if (default_value_str)
+    default_value_ = *default_value_str;
+  return IsValid();
+}
+
+void RangeVendorCapability::SaveTo(base::Value* dict) const {
+  DCHECK(IsValid());
+  dict->SetKey(
+      kKeyValueType,
+      base::Value(TypeToString(kRangeVendorCapabilityTypeNames, value_type_)));
+  dict->SetKey(kVendorCapabilityMinValue, base::Value(min_value_));
+  dict->SetKey(kVendorCapabilityMaxValue, base::Value(max_value_));
+  if (!default_value_.empty())
+    dict->SetKey(kVendorCapabilityDefaultValue, base::Value(default_value_));
+}
+
+SelectVendorCapabilityOption::SelectVendorCapabilityOption() = default;
+
+SelectVendorCapabilityOption::SelectVendorCapabilityOption(
+    const std::string& value,
+    const std::string& display_name)
+    : value(value), display_name(display_name) {}
+
+SelectVendorCapabilityOption::~SelectVendorCapabilityOption() = default;
+
+bool SelectVendorCapabilityOption::operator==(
+    const SelectVendorCapabilityOption& other) const {
+  return value == other.value && display_name == other.display_name;
+}
+
+bool SelectVendorCapabilityOption::IsValid() const {
+  return !value.empty() && !display_name.empty();
+}
+
+TypedValueVendorCapability::TypedValueVendorCapability() = default;
+
+TypedValueVendorCapability::TypedValueVendorCapability(ValueType value_type)
+    : TypedValueVendorCapability(value_type, /*default_value=*/"") {}
+
+TypedValueVendorCapability::TypedValueVendorCapability(
+    ValueType value_type,
+    const std::string& default_value)
+    : value_type_(value_type), default_value_(default_value) {}
+
+TypedValueVendorCapability::TypedValueVendorCapability(
+    TypedValueVendorCapability&& other) = default;
+
+TypedValueVendorCapability::~TypedValueVendorCapability() = default;
+
+TypedValueVendorCapability& TypedValueVendorCapability::operator=(
+    TypedValueVendorCapability&& other) = default;
+
+bool TypedValueVendorCapability::operator==(
+    const TypedValueVendorCapability& other) const {
+  return value_type_ == other.value_type_ &&
+         default_value_ == other.default_value_;
+}
+
+bool TypedValueVendorCapability::IsValid() const {
+  if (default_value_.empty())
+    return true;
+  switch (value_type_) {
+    case ValueType::BOOLEAN:
+      return default_value_ == "true" || default_value_ == "false";
+    case ValueType::FLOAT: {
+      double value;
+      return base::StringToDouble(default_value_, &value);
+    }
+    case ValueType::INTEGER: {
+      int value;
+      return base::StringToInt(default_value_, &value);
+    }
+    case ValueType::STRING:
+      return true;
+  }
+  NOTREACHED() << "Bad typed value capability value type";
+  return false;
+}
+
+bool TypedValueVendorCapability::LoadFrom(const base::Value& dict) {
+  const std::string* value_type_str = dict.FindStringKey(kKeyValueType);
+  if (!value_type_str || !TypeFromString(kTypedValueVendorCapabilityTypeNames,
+                                         *value_type_str, &value_type_)) {
+    return false;
+  }
+  const std::string* default_value_str =
+      dict.FindStringKey(kVendorCapabilityDefaultValue);
+  if (default_value_str)
+    default_value_ = *default_value_str;
+  return IsValid();
+}
+
+void TypedValueVendorCapability::SaveTo(base::Value* dict) const {
+  DCHECK(IsValid());
+  dict->SetKey(kKeyValueType,
+               base::Value(TypeToString(kTypedValueVendorCapabilityTypeNames,
+                                        value_type_)));
+  if (!default_value_.empty())
+    dict->SetKey(kVendorCapabilityDefaultValue, base::Value(default_value_));
+}
+
+VendorCapability::VendorCapability() = default;
+
+VendorCapability::VendorCapability(const std::string& id,
+                                   const std::string& display_name,
+                                   RangeVendorCapability range_capability)
+    : type_(Type::RANGE),
+      id_(id),
+      display_name_(display_name),
+      range_capability_(std::move(range_capability)) {}
+
+VendorCapability::VendorCapability(const std::string& id,
+                                   const std::string& display_name,
+                                   SelectVendorCapability select_capability)
+    : type_(Type::SELECT),
+      id_(id),
+      display_name_(display_name),
+      select_capability_(std::move(select_capability)) {}
+
+VendorCapability::VendorCapability(
+    const std::string& id,
+    const std::string& display_name,
+    TypedValueVendorCapability typed_value_capability)
+    : type_(Type::TYPED_VALUE),
+      id_(id),
+      display_name_(display_name),
+      typed_value_capability_(std::move(typed_value_capability)) {}
+
+VendorCapability::VendorCapability(VendorCapability&& other) = default;
+
+VendorCapability::~VendorCapability() = default;
+
+bool VendorCapability::operator==(const VendorCapability& other) const {
+  return type_ == other.type_ && id_ == other.id_ &&
+         display_name_ == other.display_name_ &&
+         range_capability_ == other.range_capability_ &&
+         select_capability_ == other.select_capability_ &&
+         typed_value_capability_ == other.typed_value_capability_;
+}
+
+bool VendorCapability::IsValid() const {
+  if (id_.empty() || display_name_.empty())
+    return false;
+  switch (type_) {
+    case Type::RANGE:
+      return !select_capability_ && !typed_value_capability_ &&
+             range_capability_ && range_capability_.value().IsValid();
+    case Type::SELECT:
+      return !range_capability_ && !typed_value_capability_ &&
+             select_capability_ && select_capability_.value().IsValid();
+    case Type::TYPED_VALUE:
+      return !range_capability_ && !select_capability_ &&
+             typed_value_capability_ &&
+             typed_value_capability_.value().IsValid();
+  }
+  NOTREACHED() << "Bad vendor capability type";
+  return false;
+}
+
+bool VendorCapability::LoadFrom(const base::Value& dict) {
+  const std::string* type_str = dict.FindStringKey(kKeyType);
+  if (!type_str ||
+      !TypeFromString(kVendorCapabilityTypeNames, *type_str, &type_)) {
+    return false;
+  }
+  const std::string* id_str = dict.FindStringKey(kKeyId);
+  if (!id_str)
+    return false;
+  id_ = *id_str;
+  const std::string* display_name_str = dict.FindStringKey(kKeyDisplayName);
+  if (!display_name_str)
+    return false;
+  display_name_ = *display_name_str;
+
+  const base::Value* range_capability_value =
+      dict.FindKey(kOptionRangeCapability);
+  if (range_capability_value) {
+    if (!range_capability_value->is_dict())
+      return false;
+    range_capability_ = RangeVendorCapability();
+    if (!range_capability_.value().LoadFrom(*range_capability_value))
+      return false;
+  }
+
+  const base::Value* select_capability_value =
+      dict.FindKey(kOptionSelectCapability);
+  if (select_capability_value) {
+    if (!select_capability_value->is_dict())
+      return false;
+    select_capability_ = SelectVendorCapability();
+    if (!select_capability_.value().LoadFrom(*select_capability_value))
+      return false;
+  }
+
+  const base::Value* typed_value_capability_value =
+      dict.FindKey(kOptionTypedValueCapability);
+  if (typed_value_capability_value) {
+    if (!typed_value_capability_value->is_dict())
+      return false;
+    typed_value_capability_ = TypedValueVendorCapability();
+    if (!typed_value_capability_.value().LoadFrom(
+            *typed_value_capability_value)) {
+      return false;
+    }
+  }
+
+  return IsValid();
 }
 
+void VendorCapability::SaveTo(base::Value* dict) const {
+  DCHECK(IsValid());
+  dict->SetKey(kKeyType,
+               base::Value(TypeToString(kVendorCapabilityTypeNames, type_)));
+  dict->SetKey(kKeyId, base::Value(id_));
+  dict->SetKey(kKeyDisplayName, base::Value(display_name_));
+
+  if (range_capability_) {
+    base::Value range_capability_value(base::Value::Type::DICTIONARY);
+    range_capability_.value().SaveTo(&range_capability_value);
+    dict->SetKey(kOptionRangeCapability, std::move(range_capability_value));
+  } else if (select_capability_) {
+    base::Value select_capability_value(base::Value::Type::DICTIONARY);
+    select_capability_.value().SaveTo(&select_capability_value);
+    dict->SetKey(kOptionSelectCapability, std::move(select_capability_value));
+  } else {
+    DCHECK(typed_value_capability_);
+    base::Value typed_value_capability_value(base::Value::Type::DICTIONARY);
+    typed_value_capability_.value().SaveTo(&typed_value_capability_value);
+    dict->SetKey(kOptionTypedValueCapability,
+                 std::move(typed_value_capability_value));
+  }
+}
+
+Color::Color() : type(ColorType::AUTO_COLOR) {}
+
 Color::Color(ColorType type) : type(type) {
 }
 
@@ -408,14 +820,17 @@ bool Color::operator==(const Color& other) const {
 }
 
 bool Color::IsValid() const {
-  if (type != CUSTOM_COLOR && type != CUSTOM_MONOCHROME)
+  if (type != ColorType::CUSTOM_COLOR && type != ColorType::CUSTOM_MONOCHROME)
     return true;
   return !vendor_id.empty() && !custom_display_name.empty();
 }
 
 Margins::Margins()
-    : type(STANDARD_MARGINS), top_um(0), right_um(0), bottom_um(0), left_um(0) {
-}
+    : type(MarginsType::STANDARD_MARGINS),
+      top_um(0),
+      right_um(0),
+      bottom_um(0),
+      left_um(0) {}
 
 Margins::Margins(MarginsType type,
                  int32_t top_um,
@@ -448,8 +863,10 @@ bool Dpi::operator==(const Dpi& other) const {
 }
 
 Media::Media()
-    : type(CUSTOM_MEDIA), width_um(0), height_um(0), is_continuous_feed(false) {
-}
+    : type(MediaType::CUSTOM_MEDIA),
+      width_um(0),
+      height_um(0),
+      is_continuous_feed(false) {}
 
 Media::Media(MediaType type)
     : type(type),
@@ -472,7 +889,7 @@ Media::Media(const std::string& custom_display_name,
              const std::string& vendor_id,
              int32_t width_um,
              int32_t height_um)
-    : type(CUSTOM_MEDIA),
+    : type(MediaType::CUSTOM_MEDIA),
       width_um(width_um),
       height_um(height_um),
       is_continuous_feed(width_um <= 0 || height_um <= 0),
@@ -520,18 +937,12 @@ bool Interval::operator==(const Interval& other) const {
 template <const char* kName>
 class ItemsTraits {
  public:
-  static std::string GetCapabilityPath() {
-    std::string result = kSectionPrinter;
-    result += '.';
-    result += kName;
-    return result;
+  static std::vector<base::StringPiece> GetCapabilityPath() {
+    return {kSectionPrinter, kName};
   }
 
-  static std::string GetTicketItemPath() {
-    std::string result = kSectionPrint;
-    result += '.';
-    result += kName;
-    return result;
+  static std::vector<base::StringPiece> GetTicketItemPath() {
+    return {kSectionPrint, kName};
   }
 };
 
@@ -546,24 +957,30 @@ class NoValueValidation {
 class ContentTypeTraits : public NoValueValidation,
                           public ItemsTraits<kOptionContentType> {
  public:
-  static bool Load(const base::DictionaryValue& dict, ContentType* option) {
-    return dict.GetString(kKeyContentType, option);
+  static bool Load(const base::Value& dict, ContentType* option) {
+    const std::string* content_type = dict.FindStringKey(kKeyContentType);
+    if (!content_type)
+      return false;
+    *option = *content_type;
+    return true;
   }
 
-  static void Save(ContentType option, base::DictionaryValue* dict) {
-    dict->SetString(kKeyContentType, option);
+  static void Save(ContentType option, base::Value* dict) {
+    dict->SetKey(kKeyContentType, base::Value(option));
   }
 };
 
 class PwgRasterConfigTraits : public NoValueValidation,
                               public ItemsTraits<kOptionPwgRasterConfig> {
  public:
-  static bool Load(const base::DictionaryValue& dict, PwgRasterConfig* option) {
-    std::string document_sheet_back;
+  static bool Load(const base::Value& dict, PwgRasterConfig* option) {
     PwgRasterConfig option_out;
-    if (dict.GetString(kPwgRasterDocumentSheetBack, &document_sheet_back)) {
-      if (!TypeFromString(kDocumentSheetBackNames,
-                          document_sheet_back,
+    const base::Value* document_sheet_back =
+        dict.FindKey(kPwgRasterDocumentSheetBack);
+    if (document_sheet_back) {
+      if (!document_sheet_back->is_string() ||
+          !TypeFromString(kDocumentSheetBackNames,
+                          document_sheet_back->GetString(),
                           &option_out.document_sheet_back)) {
         return false;
       }
@@ -574,40 +991,43 @@ class PwgRasterConfigTraits : public NoValueValidation,
     if (document_types_supported) {
       if (!document_types_supported->is_list())
         return false;
-
-      for (const auto& type : document_types_supported->GetList()) {
-        if (!type.is_string())
+      for (const auto& type_value : document_types_supported->GetList()) {
+        if (!type_value.is_string())
           return false;
 
-        std::string type_str = type.GetString();
-        if (type_str == kTypeDocumentSupportedTypeSRGB8)
-          option_out.document_types_supported.push_back(SRGB_8);
-        else if (type_str == kTypeDocumentSupportedTypeSGRAY8)
-          option_out.document_types_supported.push_back(SGRAY_8);
+        const std::string& type = type_value.GetString();
+        if (type == kTypeDocumentSupportedTypeSRGB8) {
+          option_out.document_types_supported.push_back(
+              PwgDocumentTypeSupported::SRGB_8);
+        } else if (type == kTypeDocumentSupportedTypeSGRAY8) {
+          option_out.document_types_supported.push_back(
+              PwgDocumentTypeSupported::SGRAY_8);
+        }
       }
     }
 
-    dict.GetBoolean(kPwgRasterReverseOrderStreaming,
-                    &option_out.reverse_order_streaming);
-    dict.GetBoolean(kPwgRasterRotateAllPages, &option_out.rotate_all_pages);
+    option_out.reverse_order_streaming =
+        dict.FindBoolKey(kPwgRasterReverseOrderStreaming).value_or(false);
+    option_out.rotate_all_pages =
+        dict.FindBoolKey(kPwgRasterRotateAllPages).value_or(false);
     *option = option_out;
     return true;
   }
 
-  static void Save(const PwgRasterConfig& option, base::DictionaryValue* dict) {
-    dict->SetString(
-        kPwgRasterDocumentSheetBack,
-        TypeToString(kDocumentSheetBackNames, option.document_sheet_back));
+  static void Save(const PwgRasterConfig& option, base::Value* dict) {
+    dict->SetKey(kPwgRasterDocumentSheetBack,
+                 base::Value(TypeToString(kDocumentSheetBackNames,
+                                          option.document_sheet_back)));
 
     if (!option.document_types_supported.empty()) {
       base::Value::ListStorage supported_list;
       for (const auto& type : option.document_types_supported) {
         switch (type) {
-          case SRGB_8:
+          case PwgDocumentTypeSupported::SRGB_8:
             supported_list.push_back(
                 base::Value(kTypeDocumentSupportedTypeSRGB8));
             break;
-          case SGRAY_8:
+          case PwgDocumentTypeSupported::SGRAY_8:
             supported_list.push_back(
                 base::Value(kTypeDocumentSupportedTypeSGRAY8));
             break;
@@ -618,12 +1038,56 @@ class PwgRasterConfigTraits : public NoValueValidation,
     }
 
     if (option.reverse_order_streaming) {
-      dict->SetBoolean(kPwgRasterReverseOrderStreaming,
-                       option.reverse_order_streaming);
+      dict->SetKey(kPwgRasterReverseOrderStreaming,
+                   base::Value(option.reverse_order_streaming));
     }
 
-    if (option.rotate_all_pages)
-      dict->SetBoolean(kPwgRasterRotateAllPages, option.rotate_all_pages);
+    if (option.rotate_all_pages) {
+      dict->SetKey(kPwgRasterRotateAllPages,
+                   base::Value(option.rotate_all_pages));
+    }
+  }
+};
+
+class VendorCapabilityTraits : public ItemsTraits<kOptionVendorCapability> {
+ public:
+  static bool IsValid(const VendorCapability& option) {
+    return option.IsValid();
+  }
+
+  static bool Load(const base::Value& dict, VendorCapability* option) {
+    return option->LoadFrom(dict);
+  }
+
+  static void Save(const VendorCapability& option, base::Value* dict) {
+    option.SaveTo(dict);
+  }
+};
+
+class SelectVendorCapabilityTraits
+    : public ItemsTraits<kOptionSelectCapability> {
+ public:
+  static bool IsValid(const SelectVendorCapabilityOption& option) {
+    return option.IsValid();
+  }
+
+  static bool Load(const base::Value& dict,
+                   SelectVendorCapabilityOption* option) {
+    const std::string* value = dict.FindStringKey(kKeyValue);
+    if (!value)
+      return false;
+    option->value = *value;
+    const std::string* display_name = dict.FindStringKey(kKeyDisplayName);
+    if (!display_name)
+      return false;
+    option->display_name = *display_name;
+    return true;
+  }
+
+  static void Save(const SelectVendorCapabilityOption& option,
+                   base::Value* dict) {
+    dict->SetKey(kKeyValue, base::Value(option.value));
+    dict->SetKey(kKeyDisplayName, base::Value(option.display_name));
   }
 };
 
@@ -631,51 +1095,55 @@ class ColorTraits : public ItemsTraits<kOptionColor> {
  public:
   static bool IsValid(const Color& option) { return option.IsValid(); }
 
-  static bool Load(const base::DictionaryValue& dict, Color* option) {
-    std::string type_str;
-    if (!dict.GetString(kKeyType, &type_str))
-      return false;
-    if (!TypeFromString(kColorNames, type_str, &option->type))
+  static bool Load(const base::Value& dict, Color* option) {
+    const std::string* type = dict.FindStringKey(kKeyType);
+    if (!type || !TypeFromString(kColorNames, *type, &option->type))
       return false;
-    dict.GetString(kKeyVendorId, &option->vendor_id);
-    dict.GetString(kCustomName, &option->custom_display_name);
+    const std::string* vendor_id = dict.FindStringKey(kKeyVendorId);
+    if (vendor_id)
+      option->vendor_id = *vendor_id;
+    const std::string* custom_display_name =
+        dict.FindStringKey(kKeyCustomDisplayName);
+    if (custom_display_name)
+      option->custom_display_name = *custom_display_name;
     return true;
   }
 
-  static void Save(const Color& option, base::DictionaryValue* dict) {
-    dict->SetString(kKeyType, TypeToString(kColorNames, option.type));
+  static void Save(const Color& option, base::Value* dict) {
+    dict->SetKey(kKeyType, base::Value(TypeToString(kColorNames, option.type)));
     if (!option.vendor_id.empty())
-      dict->SetString(kKeyVendorId, option.vendor_id);
-    if (!option.custom_display_name.empty())
-      dict->SetString(kCustomName, option.custom_display_name);
+      dict->SetKey(kKeyVendorId, base::Value(option.vendor_id));
+    if (!option.custom_display_name.empty()) {
+      dict->SetKey(kKeyCustomDisplayName,
+                   base::Value(option.custom_display_name));
+    }
   }
 };
 
 class DuplexTraits : public NoValueValidation,
                      public ItemsTraits<kOptionDuplex> {
  public:
-  static bool Load(const base::DictionaryValue& dict, DuplexType* option) {
-    std::string type_str;
-    return dict.GetString(kKeyType, &type_str) &&
-           TypeFromString(kDuplexNames, type_str, option);
+  static bool Load(const base::Value& dict, DuplexType* option) {
+    const std::string* type = dict.FindStringKey(kKeyType);
+    return type && TypeFromString(kDuplexNames, *type, option);
   }
 
-  static void Save(DuplexType option, base::DictionaryValue* dict) {
-    dict->SetString(kKeyType, TypeToString(kDuplexNames, option));
+  static void Save(DuplexType option, base::Value* dict) {
+    dict->SetKey(kKeyType, base::Value(TypeToString(kDuplexNames, option)));
   }
 };
 
 class OrientationTraits : public NoValueValidation,
                           public ItemsTraits<kOptionPageOrientation> {
  public:
-  static bool Load(const base::DictionaryValue& dict, OrientationType* option) {
-    std::string type_str;
-    return dict.GetString(kKeyType, &type_str) &&
-           TypeFromString(kOrientationNames, type_str, option);
+  static bool Load(const base::Value& dict, OrientationType* option) {
+    const std::string* type = dict.FindStringKey(kKeyType);
+    return type && TypeFromString(kOrientationNames, *type, option);
   }
 
-  static void Save(OrientationType option, base::DictionaryValue* dict) {
-    dict->SetString(kKeyType, TypeToString(kOrientationNames, option));
+  static void Save(OrientationType option, base::Value* dict) {
+    dict->SetKey(kKeyType,
+                 base::Value(TypeToString(kOrientationNames, option)));
   }
 };
 
@@ -683,36 +1151,46 @@ class CopiesTraits : public ItemsTraits<kOptionCopies> {
  public:
   static bool IsValid(int32_t option) { return option >= 1; }
 
-  static bool Load(const base::DictionaryValue& dict, int32_t* option) {
-    return dict.GetInteger(kOptionCopies, option);
+  static bool Load(const base::Value& dict, int32_t* option) {
+    base::Optional<int> copies = dict.FindIntKey(kOptionCopies);
+    if (!copies)
+      return false;
+    *option = copies.value();
+    return true;
   }
 
-  static void Save(int32_t option, base::DictionaryValue* dict) {
-    dict->SetInteger(kOptionCopies, option);
+  static void Save(int32_t option, base::Value* dict) {
+    dict->SetKey(kOptionCopies, base::Value(option));
   }
 };
 
 class MarginsTraits : public NoValueValidation,
                       public ItemsTraits<kOptionMargins> {
  public:
-  static bool Load(const base::DictionaryValue& dict, Margins* option) {
-    std::string type_str;
-    if (!dict.GetString(kKeyType, &type_str))
+  static bool Load(const base::Value& dict, Margins* option) {
+    const std::string* type = dict.FindStringKey(kKeyType);
+    if (!type || !TypeFromString(kMarginsNames, *type, &option->type))
       return false;
-    if (!TypeFromString(kMarginsNames, type_str, &option->type))
+    base::Optional<int> top_um = dict.FindIntKey(kMarginTop);
+    base::Optional<int> right_um = dict.FindIntKey(kMarginRight);
+    base::Optional<int> bottom_um = dict.FindIntKey(kMarginBottom);
+    base::Optional<int> left_um = dict.FindIntKey(kMarginLeft);
+    if (!top_um || !right_um || !bottom_um || !left_um)
       return false;
-    return dict.GetInteger(kMarginTop, &option->top_um) &&
-           dict.GetInteger(kMarginRight, &option->right_um) &&
-           dict.GetInteger(kMarginBottom, &option->bottom_um) &&
-           dict.GetInteger(kMarginLeft, &option->left_um);
+    option->top_um = top_um.value();
+    option->right_um = right_um.value();
+    option->bottom_um = bottom_um.value();
+    option->left_um = left_um.value();
+    return true;
   }
 
-  static void Save(const Margins& option, base::DictionaryValue* dict) {
-    dict->SetString(kKeyType, TypeToString(kMarginsNames, option.type));
-    dict->SetInteger(kMarginTop, option.top_um);
-    dict->SetInteger(kMarginRight, option.right_um);
-    dict->SetInteger(kMarginBottom, option.bottom_um);
-    dict->SetInteger(kMarginLeft, option.left_um);
+  static void Save(const Margins& option, base::Value* dict) {
+    dict->SetKey(kKeyType,
+                 base::Value(TypeToString(kMarginsNames, option.type)));
+    dict->SetKey(kMarginTop, base::Value(option.top_um));
+    dict->SetKey(kMarginRight, base::Value(option.right_um));
+    dict->SetKey(kMarginBottom, base::Value(option.bottom_um));
+    dict->SetKey(kMarginLeft, base::Value(option.left_um));
   }
 };
 
@@ -720,28 +1198,32 @@ class DpiTraits : public ItemsTraits<kOptionDpi> {
  public:
   static bool IsValid(const Dpi& option) { return option.IsValid(); }
 
-  static bool Load(const base::DictionaryValue& dict, Dpi* option) {
-    return dict.GetInteger(kDpiHorizontal, &option->horizontal) &&
-           dict.GetInteger(kDpiVertical, &option->vertical);
+  static bool Load(const base::Value& dict, Dpi* option) {
+    base::Optional<int> horizontal = dict.FindIntKey(kDpiHorizontal);
+    base::Optional<int> vertical = dict.FindIntKey(kDpiVertical);
+    if (!horizontal || !vertical)
+      return false;
+    option->horizontal = horizontal.value();
+    option->vertical = vertical.value();
+    return true;
   }
 
-  static void Save(const Dpi& option, base::DictionaryValue* dict) {
-    dict->SetInteger(kDpiHorizontal, option.horizontal);
-    dict->SetInteger(kDpiVertical, option.vertical);
+  static void Save(const Dpi& option, base::Value* dict) {
+    dict->SetKey(kDpiHorizontal, base::Value(option.horizontal));
+    dict->SetKey(kDpiVertical, base::Value(option.vertical));
   }
 };
 
 class FitToPageTraits : public NoValueValidation,
                         public ItemsTraits<kOptionFitToPage> {
  public:
-  static bool Load(const base::DictionaryValue& dict, FitToPageType* option) {
-    std::string type_str;
-    return dict.GetString(kKeyType, &type_str) &&
-           TypeFromString(kFitToPageNames, type_str, option);
+  static bool Load(const base::Value& dict, FitToPageType* option) {
+    const std::string* type = dict.FindStringKey(kKeyType);
+    return type && TypeFromString(kFitToPageNames, *type, option);
   }
 
-  static void Save(FitToPageType option, base::DictionaryValue* dict) {
-    dict->SetString(kKeyType, TypeToString(kFitToPageNames, option));
+  static void Save(FitToPageType option, base::Value* dict) {
+    dict->SetKey(kKeyType, base::Value(TypeToString(kFitToPageNames, option)));
   }
 };
 
@@ -756,33 +1238,32 @@ class PageRangeTraits : public ItemsTraits<kOptionPageRange> {
     return true;
   }
 
-  static bool Load(const base::DictionaryValue& dict, PageRange* option) {
-    const base::ListValue* list = nullptr;
-    if (!dict.GetList(kPageRangeInterval, &list))
+  static bool Load(const base::Value& dict, PageRange* option) {
+    const base::Value* list_value =
+        dict.FindKeyOfType(kPageRangeInterval, base::Value::Type::LIST);
+    if (!list_value)
       return false;
-    for (size_t i = 0; i < list->GetSize(); ++i) {
-      const base::DictionaryValue* interval = nullptr;
-      if (!list->GetDictionary(i, &interval))
-        return false;
-      Interval new_interval(1, kMaxPageNumber);
-      interval->GetInteger(kPageRangeStart, &new_interval.start);
-      interval->GetInteger(kPageRangeEnd, &new_interval.end);
-      option->push_back(new_interval);
+    const base::Value::ListStorage& list = list_value->GetList();
+    for (const base::Value& interval : list) {
+      int page_range_start = interval.FindIntKey(kPageRangeStart).value_or(1);
+      int page_range_end =
+          interval.FindIntKey(kPageRangeEnd).value_or(kMaxPageNumber);
+      option->push_back(Interval(page_range_start, page_range_end));
     }
     return true;
   }
 
-  static void Save(const PageRange& option, base::DictionaryValue* dict) {
+  static void Save(const PageRange& option, base::Value* dict) {
     if (!option.empty()) {
-      auto list = std::make_unique<base::ListValue>();
+      base::Value list(base::Value::Type::LIST);
       for (size_t i = 0; i < option.size(); ++i) {
-        auto interval = std::make_unique<base::DictionaryValue>();
-        interval->SetInteger(kPageRangeStart, option[i].start);
+        base::Value interval(base::Value::Type::DICTIONARY);
+        interval.SetKey(kPageRangeStart, base::Value(option[i].start));
         if (option[i].end < kMaxPageNumber)
-          interval->SetInteger(kPageRangeEnd, option[i].end);
-        list->Append(std::move(interval));
+          interval.SetKey(kPageRangeEnd, base::Value(option[i].end));
+        list.GetList().emplace_back(std::move(interval));
       }
-      dict->Set(kPageRangeInterval, std::move(list));
+      dict->SetKey(kPageRangeInterval, std::move(list));
     }
   }
 };
@@ -791,34 +1272,48 @@ class MediaTraits : public ItemsTraits<kOptionMediaSize> {
  public:
   static bool IsValid(const Media& option) { return option.IsValid(); }
 
-  static bool Load(const base::DictionaryValue& dict, Media* option) {
-    std::string type_str;
-    if (dict.GetString(kKeyName, &type_str)) {
-      if (!TypeFromString(kMediaDefinitions, type_str, &option->type))
-        return false;
-    }
-
-    dict.GetInteger(kMediaWidth, &option->width_um);
-    dict.GetInteger(kMediaHeight, &option->height_um);
-    dict.GetBoolean(kMediaIsContinuous, &option->is_continuous_feed);
-    dict.GetString(kCustomName, &option->custom_display_name);
-    dict.GetString(kKeyVendorId, &option->vendor_id);
+  static bool Load(const base::Value& dict, Media* option) {
+    const std::string* type = dict.FindStringKey(kKeyName);
+    if (type && !TypeFromString(kMediaDefinitions, *type, &option->type))
+      return false;
+    base::Optional<int> width_um = dict.FindIntKey(kMediaWidth);
+    if (width_um)
+      option->width_um = width_um.value();
+    base::Optional<int> height_um = dict.FindIntKey(kMediaHeight);
+    if (height_um)
+      option->height_um = height_um.value();
+    base::Optional<bool> is_continuous_feed =
+        dict.FindBoolKey(kMediaIsContinuous);
+    if (is_continuous_feed)
+      option->is_continuous_feed = is_continuous_feed.value();
+    const std::string* custom_display_name =
+        dict.FindStringKey(kKeyCustomDisplayName);
+    if (custom_display_name)
+      option->custom_display_name = *custom_display_name;
+    const std::string* vendor_id = dict.FindStringKey(kKeyVendorId);
+    if (vendor_id)
+      option->vendor_id = *vendor_id;
     return true;
   }
 
-  static void Save(const Media& option, base::DictionaryValue* dict) {
-    if (option.type != CUSTOM_MEDIA)
-      dict->SetString(kKeyName, TypeToString(kMediaDefinitions, option.type));
-    if (!option.custom_display_name.empty() || option.type == CUSTOM_MEDIA)
-      dict->SetString(kCustomName, option.custom_display_name);
+  static void Save(const Media& option, base::Value* dict) {
+    if (option.type != MediaType::CUSTOM_MEDIA) {
+      dict->SetKey(kKeyName,
+                   base::Value(TypeToString(kMediaDefinitions, option.type)));
+    }
+    if (!option.custom_display_name.empty() ||
+        option.type == MediaType::CUSTOM_MEDIA) {
+      dict->SetKey(kKeyCustomDisplayName,
+                   base::Value(option.custom_display_name));
+    }
     if (!option.vendor_id.empty())
-      dict->SetString(kKeyVendorId, option.vendor_id);
+      dict->SetKey(kKeyVendorId, base::Value(option.vendor_id));
     if (option.width_um > 0)
-      dict->SetInteger(kMediaWidth, option.width_um);
+      dict->SetKey(kMediaWidth, base::Value(option.width_um));
     if (option.height_um > 0)
-      dict->SetInteger(kMediaHeight, option.height_um);
+      dict->SetKey(kMediaHeight, base::Value(option.height_um));
     if (option.is_continuous_feed)
-      dict->SetBoolean(kMediaIsContinuous, true);
+      dict->SetKey(kMediaIsContinuous, base::Value(true));
   }
 };
 
@@ -827,12 +1322,16 @@ class CollateTraits : public NoValueValidation,
  public:
   static const bool kDefault = true;
 
-  static bool Load(const base::DictionaryValue& dict, bool* option) {
-    return dict.GetBoolean(kOptionCollate, option);
+  static bool Load(const base::Value& dict, bool* option) {
+    base::Optional<bool> collate = dict.FindBoolKey(kOptionCollate);
+    if (!collate)
+      return false;
+    *option = collate.value();
+    return true;
   }
 
-  static void Save(bool option, base::DictionaryValue* dict) {
-    dict->SetBoolean(kOptionCollate, option);
+  static void Save(bool option, base::Value* dict) {
+    dict->SetKey(kOptionCollate, base::Value(option));
   }
 };
 
@@ -841,14 +1340,35 @@ class ReverseTraits : public NoValueValidation,
  public:
   static const bool kDefault = false;
 
-  static bool Load(const base::DictionaryValue& dict, bool* option) {
-    return dict.GetBoolean(kOptionReverse, option);
+  static bool Load(const base::Value& dict, bool* option) {
+    base::Optional<bool> reverse = dict.FindBoolKey(kOptionReverse);
+    if (!reverse)
+      return false;
+    *option = reverse.value();
+    return true;
+  }
+
+  static void Save(bool option, base::Value* dict) {
+    dict->SetKey(kOptionReverse, base::Value(option));
+  }
+};
+
+#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::DictionaryValue* dict) {
-    dict->SetBoolean(kOptionReverse, option);
+  static void Save(bool option, base::Value* dict) {
+    dict->SetKey(kPinSupported, base::Value(option));
   }
 };
+#endif  // defined(OS_CHROMEOS)
 
 }  // namespace printer
 
@@ -856,6 +1376,9 @@ using namespace printer;
 
 template class ListCapability<ContentType, ContentTypeTraits>;
 template class ValueCapability<PwgRasterConfig, PwgRasterConfigTraits>;
+template class ListCapability<VendorCapability, VendorCapabilityTraits>;
+template class SelectionCapability<SelectVendorCapabilityOption,
+                                   SelectVendorCapabilityTraits>;
 template class SelectionCapability<Color, ColorTraits>;
 template class SelectionCapability<DuplexType, DuplexTraits>;
 template class SelectionCapability<OrientationType, OrientationTraits>;
@@ -867,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>;