Cloud Print: Support SGRAY_8 PWG-raster printing.

BUG=521776

Cq-Include-Trybots: master.tryserver.chromium.linux:closure_compilation
Change-Id: I166b8e48a70cfbbc37f72490b4bcedc383653123
Reviewed-on: https://chromium-review.googlesource.com/674751
Commit-Queue: Lei Zhang <thestig@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Rebekah Potter <rbpotter@chromium.org>
Cr-Commit-Position: refs/heads/master@{#524595}

chrome/browser/printing/cloud_print/privet_http_unittest.cc

@@ -229,11 +229,28 @@ const char kSampleCapabilitiesResponsePWGSettings[] =
          }
        })";
 
+const char kSampleCapabilitiesResponsePWGSettingsMono[] =
+    R"({
+         "version": "1.0",
+         "printer": {
+           "pwg_raster_config": {
+             "document_type_supported": [ "SGRAY_8" ],
+             "document_sheet_back": "ROTATED"
+           }
+         }
+       })";
+
 const char kSampleCJTDuplex[] =
     R"({
          "version" : "1.0",
          "print": { "duplex": {"type": "SHORT_EDGE"} }
        })";
+
+const char kSampleCJTMono[] =
+    R"({
+         "version" : "1.0",
+         "print": { "color": {"type": "STANDARD_MONOCHROME"} }
+       })";
 #endif  // BUILDFLAG(ENABLE_PRINT_PREVIEW)
 
 const char* const kTestParams[] = {"8.8.4.4", "2001:4860:4860::8888"};
@@ -880,6 +897,9 @@ TEST_P(PrivetLocalPrintTest, SuccessfulPWGLocalPrint) {
             pwg_converter_->bitmap_settings().odd_page_transform);
   EXPECT_FALSE(pwg_converter_->bitmap_settings().rotate_all_pages);
   EXPECT_FALSE(pwg_converter_->bitmap_settings().reverse_page_order);
+
+  // Defaults to true when the color is not specified.
+  EXPECT_TRUE(pwg_converter_->bitmap_settings().use_color);
 }
 
 TEST_P(PrivetLocalPrintTest, SuccessfulPWGLocalPrintDuplex) {
@@ -914,6 +934,83 @@ TEST_P(PrivetLocalPrintTest, SuccessfulPWGLocalPrintDuplex) {
             pwg_converter_->bitmap_settings().odd_page_transform);
   EXPECT_FALSE(pwg_converter_->bitmap_settings().rotate_all_pages);
   EXPECT_TRUE(pwg_converter_->bitmap_settings().reverse_page_order);
+
+  // Defaults to true when the color is not specified.
+  EXPECT_TRUE(pwg_converter_->bitmap_settings().use_color);
+}
+
+TEST_P(PrivetLocalPrintTest, SuccessfulPWGLocalPrintMono) {
+  local_print_operation_->SetUsername("sample@gmail.com");
+  local_print_operation_->SetJobname("Sample job name");
+  local_print_operation_->SetData(RefCountedBytesFromString("path/to/"));
+  local_print_operation_->SetTicket(kSampleCJTMono);
+  local_print_operation_->SetCapabilities(
+      kSampleCapabilitiesResponsePWGSettings);
+  local_print_operation_->Start();
+
+  EXPECT_TRUE(SuccessfulResponseToURL(GetUrl("/privet/info"),
+                                      kSampleInfoResponseWithCreatejob));
+
+  EXPECT_TRUE(
+      SuccessfulResponseToURL(GetUrl("/privet/info"), kSampleInfoResponse));
+
+  EXPECT_TRUE(SuccessfulResponseToURLAndJSONData(
+      GetUrl("/privet/printer/createjob"), kSampleCJTMono,
+      kSampleCreatejobResponse));
+
+  EXPECT_CALL(local_print_delegate_, OnPrivetPrintingDoneInternal());
+
+  EXPECT_TRUE(SuccessfulResponseToURLAndFilePath(
+      GetUrl("/privet/printer/submitdoc?"
+             "client_name=Chrome&user_name=sample%40gmail.com"
+             "&job_name=Sample+job+name&job_id=1234"),
+      base::FilePath(FILE_PATH_LITERAL("path/to/test.pdf")),
+      kSampleLocalPrintResponse));
+
+  EXPECT_EQ(printing::TRANSFORM_NORMAL,
+            pwg_converter_->bitmap_settings().odd_page_transform);
+  EXPECT_FALSE(pwg_converter_->bitmap_settings().rotate_all_pages);
+  EXPECT_TRUE(pwg_converter_->bitmap_settings().reverse_page_order);
+
+  // Ticket specified mono, but no SGRAY_8 color capability.
+  EXPECT_TRUE(pwg_converter_->bitmap_settings().use_color);
+}
+
+TEST_P(PrivetLocalPrintTest, SuccessfulPWGLocalPrintMonoToGRAY8Printer) {
+  local_print_operation_->SetUsername("sample@gmail.com");
+  local_print_operation_->SetJobname("Sample job name");
+  local_print_operation_->SetData(RefCountedBytesFromString("path/to/"));
+  local_print_operation_->SetTicket(kSampleCJTMono);
+  local_print_operation_->SetCapabilities(
+      kSampleCapabilitiesResponsePWGSettingsMono);
+  local_print_operation_->Start();
+
+  EXPECT_TRUE(SuccessfulResponseToURL(GetUrl("/privet/info"),
+                                      kSampleInfoResponseWithCreatejob));
+
+  EXPECT_TRUE(
+      SuccessfulResponseToURL(GetUrl("/privet/info"), kSampleInfoResponse));
+
+  EXPECT_TRUE(SuccessfulResponseToURLAndJSONData(
+      GetUrl("/privet/printer/createjob"), kSampleCJTMono,
+      kSampleCreatejobResponse));
+
+  EXPECT_CALL(local_print_delegate_, OnPrivetPrintingDoneInternal());
+
+  EXPECT_TRUE(SuccessfulResponseToURLAndFilePath(
+      GetUrl("/privet/printer/submitdoc?"
+             "client_name=Chrome&user_name=sample%40gmail.com"
+             "&job_name=Sample+job+name&job_id=1234"),
+      base::FilePath(FILE_PATH_LITERAL("path/to/test.pdf")),
+      kSampleLocalPrintResponse));
+
+  EXPECT_EQ(printing::TRANSFORM_NORMAL,
+            pwg_converter_->bitmap_settings().odd_page_transform);
+  EXPECT_FALSE(pwg_converter_->bitmap_settings().rotate_all_pages);
+  EXPECT_FALSE(pwg_converter_->bitmap_settings().reverse_page_order);
+
+  // Ticket specified mono, and SGRAY_8 color capability exists.
+  EXPECT_FALSE(pwg_converter_->bitmap_settings().use_color);
 }
 
 TEST_P(PrivetLocalPrintTest, SuccessfulLocalPrintWithCreatejob) {

chrome/browser/printing/pwg_raster_converter.cc

@@ -278,6 +278,36 @@ PwgRasterSettings PwgRasterConverter::GetBitmapSettings(
   if (duplex_item.LoadFrom(ticket))
     duplex_value = duplex_item.value();
 
+  // This assumes |ticket| contains a color ticket item. In case it does not, or
+  // the color is invalid, |color_value| will default to AUTO_COLOR, which works
+  // just fine. With AUTO_COLOR, it may be possible to better determine the
+  // value for |use_color| based on |printer_capabilities|, rather than just
+  // defaulting to the safe value of true. Parsing |printer_capabilities|
+  // requires work, which this method is avoiding on purpose.
+  cloud_devices::printer::Color color_value;
+  cloud_devices::printer::ColorTicketItem color_item;
+  if (color_item.LoadFrom(ticket) && color_item.IsValid())
+    color_value = color_item.value();
+  DCHECK(color_value.IsValid());
+  bool use_color;
+  switch (color_value.type) {
+    case cloud_devices::printer::STANDARD_MONOCHROME:
+    case cloud_devices::printer::CUSTOM_MONOCHROME:
+      use_color = false;
+      break;
+
+    case cloud_devices::printer::STANDARD_COLOR:
+    case cloud_devices::printer::CUSTOM_COLOR:
+    case cloud_devices::printer::AUTO_COLOR:
+      use_color = true;
+      break;
+
+    default:
+      NOTREACHED();
+      use_color = true;  // Still need to initialize |color| or MSVC will warn.
+      break;
+  }
+
   cloud_devices::printer::PwgRasterConfigCapability raster_capability;
   // If the raster capability fails to load, |raster_capability| will contain
   // the default value.
@@ -306,6 +336,14 @@ PwgRasterSettings PwgRasterConverter::GetBitmapSettings(
 
   result.rotate_all_pages = raster_capability.value().rotate_all_pages;
   result.reverse_page_order = raster_capability.value().reverse_order_streaming;
+
+  // No need to check for SRGB_8 support in |types|. CDD spec says:
+  // "any printer that doesn't support SGRAY_8 must be able to perform
+  // conversion from RGB to grayscale... "
+  const auto& types = raster_capability.value().document_types_supported;
+  result.use_color =
+      use_color || !base::ContainsValue(types, cloud_devices::printer::SGRAY_8);
+
   return result;
 }
 

chrome/browser/printing/pwg_raster_converter_browsertest.cc

@@ -21,6 +21,18 @@ namespace printing {
 
 namespace {
 
+// Note that for some reason the generated PWG varies depending on the
+// platform (32 or 64 bits) on Linux.
+#if defined(OS_LINUX) && defined(ARCH_CPU_32_BITS)
+constexpr char kPdfToPwgRasterColorTestFile[] = "pdf_to_pwg_raster_test_32.pwg";
+constexpr char kPdfToPwgRasterMonoTestFile[] =
+    "pdf_to_pwg_raster_mono_test_32.pwg";
+#else
+constexpr char kPdfToPwgRasterColorTestFile[] = "pdf_to_pwg_raster_test.pwg";
+constexpr char kPdfToPwgRasterMonoTestFile[] =
+    "pdf_to_pwg_raster_mono_test.pwg";
+#endif
+
 void ResultCallbackImpl(bool* called,
                         bool* success_out,
                         base::FilePath* temp_file_out,
@@ -33,6 +45,33 @@ void ResultCallbackImpl(bool* called,
   quit_closure.Run();
 }
 
+void GetPdfData(const char* file_name,
+                base::FilePath* test_data_dir,
+                scoped_refptr<base::RefCountedString>* pdf_data) {
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, test_data_dir));
+  *test_data_dir = test_data_dir->AppendASCII("printing");
+  base::FilePath pdf_file = test_data_dir->AppendASCII(file_name);
+  std::string pdf_data_str;
+  ASSERT_TRUE(base::ReadFileToString(pdf_file, &pdf_data_str));
+  ASSERT_GT(pdf_data_str.length(), 0U);
+  *pdf_data = base::RefCountedString::TakeString(&pdf_data_str);
+}
+
+std::string HashFile(const std::string& file_data) {
+  std::string sha1 = base::SHA1HashString(file_data);
+  return base::HexEncode(sha1.c_str(), sha1.length());
+}
+
+void ComparePwgFiles(const base::FilePath& expected,
+                     const base::FilePath& actual) {
+  std::string pwg_expected_data_str;
+  ASSERT_TRUE(base::ReadFileToString(expected, &pwg_expected_data_str));
+  std::string pwg_actual_data_str;
+  ASSERT_TRUE(base::ReadFileToString(actual, &pwg_actual_data_str));
+  EXPECT_EQ(pwg_expected_data_str.length(), pwg_actual_data_str.length());
+  EXPECT_EQ(HashFile(pwg_expected_data_str), HashFile(pwg_actual_data_str));
+}
+
 class PdfToPwgRasterBrowserTest : public InProcessBrowserTest {
  public:
   PdfToPwgRasterBrowserTest()
@@ -59,11 +98,6 @@ class PdfToPwgRasterBrowserTest : public InProcessBrowserTest {
   std::unique_ptr<PwgRasterConverter> converter_;
 };
 
-std::string HashFile(const std::string& file_data) {
-  std::string sha1 = base::SHA1HashString(file_data);
-  return base::HexEncode(sha1.c_str(), sha1.length());
-}
-
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(PdfToPwgRasterBrowserTest, TestFailure) {
@@ -74,19 +108,12 @@ IN_PROC_BROWSER_TEST_F(PdfToPwgRasterBrowserTest, TestFailure) {
           /*expect_success=*/false, &temp_file);
 }
 
-IN_PROC_BROWSER_TEST_F(PdfToPwgRasterBrowserTest, TestSuccess) {
+IN_PROC_BROWSER_TEST_F(PdfToPwgRasterBrowserTest, TestSuccessColor) {
   base::ScopedAllowBlockingForTesting allow_blocking;
 
   base::FilePath test_data_dir;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
-  test_data_dir = test_data_dir.AppendASCII("printing");
-  base::FilePath pdf_file =
-      test_data_dir.AppendASCII("pdf_to_pwg_raster_test.pdf");
-  std::string pdf_data_str;
-  ASSERT_TRUE(base::ReadFileToString(pdf_file, &pdf_data_str));
-  ASSERT_GT(pdf_data_str.length(), 0U);
-  scoped_refptr<base::RefCountedString> pdf_data(
-      base::RefCountedString::TakeString(&pdf_data_str));
+  scoped_refptr<base::RefCountedString> pdf_data;
+  GetPdfData("pdf_to_pwg_raster_test.pdf", &test_data_dir, &pdf_data);
 
   PdfRenderSettings pdf_settings(gfx::Rect(0, 0, 500, 500), gfx::Point(0, 0),
                                  /*dpi=*/1000, /*autorotate=*/false,
@@ -95,27 +122,42 @@ IN_PROC_BROWSER_TEST_F(PdfToPwgRasterBrowserTest, TestSuccess) {
   pwg_settings.odd_page_transform = PwgRasterTransformType::TRANSFORM_NORMAL;
   pwg_settings.rotate_all_pages = false;
   pwg_settings.reverse_page_order = false;
+  pwg_settings.use_color = true;
 
   base::FilePath temp_file;
   Convert(pdf_data.get(), pdf_settings, pwg_settings,
           /*expect_success=*/true, &temp_file);
   ASSERT_FALSE(temp_file.empty());
 
-  // Note that for some reason the generated PWG varies depending on the
-  // platform (32 or 64 bits) on Linux.
-  base::FilePath pwg_file = test_data_dir.AppendASCII(
-#if defined(OS_LINUX) && defined(ARCH_CPU_32_BITS)
-      "pdf_to_pwg_raster_test_32.pwg");
-#else
-      "pdf_to_pwg_raster_test.pwg");
-#endif
+  base::FilePath pwg_file =
+      test_data_dir.AppendASCII(kPdfToPwgRasterColorTestFile);
+  ComparePwgFiles(pwg_file, temp_file);
+}
 
-  std::string pwg_expected_data_str;
-  ASSERT_TRUE(base::ReadFileToString(pwg_file, &pwg_expected_data_str));
-  std::string pwg_actual_data_str;
-  ASSERT_TRUE(base::ReadFileToString(temp_file, &pwg_actual_data_str));
-  EXPECT_EQ(pwg_expected_data_str.length(), pwg_actual_data_str.length());
-  EXPECT_EQ(HashFile(pwg_expected_data_str), HashFile(pwg_actual_data_str));
+IN_PROC_BROWSER_TEST_F(PdfToPwgRasterBrowserTest, TestSuccessMono) {
+  base::ScopedAllowBlockingForTesting allow_blocking;
+
+  base::FilePath test_data_dir;
+  scoped_refptr<base::RefCountedString> pdf_data;
+  GetPdfData("pdf_to_pwg_raster_test.pdf", &test_data_dir, &pdf_data);
+
+  PdfRenderSettings pdf_settings(gfx::Rect(0, 0, 500, 500), gfx::Point(0, 0),
+                                 /*dpi=*/1000, /*autorotate=*/false,
+                                 PdfRenderSettings::Mode::NORMAL);
+  PwgRasterSettings pwg_settings;
+  pwg_settings.odd_page_transform = PwgRasterTransformType::TRANSFORM_NORMAL;
+  pwg_settings.rotate_all_pages = false;
+  pwg_settings.reverse_page_order = false;
+  pwg_settings.use_color = false;
+
+  base::FilePath temp_file;
+  Convert(pdf_data.get(), pdf_settings, pwg_settings,
+          /*expect_success=*/true, &temp_file);
+  ASSERT_FALSE(temp_file.empty());
+
+  base::FilePath pwg_file =
+      test_data_dir.AppendASCII(kPdfToPwgRasterMonoTestFile);
+  ComparePwgFiles(pwg_file, temp_file);
 }
 
 }  // namespace printing

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

@@ -435,7 +435,20 @@ cr.define('print_preview', function() {
             cjt.print.color.vendor_id = selectedOption.vendor_id;
           }
         }
+      } else {
+        // Always try setting the color in the print ticket, otherwise a
+        // reasonable reader of the ticket will have to do more work, or process
+        // the ticket sub-optimally, in order to safely handle the lack of a
+        // color ticket item.
+        const defaultOption = this.color.defaultColorOption();
+        if (defaultOption) {
+          cjt.print.color = {type: defaultOption.type};
+          if (defaultOption.hasOwnProperty('vendor_id')) {
+            cjt.print.color.vendor_id = defaultOption.vendor_id;
+          }
+        }
       }
+
       if (this.copies.isCapabilityAvailable() && this.copies.isUserEdited()) {
         cjt.print.copies = {copies: this.copies.getValueAsNumber()};
       }

chrome/browser/resources/print_preview/data/ticket_items/color.js

@@ -49,6 +49,18 @@ cr.define('print_preview.ticket_items', function() {
           null;
     }
 
+    /** @return {Object} Printer's default color option. */
+    defaultColorOption() {
+      const capability = this.capability;
+      if (!capability) {
+        return null;
+      }
+      const defaultOptions = capability.option.filter(function(option) {
+        return option.is_default;
+      });
+      return defaultOptions.length != 0 ? defaultOptions[0] : null;
+    }
+
     /** @return {Object} Color option corresponding to the current value. */
     getSelectedOption() {
       const capability = this.capability;
@@ -70,9 +82,7 @@ cr.define('print_preview.ticket_items', function() {
 
     /** @override */
     getDefaultValueInternal() {
-      const capability = this.capability;
-      const defaultOption =
-          capability ? this.getDefaultColorOption_(capability.option) : null;
+      const defaultOption = this.defaultColorOption();
       return defaultOption &&
           (Color.COLOR_TYPES_.indexOf(defaultOption.type) >= 0);
     }
@@ -91,21 +101,6 @@ cr.define('print_preview.ticket_items', function() {
       }
       return this.getDefaultValueInternal();
     }
-
-    /**
-     * @param {!Array<!Object<{type: (string|undefined),
-     *                           is_default: (boolean|undefined)}>>} options
-     * @return {Object<{type: (string|undefined),
-     *                   is_default: (boolean|undefined)}>} Default color
-     *     option of the given list.
-     * @private
-     */
-    getDefaultColorOption_(options) {
-      const defaultOptions = options.filter(function(option) {
-        return option.is_default;
-      });
-      return (defaultOptions.length == 0) ? null : defaultOptions[0];
-    }
   }
 
   /**

chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc

@@ -800,6 +800,7 @@ TEST_F(ExtensionPrinterHandlerTest, Print_Pwg) {
             pwg_raster_converter_->bitmap_settings().odd_page_transform);
   EXPECT_FALSE(pwg_raster_converter_->bitmap_settings().rotate_all_pages);
   EXPECT_FALSE(pwg_raster_converter_->bitmap_settings().reverse_page_order);
+  EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().use_color);
 
   EXPECT_EQ(printing::kDefaultPdfDpi,
             pwg_raster_converter_->conversion_settings().dpi);
@@ -853,6 +854,7 @@ TEST_F(ExtensionPrinterHandlerTest, Print_Pwg_NonDefaultSettings) {
             pwg_raster_converter_->bitmap_settings().odd_page_transform);
   EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().rotate_all_pages);
   EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().reverse_page_order);
+  EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().use_color);
 
   EXPECT_EQ(200,  // max(vertical_dpi, horizontal_dpi)
             pwg_raster_converter_->conversion_settings().dpi);

chrome/services/printing/pdf_to_pwg_raster_converter.cc

@@ -4,6 +4,10 @@
 
 #include "chrome/services/printing/pdf_to_pwg_raster_converter.h"
 
+#include <limits>
+#include <string>
+#include <utility>
+
 #include "chrome/utility/cloud_print/bitmap_image.h"
 #include "chrome/utility/cloud_print/pwg_encoder.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
@@ -59,6 +63,9 @@ bool RenderPdfPagesToPwgRaster(base::File pdf_file,
     cloud_print::PwgHeaderInfo header_info;
     header_info.dpi = gfx::Size(settings.dpi, settings.dpi);
     header_info.total_pages = total_page_count;
+    header_info.color_space = bitmap_settings.use_color
+                                  ? cloud_print::PwgHeaderInfo::SRGB
+                                  : cloud_print::PwgHeaderInfo::SGRAY;
 
     // Transform odd pages.
     if (page_number % 2) {

chrome/services/printing/public/interfaces/pdf_to_pwg_raster_converter.mojom

@@ -22,6 +22,9 @@ struct PwgRasterSettings {
 
   // Rasterize pages in reverse order.
   bool reverse_page_order;
+
+  // Rasterize pages in color.
+  bool use_color;
 };
 
 interface PdfToPwgRasterConverter {

chrome/services/printing/public/interfaces/pdf_to_pwg_raster_converter_struct_traits.cc

@@ -13,6 +13,7 @@ bool StructTraits<printing::mojom::PwgRasterSettingsDataView,
          printing::PwgRasterSettings* out) {
   out->rotate_all_pages = data.rotate_all_pages();
   out->reverse_page_order = data.reverse_page_order();
+  out->use_color = data.use_color();
   return data.ReadOddPageTransform(&out->odd_page_transform);
 }
 

chrome/services/printing/public/interfaces/pdf_to_pwg_raster_converter_struct_traits.h

@@ -69,6 +69,9 @@ class StructTraits<printing::mojom::PwgRasterSettingsDataView,
   static bool reverse_page_order(const printing::PwgRasterSettings& settings) {
     return settings.reverse_page_order;
   }
+  static bool use_color(const printing::PwgRasterSettings& settings) {
+    return settings.use_color;
+  }
   static printing::PwgRasterTransformType odd_page_transform(
       const printing::PwgRasterSettings& settings) {
     return settings.odd_page_transform;

components/cloud_devices/common/printer_description.cc

@@ -67,6 +67,7 @@ const char kPageRangeInterval[] = "interval";
 const char kPageRangeEnd[] = "end";
 const char kPageRangeStart[] = "start";
 
+const char kPwgRasterDocumentTypeSupported[] = "document_type_supported";
 const char kPwgRasterDocumentSheetBack[] = "document_sheet_back";
 const char kPwgRasterReverseOrderStreaming[] = "reverse_order_streaming";
 const char kPwgRasterRotateAllPages[] = "rotate_all_pages";
@@ -95,6 +96,9 @@ const char kTypeOrientationAuto[] = "AUTO";
 const char kTypeOrientationLandscape[] = "LANDSCAPE";
 const char kTypeOrientationPortrait[] = "PORTRAIT";
 
+const char kTypeDocumentSupportedTypeSRGB8[] = "SRGB_8";
+const char kTypeDocumentSupportedTypeSGRAY8[] = "SGRAY_8";
+
 const char kTypeDocumentSheetBackNormal[] = "NORMAL";
 const char kTypeDocumentSheetBackRotated[] = "ROTATED";
 const char kTypeDocumentSheetBackManualTumble[] = "MANUAL_TUMBLE";
@@ -391,6 +395,8 @@ PwgRasterConfig::PwgRasterConfig()
       rotate_all_pages(false) {
 }
 
+PwgRasterConfig::~PwgRasterConfig() {}
+
 Color::Color() : type(AUTO_COLOR) {
 }
 
@@ -564,6 +570,24 @@ class PwgRasterConfigTraits : public NoValueValidation,
       }
     }
 
+    const base::Value* document_types_supported =
+        dict.FindKey(kPwgRasterDocumentTypeSupported);
+    if (document_types_supported) {
+      if (!document_types_supported->is_list())
+        return false;
+
+      for (const auto& type : document_types_supported->GetList()) {
+        if (!type.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);
+      }
+    }
+
     dict.GetBoolean(kPwgRasterReverseOrderStreaming,
                     &option_out.reverse_order_streaming);
     dict.GetBoolean(kPwgRasterRotateAllPages, &option_out.rotate_all_pages);
@@ -576,6 +600,24 @@ class PwgRasterConfigTraits : public NoValueValidation,
         kPwgRasterDocumentSheetBack,
         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:
+            supported_list.push_back(
+                base::Value(kTypeDocumentSupportedTypeSRGB8));
+            break;
+          case SGRAY_8:
+            supported_list.push_back(
+                base::Value(kTypeDocumentSupportedTypeSGRAY8));
+            break;
+        }
+      }
+      dict->SetKey(kPwgRasterDocumentTypeSupported,
+                   base::Value(supported_list));
+    }
+
     if (option.reverse_order_streaming) {
       dict->SetBoolean(kPwgRasterReverseOrderStreaming,
                        option.reverse_order_streaming);

components/cloud_devices/common/printer_description.h

@@ -24,9 +24,16 @@ typedef std::string ContentType;
 
 enum DocumentSheetBack { NORMAL, ROTATED, MANUAL_TUMBLE, FLIPPED };
 
+enum PwgDocumentTypeSupported {
+  SGRAY_8 = 22,
+  SRGB_8 = 23,
+};
+
 struct PwgRasterConfig {
   PwgRasterConfig();
+  ~PwgRasterConfig();
 
+  std::vector<PwgDocumentTypeSupported> document_types_supported;
   DocumentSheetBack document_sheet_back;
   bool reverse_order_streaming;
   bool rotate_all_pages;

components/cloud_devices/common/printer_description_unittest.cc

@@ -194,6 +194,82 @@ const char kMultyDefaultCdd[] =
     "  }"
     "}";
 
+const char kDocumentTypeColorOnlyCdd[] =
+    "{"
+    "  'version': '1.0',"
+    "  'printer': {"
+    "    'pwg_raster_config': {"
+    "      'document_type_supported': [ 'SRGB_8' ],"
+    "      'document_sheet_back': 'ROTATED'"
+    "    }"
+    "  }"
+    "}";
+
+const char kDocumentTypeGrayOnlyCdd[] =
+    "{"
+    "  'version': '1.0',"
+    "  'printer': {"
+    "    'pwg_raster_config': {"
+    "      'document_type_supported': [ 'SGRAY_8' ],"
+    "      'document_sheet_back': 'ROTATED'"
+    "    }"
+    "  }"
+    "}";
+
+const char kDocumentTypeColorAndGrayCdd[] =
+    "{"
+    "  'version': '1.0',"
+    "  'printer': {"
+    "    'pwg_raster_config': {"
+    "      'document_type_supported': [ 'SRGB_8', 'SGRAY_8' ],"
+    "      'document_sheet_back': 'ROTATED'"
+    "    }"
+    "  }"
+    "}";
+
+const char kDocumentTypeColorAndUnsupportedCdd[] =
+    "{"
+    "  'version': '1.0',"
+    "  'printer': {"
+    "    'pwg_raster_config': {"
+    "      'document_type_supported': [ 'SRGB_8', 'SRGB_16' ],"
+    "      'document_sheet_back': 'ROTATED'"
+    "    }"
+    "  }"
+    "}";
+
+const char kDocumentTypeNoneCdd[] =
+    "{"
+    "  'version': '1.0',"
+    "  'printer': {"
+    "    'pwg_raster_config': {"
+    "      'document_sheet_back': 'ROTATED'"
+    "    }"
+    "  }"
+    "}";
+
+const char kDocumentTypeNotStringCdd[] =
+    "{"
+    "  'version': '1.0',"
+    "  'printer': {"
+    "    'pwg_raster_config': {"
+    "      'document_type_supported': [ 8, 16 ],"
+    "      'document_sheet_back': 'ROTATED'"
+    "    }"
+    "  }"
+    "}";
+
+const char kDocumentTypeNotListCdd[] =
+    "{"
+    "  'version': '1.0',"
+    "  'printer': {"
+    "    'pwg_raster_config': {"
+    "      'document_type_supported': 'ROTATED',"
+    "      'document_sheet_back': 'ROTATED'"
+    "    }"
+    "  }"
+    "}";
+
 const char kCjt[] =
     "{"
     "  'version': '1.0',"
@@ -388,6 +464,144 @@ TEST(PrinterDescriptionTest, CddSetAll) {
   EXPECT_EQ(NormalizeJson(kCdd), NormalizeJson(description.ToString()));
 }
 
+TEST(PrinterDescriptionTest, CddGetDocumentTypeSupported) {
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(
+        description.InitFromString(NormalizeJson(kDocumentTypeColorOnlyCdd)));
+
+    PwgRasterConfigCapability pwg_raster;
+    EXPECT_TRUE(pwg_raster.LoadFrom(description));
+    ASSERT_EQ(1U, pwg_raster.value().document_types_supported.size());
+    EXPECT_EQ(SRGB_8, pwg_raster.value().document_types_supported[0]);
+    EXPECT_EQ(ROTATED, pwg_raster.value().document_sheet_back);
+    EXPECT_FALSE(pwg_raster.value().reverse_order_streaming);
+  }
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(
+        description.InitFromString(NormalizeJson(kDocumentTypeGrayOnlyCdd)));
+
+    PwgRasterConfigCapability pwg_raster;
+    EXPECT_TRUE(pwg_raster.LoadFrom(description));
+    ASSERT_EQ(1U, pwg_raster.value().document_types_supported.size());
+    EXPECT_EQ(SGRAY_8, pwg_raster.value().document_types_supported[0]);
+    EXPECT_EQ(ROTATED, pwg_raster.value().document_sheet_back);
+    EXPECT_FALSE(pwg_raster.value().reverse_order_streaming);
+  }
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(description.InitFromString(
+        NormalizeJson(kDocumentTypeColorAndGrayCdd)));
+
+    PwgRasterConfigCapability pwg_raster;
+    EXPECT_TRUE(pwg_raster.LoadFrom(description));
+    ASSERT_EQ(2U, pwg_raster.value().document_types_supported.size());
+    EXPECT_EQ(SRGB_8, pwg_raster.value().document_types_supported[0]);
+    EXPECT_EQ(SGRAY_8, pwg_raster.value().document_types_supported[1]);
+    EXPECT_EQ(ROTATED, pwg_raster.value().document_sheet_back);
+    EXPECT_FALSE(pwg_raster.value().reverse_order_streaming);
+  }
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(description.InitFromString(
+        NormalizeJson(kDocumentTypeColorAndUnsupportedCdd)));
+
+    PwgRasterConfigCapability pwg_raster;
+    EXPECT_TRUE(pwg_raster.LoadFrom(description));
+    ASSERT_EQ(1U, pwg_raster.value().document_types_supported.size());
+    EXPECT_EQ(SRGB_8, pwg_raster.value().document_types_supported[0]);
+    EXPECT_EQ(ROTATED, pwg_raster.value().document_sheet_back);
+    EXPECT_FALSE(pwg_raster.value().reverse_order_streaming);
+  }
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(
+        description.InitFromString(NormalizeJson(kDocumentTypeNoneCdd)));
+
+    PwgRasterConfigCapability pwg_raster;
+    EXPECT_TRUE(pwg_raster.LoadFrom(description));
+    EXPECT_EQ(0U, pwg_raster.value().document_types_supported.size());
+    EXPECT_EQ(ROTATED, pwg_raster.value().document_sheet_back);
+    EXPECT_FALSE(pwg_raster.value().reverse_order_streaming);
+  }
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(
+        description.InitFromString(NormalizeJson(kDocumentTypeNotStringCdd)));
+
+    PwgRasterConfigCapability pwg_raster;
+    EXPECT_FALSE(pwg_raster.LoadFrom(description));
+  }
+  {
+    CloudDeviceDescription description;
+    ASSERT_TRUE(
+        description.InitFromString(NormalizeJson(kDocumentTypeNotListCdd)));
+
+    PwgRasterConfigCapability pwg_raster;
+    EXPECT_FALSE(pwg_raster.LoadFrom(description));
+  }
+}
+
+TEST(PrinterDescriptionTest, CddSetDocumentTypeSupported) {
+  {
+    CloudDeviceDescription description;
+
+    PwgRasterConfig custom_raster;
+    custom_raster.document_types_supported.push_back(SRGB_8);
+    custom_raster.document_sheet_back = ROTATED;
+
+    PwgRasterConfigCapability pwg_raster;
+    pwg_raster.set_value(custom_raster);
+    pwg_raster.SaveTo(&description);
+
+    EXPECT_EQ(NormalizeJson(kDocumentTypeColorOnlyCdd),
+              NormalizeJson(description.ToString()));
+  }
+  {
+    CloudDeviceDescription description;
+
+    PwgRasterConfig custom_raster;
+    custom_raster.document_types_supported.push_back(SGRAY_8);
+    custom_raster.document_sheet_back = ROTATED;
+
+    PwgRasterConfigCapability pwg_raster;
+    pwg_raster.set_value(custom_raster);
+    pwg_raster.SaveTo(&description);
+
+    EXPECT_EQ(NormalizeJson(kDocumentTypeGrayOnlyCdd),
+              NormalizeJson(description.ToString()));
+  }
+  {
+    CloudDeviceDescription description;
+
+    PwgRasterConfig custom_raster;
+    custom_raster.document_types_supported.push_back(SRGB_8);
+    custom_raster.document_types_supported.push_back(SGRAY_8);
+    custom_raster.document_sheet_back = ROTATED;
+
+    PwgRasterConfigCapability pwg_raster;
+    pwg_raster.set_value(custom_raster);
+    pwg_raster.SaveTo(&description);
+
+    EXPECT_EQ(NormalizeJson(kDocumentTypeColorAndGrayCdd),
+              NormalizeJson(description.ToString()));
+  }
+  {
+    CloudDeviceDescription description;
+
+    PwgRasterConfig custom_raster;
+    custom_raster.document_sheet_back = ROTATED;
+
+    PwgRasterConfigCapability pwg_raster;
+    pwg_raster.set_value(custom_raster);
+    pwg_raster.SaveTo(&description);
+
+    EXPECT_EQ(NormalizeJson(kDocumentTypeNoneCdd),
+              NormalizeJson(description.ToString()));
+  }
+}
+
 TEST(PrinterDescriptionTest, CddGetAll) {
   CloudDeviceDescription description;
   ASSERT_TRUE(description.InitFromString(NormalizeJson(kCdd)));
@@ -424,6 +638,7 @@ TEST(PrinterDescriptionTest, CddGetAll) {
   EXPECT_TRUE(content_types.Contains("image/pwg-raster"));
   EXPECT_TRUE(content_types.Contains("image/jpeg"));
 
+  EXPECT_EQ(0U, pwg_raster_config.value().document_types_supported.size());
   EXPECT_EQ(MANUAL_TUMBLE, pwg_raster_config.value().document_sheet_back);
   EXPECT_TRUE(pwg_raster_config.value().reverse_order_streaming);
   EXPECT_FALSE(pwg_raster_config.value().rotate_all_pages);

printing/pwg_raster_settings.h

@@ -22,6 +22,8 @@ struct PwgRasterSettings {
   bool rotate_all_pages;
   // Rasterize pages in reverse order.
   bool reverse_page_order;
+  // Rasterize pages in color.
+  bool use_color;
 };
 
 }  // namespace printing