chrome/browser/printing/pwg_raster_converter.cc - chromium/src - Git at Google

 // Copyright 2013 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "chrome/browser/printing/pwg_raster_converter.h"

 #include <algorithm>
 #include <memory>
 #include <optional>
 #include <utility>

 #include "base/cancelable_callback.h"
 #include "base/check_op.h"
 #include "base/containers/contains.h"
 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/notreached.h"
 #include "chrome/browser/printing/printing_service.h"
 #include "chrome/services/printing/public/mojom/pdf_to_pwg_raster_converter.mojom.h"
 #include "chrome/services/printing/public/mojom/printing_service.mojom.h"
 #include "components/cloud_devices/common/cloud_device_description.h"
 #include "components/cloud_devices/common/printer_description.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "printing/mojom/print.mojom.h"
 #include "printing/pdf_render_settings.h"
 #include "printing/pwg_raster_settings.h"
 #include "printing/units.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"

 namespace printing {

 namespace {

 using content::BrowserThread;

 // Converts PDF into PWG raster. Class lives on the UI thread.
 class PwgRasterConverterHelper
     : public base::RefCounted<PwgRasterConverterHelper> {
  public:
   PwgRasterConverterHelper(const PdfRenderSettings& settings,
                            const PwgRasterSettings& bitmap_settings);

   PwgRasterConverterHelper(const PwgRasterConverterHelper&) = delete;
   PwgRasterConverterHelper& operator=(const PwgRasterConverterHelper&) = delete;

   void Convert(const std::optional<bool>& use_skia,
                const base::RefCountedMemory* data,
                PwgRasterConverter::ResultCallback callback);

  private:
   friend class base::RefCounted<PwgRasterConverterHelper>;

   ~PwgRasterConverterHelper();

   void RunCallback(base::ReadOnlySharedMemoryRegion region,
                    uint32_t page_count);

   PdfRenderSettings settings_;
   PwgRasterSettings bitmap_settings_;
   mojo::Remote<printing::mojom::PdfToPwgRasterConverter>
       pdf_to_pwg_raster_converter_remote_;
   PwgRasterConverter::ResultCallback callback_;
 };

 PwgRasterConverterHelper::PwgRasterConverterHelper(
     const PdfRenderSettings& settings,
     const PwgRasterSettings& bitmap_settings)
     : settings_(settings), bitmap_settings_(bitmap_settings) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }

 PwgRasterConverterHelper::~PwgRasterConverterHelper() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }

 void PwgRasterConverterHelper::Convert(
     const std::optional<bool>& use_skia,
     const base::RefCountedMemory* data,
     PwgRasterConverter::ResultCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);

   callback_ = std::move(callback);

   GetPrintingService()->BindPdfToPwgRasterConverter(
       pdf_to_pwg_raster_converter_remote_.BindNewPipeAndPassReceiver());
   pdf_to_pwg_raster_converter_remote_.set_disconnect_handler(
       base::BindOnce(&PwgRasterConverterHelper::RunCallback, this,
                      base::ReadOnlySharedMemoryRegion(), /*page_count=*/0));

   base::MappedReadOnlyRegion memory =
       base::ReadOnlySharedMemoryRegion::Create(data->size());
   if (!memory.IsValid()) {
     RunCallback(base::ReadOnlySharedMemoryRegion(), /*page_count=*/0);
     return;
   }

   if (use_skia) {
     pdf_to_pwg_raster_converter_remote_->SetUseSkiaRendererPolicy(*use_skia);
   }

   // TODO(thestig): Write `data` into shared memory in the first place, to avoid
   // this copy.
   memory.mapping.GetMemoryAsSpan<uint8_t>().copy_prefix_from(*data);
   pdf_to_pwg_raster_converter_remote_->Convert(
       std::move(memory.region), settings_, bitmap_settings_,
       base::BindOnce(&PwgRasterConverterHelper::RunCallback, this));
 }

 void PwgRasterConverterHelper::RunCallback(
     base::ReadOnlySharedMemoryRegion region,
     uint32_t page_count) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (callback_) {
     if (region.IsValid() && page_count > 0) {
       size_t average_page_size_in_kb = region.GetSize() / 1024;
       average_page_size_in_kb /= page_count;
       UMA_HISTOGRAM_MEMORY_KB("Printing.ConversionSize.Pwg",
                               average_page_size_in_kb);
       std::move(callback_).Run(std::move(region));
     } else {
       // TODO(thestig): Consider adding UMA to track failure rates.
       std::move(callback_).Run(base::ReadOnlySharedMemoryRegion());
     }
   }
   pdf_to_pwg_raster_converter_remote_.reset();
 }

 class PwgRasterConverterImpl : public PwgRasterConverter {
  public:
   PwgRasterConverterImpl();

   PwgRasterConverterImpl(const PwgRasterConverterImpl&) = delete;
   PwgRasterConverterImpl& operator=(const PwgRasterConverterImpl&) = delete;

   ~PwgRasterConverterImpl() override;

   void Start(const std::optional<bool>& use_skia,
              const base::RefCountedMemory* data,
              const PdfRenderSettings& conversion_settings,
              const PwgRasterSettings& bitmap_settings,
              ResultCallback callback) override;

  private:
   scoped_refptr<PwgRasterConverterHelper> utility_client_;

   // Cancelable version of PwgRasterConverter::ResultCallback.
   base::CancelableOnceCallback<void(base::ReadOnlySharedMemoryRegion)>
       cancelable_callback_;
 };

 PwgRasterConverterImpl::PwgRasterConverterImpl() = default;

 PwgRasterConverterImpl::~PwgRasterConverterImpl() = default;

 void PwgRasterConverterImpl::Start(const std::optional<bool>& use_skia,
                                    const base::RefCountedMemory* data,
                                    const PdfRenderSettings& conversion_settings,
                                    const PwgRasterSettings& bitmap_settings,
                                    ResultCallback callback) {
   cancelable_callback_.Reset(std::move(callback));
   utility_client_ = base::MakeRefCounted<PwgRasterConverterHelper>(
       conversion_settings, bitmap_settings);
   utility_client_->Convert(use_skia, data, cancelable_callback_.callback());
 }

 }  // namespace

 // static
 std::unique_ptr<PwgRasterConverter> PwgRasterConverter::CreateDefault() {
   return std::make_unique<PwgRasterConverterImpl>();
 }

 // static
 PdfRenderSettings PwgRasterConverter::GetConversionSettings(
     const cloud_devices::CloudDeviceDescription& printer_capabilities,
     const gfx::Size& page_size,
     bool use_color) {
   gfx::Size dpi = gfx::Size(kDefaultPdfDpi, kDefaultPdfDpi);
   cloud_devices::printer::DpiCapability dpis;
   if (dpis.LoadFrom(printer_capabilities))
     dpi = gfx::Size(dpis.GetDefault().horizontal, dpis.GetDefault().vertical);

   bool page_is_landscape =
       static_cast<double>(page_size.width()) / dpi.width() >
       static_cast<double>(page_size.height()) / dpi.height();

   // Pdfium assumes that page width is given in dpi.width(), and height in
   // dpi.height(). If we rotate the page, we need to also swap the DPIs.
   gfx::Size final_page_size = page_size;
   if (page_is_landscape) {
     final_page_size = gfx::Size(page_size.height(), page_size.width());
     dpi = gfx::Size(dpi.height(), dpi.width());
   }
   double scale_x = static_cast<double>(dpi.width()) / kPointsPerInch;
   double scale_y = static_cast<double>(dpi.height()) / kPointsPerInch;

   // Make vertical rectangle to optimize streaming to printer. Fix orientation
   // by autorotate.
   gfx::Rect area(final_page_size.width() * scale_x,
                  final_page_size.height() * scale_y);
   return PdfRenderSettings(area, gfx::Point(0, 0), dpi,
                            /*autorotate=*/true, use_color,
                            PdfRenderSettings::Mode::NORMAL);
 }

 // static
 PwgRasterSettings PwgRasterConverter::GetBitmapSettings(
     const cloud_devices::CloudDeviceDescription& printer_capabilities,
     const cloud_devices::CloudDeviceDescription& ticket) {
   cloud_devices::printer::DuplexTicketItem duplex_item;
   cloud_devices::printer::DuplexType duplex_value =
       cloud_devices::printer::DuplexType::NO_DUPLEX;
   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::ColorType::STANDARD_MONOCHROME:
     case cloud_devices::printer::ColorType::CUSTOM_MONOCHROME:
       use_color = false;
       break;

     case cloud_devices::printer::ColorType::STANDARD_COLOR:
     case cloud_devices::printer::ColorType::CUSTOM_COLOR:
     case cloud_devices::printer::ColorType::AUTO_COLOR:
       use_color = true;
       break;

     default:
       NOTREACHED();
   }

   cloud_devices::printer::PwgRasterConfigCapability raster_capability;
   // If the raster capability fails to load, `raster_capability` will contain
   // the default value.
   raster_capability.LoadFrom(printer_capabilities);
   cloud_devices::printer::DocumentSheetBack document_sheet_back =
       raster_capability.value().document_sheet_back;

   PwgRasterSettings result;
   switch (duplex_value) {
     case cloud_devices::printer::DuplexType::NO_DUPLEX:
       result.duplex_mode = mojom::DuplexMode::kSimplex;
       result.odd_page_transform = TRANSFORM_NORMAL;
       break;
     case cloud_devices::printer::DuplexType::LONG_EDGE:
       result.duplex_mode = mojom::DuplexMode::kLongEdge;
       if (document_sheet_back ==
           cloud_devices::printer::DocumentSheetBack::ROTATED) {
         result.odd_page_transform = TRANSFORM_ROTATE_180;
       } else if (document_sheet_back ==
                  cloud_devices::printer::DocumentSheetBack::FLIPPED) {
         result.odd_page_transform = TRANSFORM_FLIP_VERTICAL;
       } else {
         result.odd_page_transform = TRANSFORM_NORMAL;
       }
       break;
     case cloud_devices::printer::DuplexType::SHORT_EDGE:
       result.duplex_mode = mojom::DuplexMode::kShortEdge;
       if (document_sheet_back ==
           cloud_devices::printer::DocumentSheetBack::MANUAL_TUMBLE) {
         result.odd_page_transform = TRANSFORM_ROTATE_180;
       } else if (document_sheet_back ==
                  cloud_devices::printer::DocumentSheetBack::FLIPPED) {
         result.odd_page_transform = TRANSFORM_FLIP_HORIZONTAL;
       } else {
         result.odd_page_transform = TRANSFORM_NORMAL;
       }
       break;
   }

   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::Contains(
           types, cloud_devices::printer::PwgDocumentTypeSupported::SGRAY_8);

   return result;
 }

 }  // namespace printing
	// Copyright 2013 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "chrome/browser/printing/pwg_raster_converter.h"

	#include <algorithm>
	#include <memory>
	#include <optional>
	#include <utility>

	#include "base/cancelable_callback.h"
	#include "base/check_op.h"
	#include "base/containers/contains.h"
	#include "base/functional/bind.h"
	#include "base/functional/callback_helpers.h"
	#include "base/metrics/histogram_macros.h"
	#include "base/notreached.h"
	#include "chrome/browser/printing/printing_service.h"
	#include "chrome/services/printing/public/mojom/pdf_to_pwg_raster_converter.mojom.h"
	#include "chrome/services/printing/public/mojom/printing_service.mojom.h"
	#include "components/cloud_devices/common/cloud_device_description.h"
	#include "components/cloud_devices/common/printer_description.h"
	#include "content/public/browser/browser_thread.h"
	#include "content/public/browser/child_process_data.h"
	#include "mojo/public/cpp/bindings/remote.h"
	#include "mojo/public/cpp/system/platform_handle.h"
	#include "printing/mojom/print.mojom.h"
	#include "printing/pdf_render_settings.h"
	#include "printing/pwg_raster_settings.h"
	#include "printing/units.h"
	#include "ui/gfx/geometry/rect.h"
	#include "ui/gfx/geometry/size.h"

	namespace printing {

	namespace {

	using content::BrowserThread;

	// Converts PDF into PWG raster. Class lives on the UI thread.
	class PwgRasterConverterHelper
	: public base::RefCounted<PwgRasterConverterHelper> {
	public:
	PwgRasterConverterHelper(const PdfRenderSettings& settings,
	const PwgRasterSettings& bitmap_settings);

	PwgRasterConverterHelper(const PwgRasterConverterHelper&) = delete;
	PwgRasterConverterHelper& operator=(const PwgRasterConverterHelper&) = delete;

	void Convert(const std::optional<bool>& use_skia,
	const base::RefCountedMemory* data,
	PwgRasterConverter::ResultCallback callback);

	private:
	friend class base::RefCounted<PwgRasterConverterHelper>;

	~PwgRasterConverterHelper();

	void RunCallback(base::ReadOnlySharedMemoryRegion region,
	uint32_t page_count);

	PdfRenderSettings settings_;
	PwgRasterSettings bitmap_settings_;
	mojo::Remote<printing::mojom::PdfToPwgRasterConverter>
	pdf_to_pwg_raster_converter_remote_;
	PwgRasterConverter::ResultCallback callback_;
	};

	PwgRasterConverterHelper::PwgRasterConverterHelper(
	const PdfRenderSettings& settings,
	const PwgRasterSettings& bitmap_settings)
	: settings_(settings), bitmap_settings_(bitmap_settings) {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);
	}

	PwgRasterConverterHelper::~PwgRasterConverterHelper() {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);
	}

	void PwgRasterConverterHelper::Convert(
	const std::optional<bool>& use_skia,
	const base::RefCountedMemory* data,
	PwgRasterConverter::ResultCallback callback) {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);

	callback_ = std::move(callback);

	GetPrintingService()->BindPdfToPwgRasterConverter(
	pdf_to_pwg_raster_converter_remote_.BindNewPipeAndPassReceiver());
	pdf_to_pwg_raster_converter_remote_.set_disconnect_handler(
	base::BindOnce(&PwgRasterConverterHelper::RunCallback, this,
	base::ReadOnlySharedMemoryRegion(), /page_count=/0));

	base::MappedReadOnlyRegion memory =
	base::ReadOnlySharedMemoryRegion::Create(data->size());
	if (!memory.IsValid()) {
	RunCallback(base::ReadOnlySharedMemoryRegion(), /page_count=/0);
	return;
	}

	if (use_skia) {
	pdf_to_pwg_raster_converter_remote_->SetUseSkiaRendererPolicy(*use_skia);
	}

	// TODO(thestig): Write `data` into shared memory in the first place, to avoid
	// this copy.
	memory.mapping.GetMemoryAsSpan<uint8_t>().copy_prefix_from(*data);
	pdf_to_pwg_raster_converter_remote_->Convert(
	std::move(memory.region), settings_, bitmap_settings_,
	base::BindOnce(&PwgRasterConverterHelper::RunCallback, this));
	}

	void PwgRasterConverterHelper::RunCallback(
	base::ReadOnlySharedMemoryRegion region,
	uint32_t page_count) {
	DCHECK_CURRENTLY_ON(BrowserThread::UI);
	if (callback_) {
	if (region.IsValid() && page_count > 0) {
	size_t average_page_size_in_kb = region.GetSize() / 1024;
	average_page_size_in_kb /= page_count;
	UMA_HISTOGRAM_MEMORY_KB("Printing.ConversionSize.Pwg",
	average_page_size_in_kb);
	std::move(callback_).Run(std::move(region));
	} else {
	// TODO(thestig): Consider adding UMA to track failure rates.
	std::move(callback_).Run(base::ReadOnlySharedMemoryRegion());
	}
	}
	pdf_to_pwg_raster_converter_remote_.reset();
	}

	class PwgRasterConverterImpl : public PwgRasterConverter {
	public:
	PwgRasterConverterImpl();

	PwgRasterConverterImpl(const PwgRasterConverterImpl&) = delete;
	PwgRasterConverterImpl& operator=(const PwgRasterConverterImpl&) = delete;

	~PwgRasterConverterImpl() override;

	void Start(const std::optional<bool>& use_skia,
	const base::RefCountedMemory* data,
	const PdfRenderSettings& conversion_settings,
	const PwgRasterSettings& bitmap_settings,
	ResultCallback callback) override;

	private:
	scoped_refptr<PwgRasterConverterHelper> utility_client_;

	// Cancelable version of PwgRasterConverter::ResultCallback.
	base::CancelableOnceCallback<void(base::ReadOnlySharedMemoryRegion)>
	cancelable_callback_;
	};

	PwgRasterConverterImpl::PwgRasterConverterImpl() = default;

	PwgRasterConverterImpl::~PwgRasterConverterImpl() = default;

	void PwgRasterConverterImpl::Start(const std::optional<bool>& use_skia,
	const base::RefCountedMemory* data,
	const PdfRenderSettings& conversion_settings,
	const PwgRasterSettings& bitmap_settings,
	ResultCallback callback) {
	cancelable_callback_.Reset(std::move(callback));
	utility_client_ = base::MakeRefCounted<PwgRasterConverterHelper>(
	conversion_settings, bitmap_settings);
	utility_client_->Convert(use_skia, data, cancelable_callback_.callback());
	}

	} // namespace

	// static
	std::unique_ptr<PwgRasterConverter> PwgRasterConverter::CreateDefault() {
	return std::make_unique<PwgRasterConverterImpl>();
	}

	// static
	PdfRenderSettings PwgRasterConverter::GetConversionSettings(
	const cloud_devices::CloudDeviceDescription& printer_capabilities,
	const gfx::Size& page_size,
	bool use_color) {
	gfx::Size dpi = gfx::Size(kDefaultPdfDpi, kDefaultPdfDpi);
	cloud_devices::printer::DpiCapability dpis;
	if (dpis.LoadFrom(printer_capabilities))
	dpi = gfx::Size(dpis.GetDefault().horizontal, dpis.GetDefault().vertical);

	bool page_is_landscape =
	static_cast<double>(page_size.width()) / dpi.width() >
	static_cast<double>(page_size.height()) / dpi.height();

	// Pdfium assumes that page width is given in dpi.width(), and height in
	// dpi.height(). If we rotate the page, we need to also swap the DPIs.
	gfx::Size final_page_size = page_size;
	if (page_is_landscape) {
	final_page_size = gfx::Size(page_size.height(), page_size.width());
	dpi = gfx::Size(dpi.height(), dpi.width());
	}
	double scale_x = static_cast<double>(dpi.width()) / kPointsPerInch;
	double scale_y = static_cast<double>(dpi.height()) / kPointsPerInch;

	// Make vertical rectangle to optimize streaming to printer. Fix orientation
	// by autorotate.
	gfx::Rect area(final_page_size.width() * scale_x,
	final_page_size.height() * scale_y);
	return PdfRenderSettings(area, gfx::Point(0, 0), dpi,
	/autorotate=/true, use_color,
	PdfRenderSettings::Mode::NORMAL);
	}

	// static
	PwgRasterSettings PwgRasterConverter::GetBitmapSettings(
	const cloud_devices::CloudDeviceDescription& printer_capabilities,
	const cloud_devices::CloudDeviceDescription& ticket) {
	cloud_devices::printer::DuplexTicketItem duplex_item;
	cloud_devices::printer::DuplexType duplex_value =
	cloud_devices::printer::DuplexType::NO_DUPLEX;
	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::ColorType::STANDARD_MONOCHROME:
	case cloud_devices::printer::ColorType::CUSTOM_MONOCHROME:
	use_color = false;
	break;

	case cloud_devices::printer::ColorType::STANDARD_COLOR:
	case cloud_devices::printer::ColorType::CUSTOM_COLOR:
	case cloud_devices::printer::ColorType::AUTO_COLOR:
	use_color = true;
	break;

	default:
	NOTREACHED();
	}

	cloud_devices::printer::PwgRasterConfigCapability raster_capability;
	// If the raster capability fails to load, `raster_capability` will contain
	// the default value.
	raster_capability.LoadFrom(printer_capabilities);
	cloud_devices::printer::DocumentSheetBack document_sheet_back =
	raster_capability.value().document_sheet_back;

	PwgRasterSettings result;
	switch (duplex_value) {
	case cloud_devices::printer::DuplexType::NO_DUPLEX:
	result.duplex_mode = mojom::DuplexMode::kSimplex;
	result.odd_page_transform = TRANSFORM_NORMAL;
	break;
	case cloud_devices::printer::DuplexType::LONG_EDGE:
	result.duplex_mode = mojom::DuplexMode::kLongEdge;
	if (document_sheet_back ==
	cloud_devices::printer::DocumentSheetBack::ROTATED) {
	result.odd_page_transform = TRANSFORM_ROTATE_180;
	} else if (document_sheet_back ==
	cloud_devices::printer::DocumentSheetBack::FLIPPED) {
	result.odd_page_transform = TRANSFORM_FLIP_VERTICAL;
	} else {
	result.odd_page_transform = TRANSFORM_NORMAL;
	}
	break;
	case cloud_devices::printer::DuplexType::SHORT_EDGE:
	result.duplex_mode = mojom::DuplexMode::kShortEdge;
	if (document_sheet_back ==
	cloud_devices::printer::DocumentSheetBack::MANUAL_TUMBLE) {
	result.odd_page_transform = TRANSFORM_ROTATE_180;
	} else if (document_sheet_back ==
	cloud_devices::printer::DocumentSheetBack::FLIPPED) {
	result.odd_page_transform = TRANSFORM_FLIP_HORIZONTAL;
	} else {
	result.odd_page_transform = TRANSFORM_NORMAL;
	}
	break;
	}

	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::Contains(
	types, cloud_devices::printer::PwgDocumentTypeSupported::SGRAY_8);

	return result;
	}

	} // namespace printing