From 6c11fb357ec39bf087b8b632e2b1e375aef1b38b Mon Sep 17 00:00:00 2001 From: Allan Sandfeld Jensen Date: Thu, 16 May 2019 09:59:13 +0200 Subject: BASELINE: Update Chromium to 74.0.3729.159 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: I8d2497da544c275415aedd94dd25328d555de811 Reviewed-by: Michael Brüning --- .../cloud_devices/common/printer_description.cc | 1210 ++++++++++++++------ 1 file changed, 868 insertions(+), 342 deletions(-) (limited to 'chromium/components/cloud_devices/common/printer_description.cc') 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 #include #include +#include #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(width* unit_um + 0.5), \ - static_cast(height* unit_um + 0.5) \ + type, &#type[strlen("MediaType::")], \ + static_cast(width * unit_um + 0.5), \ + static_cast(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 class ItemsTraits { public: - static std::string GetCapabilityPath() { - std::string result = kSectionPrinter; - result += '.'; - result += kName; - return result; + static std::vector GetCapabilityPath() { + return {kSectionPrinter, kName}; } - static std::string GetTicketItemPath() { - std::string result = kSectionPrint; - result += '.'; - result += kName; - return result; + static std::vector GetTicketItemPath() { + return {kSectionPrint, kName}; } }; @@ -546,24 +957,30 @@ class NoValueValidation { class ContentTypeTraits : public NoValueValidation, public ItemsTraits { 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 { 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 { + 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 { + 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 { 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 { 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 { 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 { 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 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 { 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 top_um = dict.FindIntKey(kMarginTop); + base::Optional right_um = dict.FindIntKey(kMarginRight); + base::Optional bottom_um = dict.FindIntKey(kMarginBottom); + base::Optional 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 { 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 horizontal = dict.FindIntKey(kDpiHorizontal); + base::Optional 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 { 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 { 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::Value list(base::Value::Type::LIST); for (size_t i = 0; i < option.size(); ++i) { - auto interval = std::make_unique(); - 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 { 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 width_um = dict.FindIntKey(kMediaWidth); + if (width_um) + option->width_um = width_um.value(); + base::Optional height_um = dict.FindIntKey(kMediaHeight); + if (height_um) + option->height_um = height_um.value(); + base::Optional 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 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 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 { + public: + static bool Load(const base::Value& dict, bool* option) { + base::Optional 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; template class ValueCapability; +template class ListCapability; +template class SelectionCapability; template class SelectionCapability; template class SelectionCapability; template class SelectionCapability; @@ -867,6 +1390,9 @@ template class EmptyCapability; template class EmptyCapability; template class BooleanCapability; template class BooleanCapability; +#if defined(OS_CHROMEOS) +template class ValueCapability; +#endif // defined(OS_CHROMEOS) template class TicketItem; template class TicketItem; -- cgit v1.2.1