pdf/pdfium/pdfium_api_wrappers.cc - chromium/src - Git at Google

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

 #include "pdf/pdfium/pdfium_api_wrappers.h"

 #include <stddef.h>
 #include <stdint.h>

 #include <algorithm>
 #include <optional>
 #include <string>
 #include <utility>

 #include "base/check_op.h"
 #include "base/compiler_specific.h"
 #include "base/containers/span.h"
 #include "base/numerics/checked_math.h"
 #include "base/numerics/safe_conversions.h"
 #include "pdf/pdf_rect.h"
 #include "pdf/pdfium/pdfium_api_string_buffer_adapter.h"
 #include "printing/units.h"
 #include "third_party/pdfium/public/cpp/fpdf_scopers.h"
 #include "third_party/pdfium/public/fpdf_edit.h"
 #include "third_party/pdfium/public/fpdfview.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"

 #if BUILDFLAG(IS_WIN)
 #include <string.h>  // for memset()
 #endif

 using printing::ConvertUnitFloat;
 using printing::kPointsPerInch;

 namespace chrome_pdf {

 namespace {

 // Check that PdfRect and FS_RECTF have the same size and member variables have
 // the same offsets, to allow for safe casting between them.
 static_assert(sizeof(PdfRect) == sizeof(FS_RECTF));
 static_assert(PdfRect::offsetof_left() == offsetof(FS_RECTF, left));
 static_assert(PdfRect::offsetof_bottom() == offsetof(FS_RECTF, bottom));
 static_assert(PdfRect::offsetof_right() == offsetof(FS_RECTF, right));
 static_assert(PdfRect::offsetof_top() == offsetof(FS_RECTF, top));

 int GetRenderFlagsFromSettings(
     const PDFiumEngineExports::RenderingSettings& settings) {
   int flags = FPDF_ANNOT;
   if (!settings.use_color) {
     flags |= FPDF_GRAYSCALE;
   }
   if (settings.render_for_printing) {
     flags |= FPDF_PRINTING;
   }
   return flags;
 }

 int CalculatePosition(FPDF_PAGE page,
                       const PDFiumEngineExports::RenderingSettings& settings,
                       gfx::Rect* dest) {
   // settings.bounds is in terms of the max DPI. Convert page sizes to match.
   const int dpi_x = settings.dpi.width();
   const int dpi_y = settings.dpi.height();
   const int dpi = std::max(dpi_x, dpi_y);
   int page_width = static_cast<int>(
       ConvertUnitFloat(FPDF_GetPageWidthF(page), kPointsPerInch, dpi));
   int page_height = static_cast<int>(
       ConvertUnitFloat(FPDF_GetPageHeightF(page), kPointsPerInch, dpi));

   // Start by assuming that we will draw exactly to the bounds rect
   // specified.
   *dest = settings.bounds;

   int rotate = 0;  // normal orientation.

   // Auto-rotate landscape pages to print correctly.
   if (settings.autorotate &&
       (dest->width() > dest->height()) != (page_width > page_height)) {
     rotate = 3;  // 90 degrees counter-clockwise.
     std::swap(page_width, page_height);
   }

   // See if we need to scale the output
   bool scale_to_bounds = false;
   if (settings.fit_to_bounds &&
       ((page_width > dest->width()) || (page_height > dest->height()))) {
     scale_to_bounds = true;
   } else if (settings.stretch_to_bounds &&
              ((page_width < dest->width()) || (page_height < dest->height()))) {
     scale_to_bounds = true;
   }

   if (scale_to_bounds) {
     // If we need to maintain aspect ratio, calculate the actual width and
     // height.
     if (settings.keep_aspect_ratio) {
       double scale_factor_x = page_width;
       scale_factor_x /= dest->width();
       double scale_factor_y = page_height;
       scale_factor_y /= dest->height();
       if (scale_factor_x > scale_factor_y) {
         dest->set_height(page_height / scale_factor_x);
       } else {
         dest->set_width(page_width / scale_factor_y);
       }
     }
   } else {
     // We are not scaling to bounds. Draw in the actual page size. If the
     // actual page size is larger than the bounds, the output will be
     // clipped.
     dest->set_width(page_width);
     dest->set_height(page_height);
   }

   // Scale the bounds to device units if DPI is rectangular.
   if (dpi_x != dpi_y) {
     dest->set_width(dest->width() * dpi_x / dpi);
     dest->set_height(dest->height() * dpi_y / dpi);
   }

   if (settings.center_in_bounds) {
     gfx::Vector2d offset(
         (settings.bounds.width() * dpi_x / dpi - dest->width()) / 2,
         (settings.bounds.height() * dpi_y / dpi - dest->height()) / 2);
     dest->Offset(offset);
   }
   return rotate;
 }

 }  // namespace

 const FS_RECTF& FsRectFFromPdfRect(const PdfRect& rect) {
   return reinterpret_cast<const FS_RECTF&>(rect);
 }

 FS_RECTF& FsRectFFromPdfRect(PdfRect& rect) {
   return reinterpret_cast<FS_RECTF&>(rect);
 }

 ScopedFPDFDocument LoadPdfData(base::span<const uint8_t> pdf_data) {
   return LoadPdfDataWithPassword(pdf_data, std::string());
 }

 ScopedFPDFDocument LoadPdfDataWithPassword(base::span<const uint8_t> pdf_data,
                                            const std::string& password) {
   return ScopedFPDFDocument(FPDF_LoadMemDocument64(
       pdf_data.data(), pdf_data.size(), password.c_str()));
 }

 std::optional<PdfRect> GetAnnotRect(FPDF_ANNOTATION annot) {
   PdfRect rect;
   if (!FPDFAnnot_GetRect(annot, &FsRectFFromPdfRect(rect))) {
     return std::nullopt;
   }
   return rect;
 }

 std::optional<PdfRect> GetPageBoundingBox(FPDF_PAGE page) {
   PdfRect rect;
   if (!FPDF_GetPageBoundingBox(page, &FsRectFFromPdfRect(rect))) {
     return std::nullopt;
   }
   return rect;
 }

 std::optional<PdfRect> GetPageObjectBounds(FPDF_PAGEOBJECT page_object) {
   PdfRect rect;
   if (!FPDFPageObj_GetBounds(page_object, rect.writable_left(),
                              rect.writable_bottom(), rect.writable_right(),
                              rect.writable_top())) {
     return std::nullopt;
   }
   return rect;
 }

 std::u16string GetPageObjectMarkName(FPDF_PAGEOBJECTMARK mark) {
   // FPDFPageObjMark_GetName() naturally handles null `mark` inputs, so no
   // explicit check.

   std::u16string name;
   // NOLINT used below because this is required by the PDFium API interaction.
   unsigned long buflen_bytes = 0;  // NOLINT(runtime/int)
   if (!FPDFPageObjMark_GetName(mark, nullptr, 0, &buflen_bytes)) {
     return name;
   }

   // PDFium should never return an odd number of bytes for 16-bit chars.
   static_assert(sizeof(FPDF_WCHAR) == sizeof(char16_t));
   CHECK_EQ(buflen_bytes % 2, 0u);

   // Number of characters, including the NUL.
   const size_t expected_size = base::checked_cast<size_t>(buflen_bytes / 2);
   PDFiumAPIStringBufferAdapter adapter(&name, expected_size,
                                        /*check_expected_size=*/true);
   unsigned long actual_buflen_bytes = 0;  // NOLINT(runtime/int)
   bool result =
       FPDFPageObjMark_GetName(mark, static_cast<FPDF_WCHAR*>(adapter.GetData()),
                               buflen_bytes, &actual_buflen_bytes);
   CHECK(result);

   // Reuse `expected_size`, as `actual_buflen_bytes` divided by 2 is equal.
   CHECK_EQ(actual_buflen_bytes, buflen_bytes);
   adapter.Close(expected_size);
   return name;
 }

 std::optional<PdfRect> GetTextCharBox(FPDF_TEXTPAGE text_page, int index) {
   double left;
   double right;
   double bottom;
   double top;
   if (!FPDFText_GetCharBox(text_page, index, &left, &right, &bottom, &top)) {
     return std::nullopt;
   }
   return PdfRect(/*left=*/left,
                  /*bottom=*/bottom,
                  /*right=*/right,
                  /*top=*/top);
 }

 bool RenderPageToBitmap(FPDF_PAGE page,
                         const PDFiumEngineExports::RenderingSettings& settings,
                         void* bitmap_buffer) {
   if (!page || !bitmap_buffer) {
     return false;
   }

   constexpr int kBgraImageColorChannels = 4;
   base::CheckedNumeric<int> stride = kBgraImageColorChannels;
   stride *= settings.bounds.width();
   if (!stride.IsValid()) {
     return false;
   }

   gfx::Rect dest;
   int rotate = CalculatePosition(page, settings, &dest);

   ScopedFPDFBitmap bitmap(
       FPDFBitmap_CreateEx(settings.bounds.width(), settings.bounds.height(),
                           FPDFBitmap_BGRA, bitmap_buffer, stride.ValueOrDie()));
   // Clear the bitmap
   FPDFBitmap_FillRect(bitmap.get(), 0, 0, settings.bounds.width(),
                       settings.bounds.height(), 0xFFFFFFFF);
   // Shift top-left corner of bounds to (0, 0) if it's not there.
   dest.set_origin(dest.origin() - settings.bounds.OffsetFromOrigin());

   FPDF_RenderPageBitmap(bitmap.get(), page, dest.x(), dest.y(), dest.width(),
                         dest.height(), rotate,
                         GetRenderFlagsFromSettings(settings));
   return true;
 }

 #if BUILDFLAG(IS_WIN)
 bool RenderPageToDC(FPDF_PAGE page,
                     const PDFiumEngineExports::RenderingSettings& settings,
                     HDC dc) {
   if (!page || !dc) {
     return false;
   }

   PDFiumEngineExports::RenderingSettings new_settings = settings;
   // calculate the page size
   if (new_settings.dpi.width() == -1) {
     new_settings.dpi.set_width(GetDeviceCaps(dc, LOGPIXELSX));
   }
   if (new_settings.dpi.height() == -1) {
     new_settings.dpi.set_height(GetDeviceCaps(dc, LOGPIXELSY));
   }

   gfx::Rect dest;
   int rotate = CalculatePosition(page, new_settings, &dest);

   int save_state = SaveDC(dc);
   // The caller wanted all drawing to happen within the bounds specified.
   // Based on scale calculations, our destination rect might be larger
   // than the bounds. Set the clip rect to the bounds.
   IntersectClipRect(dc, settings.bounds.x(), settings.bounds.y(),
                     settings.bounds.x() + settings.bounds.width(),
                     settings.bounds.y() + settings.bounds.height());

   int flags = GetRenderFlagsFromSettings(settings);

   // A "temporary" hack. Some PDFs seems to render very slowly if
   // FPDF_RenderPage() is directly used on a printer DC. I suspect it is
   // because of the code to talk Postscript directly to the printer if
   // the printer supports this. Need to discuss this with PDFium. For now,
   // render to a bitmap and then blit the bitmap to the DC if we have been
   // supplied a printer DC.
   int device_type = GetDeviceCaps(dc, TECHNOLOGY);
   if (device_type == DT_RASPRINTER || device_type == DT_PLOTTER) {
     ScopedFPDFBitmap bitmap(
         FPDFBitmap_Create(dest.width(), dest.height(), FPDFBitmap_BGRx));
     // Clear the bitmap
     FPDFBitmap_FillRect(bitmap.get(), 0, 0, dest.width(), dest.height(),
                         0xFFFFFFFF);
     FPDF_RenderPageBitmap(bitmap.get(), page, 0, 0, dest.width(), dest.height(),
                           rotate, flags);
     int stride = FPDFBitmap_GetStride(bitmap.get());
     BITMAPINFO bmi;
     UNSAFE_TODO(memset(&bmi, 0, sizeof(bmi)));
     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
     bmi.bmiHeader.biWidth = dest.width();
     bmi.bmiHeader.biHeight = -dest.height();  // top-down image
     bmi.bmiHeader.biPlanes = 1;
     bmi.bmiHeader.biBitCount = 32;
     bmi.bmiHeader.biCompression = BI_RGB;
     bmi.bmiHeader.biSizeImage = stride * dest.height();
     StretchDIBits(dc, dest.x(), dest.y(), dest.width(), dest.height(), 0, 0,
                   dest.width(), dest.height(),
                   FPDFBitmap_GetBuffer(bitmap.get()), &bmi, DIB_RGB_COLORS,
                   SRCCOPY);
   } else {
     FPDF_RenderPage(dc, page, dest.x(), dest.y(), dest.width(), dest.height(),
                     rotate, flags);
   }
   RestoreDC(dc, save_state);
   return true;
 }
 #endif  // BUILDFLAG(IS_WIN)

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

	#include "pdf/pdfium/pdfium_api_wrappers.h"

	#include <stddef.h>
	#include <stdint.h>

	#include <algorithm>
	#include <optional>
	#include <string>
	#include <utility>

	#include "base/check_op.h"
	#include "base/compiler_specific.h"
	#include "base/containers/span.h"
	#include "base/numerics/checked_math.h"
	#include "base/numerics/safe_conversions.h"
	#include "pdf/pdf_rect.h"
	#include "pdf/pdfium/pdfium_api_string_buffer_adapter.h"
	#include "printing/units.h"
	#include "third_party/pdfium/public/cpp/fpdf_scopers.h"
	#include "third_party/pdfium/public/fpdf_edit.h"
	#include "third_party/pdfium/public/fpdfview.h"
	#include "ui/gfx/geometry/rect.h"
	#include "ui/gfx/geometry/vector2d.h"

	#if BUILDFLAG(IS_WIN)
	#include <string.h> // for memset()
	#endif

	using printing::ConvertUnitFloat;
	using printing::kPointsPerInch;

	namespace chrome_pdf {

	namespace {

	// Check that PdfRect and FS_RECTF have the same size and member variables have
	// the same offsets, to allow for safe casting between them.
	static_assert(sizeof(PdfRect) == sizeof(FS_RECTF));
	static_assert(PdfRect::offsetof_left() == offsetof(FS_RECTF, left));
	static_assert(PdfRect::offsetof_bottom() == offsetof(FS_RECTF, bottom));
	static_assert(PdfRect::offsetof_right() == offsetof(FS_RECTF, right));
	static_assert(PdfRect::offsetof_top() == offsetof(FS_RECTF, top));

	int GetRenderFlagsFromSettings(
	const PDFiumEngineExports::RenderingSettings& settings) {
	int flags = FPDF_ANNOT;
	if (!settings.use_color) {
	flags \|= FPDF_GRAYSCALE;
	}
	if (settings.render_for_printing) {
	flags \|= FPDF_PRINTING;
	}
	return flags;
	}

	int CalculatePosition(FPDF_PAGE page,
	const PDFiumEngineExports::RenderingSettings& settings,
	gfx::Rect* dest) {
	// settings.bounds is in terms of the max DPI. Convert page sizes to match.
	const int dpi_x = settings.dpi.width();
	const int dpi_y = settings.dpi.height();
	const int dpi = std::max(dpi_x, dpi_y);
	int page_width = static_cast<int>(
	ConvertUnitFloat(FPDF_GetPageWidthF(page), kPointsPerInch, dpi));
	int page_height = static_cast<int>(
	ConvertUnitFloat(FPDF_GetPageHeightF(page), kPointsPerInch, dpi));

	// Start by assuming that we will draw exactly to the bounds rect
	// specified.
	*dest = settings.bounds;

	int rotate = 0; // normal orientation.

	// Auto-rotate landscape pages to print correctly.
	if (settings.autorotate &&
	(dest->width() > dest->height()) != (page_width > page_height)) {
	rotate = 3; // 90 degrees counter-clockwise.
	std::swap(page_width, page_height);
	}

	// See if we need to scale the output
	bool scale_to_bounds = false;
	if (settings.fit_to_bounds &&
	((page_width > dest->width()) \|\| (page_height > dest->height()))) {
	scale_to_bounds = true;
	} else if (settings.stretch_to_bounds &&
	((page_width < dest->width()) \|\| (page_height < dest->height()))) {
	scale_to_bounds = true;
	}

	if (scale_to_bounds) {
	// If we need to maintain aspect ratio, calculate the actual width and
	// height.
	if (settings.keep_aspect_ratio) {
	double scale_factor_x = page_width;
	scale_factor_x /= dest->width();
	double scale_factor_y = page_height;
	scale_factor_y /= dest->height();
	if (scale_factor_x > scale_factor_y) {
	dest->set_height(page_height / scale_factor_x);
	} else {
	dest->set_width(page_width / scale_factor_y);
	}
	}
	} else {
	// We are not scaling to bounds. Draw in the actual page size. If the
	// actual page size is larger than the bounds, the output will be
	// clipped.
	dest->set_width(page_width);
	dest->set_height(page_height);
	}

	// Scale the bounds to device units if DPI is rectangular.
	if (dpi_x != dpi_y) {
	dest->set_width(dest->width() * dpi_x / dpi);
	dest->set_height(dest->height() * dpi_y / dpi);
	}

	if (settings.center_in_bounds) {
	gfx::Vector2d offset(
	(settings.bounds.width() * dpi_x / dpi - dest->width()) / 2,
	(settings.bounds.height() * dpi_y / dpi - dest->height()) / 2);
	dest->Offset(offset);
	}
	return rotate;
	}

	} // namespace

	const FS_RECTF& FsRectFFromPdfRect(const PdfRect& rect) {
	return reinterpret_cast<const FS_RECTF&>(rect);
	}

	FS_RECTF& FsRectFFromPdfRect(PdfRect& rect) {
	return reinterpret_cast<FS_RECTF&>(rect);
	}

	ScopedFPDFDocument LoadPdfData(base::span<const uint8_t> pdf_data) {
	return LoadPdfDataWithPassword(pdf_data, std::string());
	}

	ScopedFPDFDocument LoadPdfDataWithPassword(base::span<const uint8_t> pdf_data,
	const std::string& password) {
	return ScopedFPDFDocument(FPDF_LoadMemDocument64(
	pdf_data.data(), pdf_data.size(), password.c_str()));
	}

	std::optional<PdfRect> GetAnnotRect(FPDF_ANNOTATION annot) {
	PdfRect rect;
	if (!FPDFAnnot_GetRect(annot, &FsRectFFromPdfRect(rect))) {
	return std::nullopt;
	}
	return rect;
	}

	std::optional<PdfRect> GetPageBoundingBox(FPDF_PAGE page) {
	PdfRect rect;
	if (!FPDF_GetPageBoundingBox(page, &FsRectFFromPdfRect(rect))) {
	return std::nullopt;
	}
	return rect;
	}

	std::optional<PdfRect> GetPageObjectBounds(FPDF_PAGEOBJECT page_object) {
	PdfRect rect;
	if (!FPDFPageObj_GetBounds(page_object, rect.writable_left(),
	rect.writable_bottom(), rect.writable_right(),
	rect.writable_top())) {
	return std::nullopt;
	}
	return rect;
	}

	std::u16string GetPageObjectMarkName(FPDF_PAGEOBJECTMARK mark) {
	// FPDFPageObjMark_GetName() naturally handles null `mark` inputs, so no
	// explicit check.

	std::u16string name;
	// NOLINT used below because this is required by the PDFium API interaction.
	unsigned long buflen_bytes = 0; // NOLINT(runtime/int)
	if (!FPDFPageObjMark_GetName(mark, nullptr, 0, &buflen_bytes)) {
	return name;
	}

	// PDFium should never return an odd number of bytes for 16-bit chars.
	static_assert(sizeof(FPDF_WCHAR) == sizeof(char16_t));
	CHECK_EQ(buflen_bytes % 2, 0u);

	// Number of characters, including the NUL.
	const size_t expected_size = base::checked_cast<size_t>(buflen_bytes / 2);
	PDFiumAPIStringBufferAdapter adapter(&name, expected_size,
	/check_expected_size=/true);
	unsigned long actual_buflen_bytes = 0; // NOLINT(runtime/int)
	bool result =
	FPDFPageObjMark_GetName(mark, static_cast<FPDF_WCHAR*>(adapter.GetData()),
	buflen_bytes, &actual_buflen_bytes);
	CHECK(result);

	// Reuse `expected_size`, as `actual_buflen_bytes` divided by 2 is equal.
	CHECK_EQ(actual_buflen_bytes, buflen_bytes);
	adapter.Close(expected_size);
	return name;
	}

	std::optional<PdfRect> GetTextCharBox(FPDF_TEXTPAGE text_page, int index) {
	double left;
	double right;
	double bottom;
	double top;
	if (!FPDFText_GetCharBox(text_page, index, &left, &right, &bottom, &top)) {
	return std::nullopt;
	}
	return PdfRect(/left=/left,
	/bottom=/bottom,
	/right=/right,
	/top=/top);
	}

	bool RenderPageToBitmap(FPDF_PAGE page,
	const PDFiumEngineExports::RenderingSettings& settings,
	void* bitmap_buffer) {
	if (!page \|\| !bitmap_buffer) {
	return false;
	}

	constexpr int kBgraImageColorChannels = 4;
	base::CheckedNumeric<int> stride = kBgraImageColorChannels;
	stride *= settings.bounds.width();
	if (!stride.IsValid()) {
	return false;
	}

	gfx::Rect dest;
	int rotate = CalculatePosition(page, settings, &dest);

	ScopedFPDFBitmap bitmap(
	FPDFBitmap_CreateEx(settings.bounds.width(), settings.bounds.height(),
	FPDFBitmap_BGRA, bitmap_buffer, stride.ValueOrDie()));
	// Clear the bitmap
	FPDFBitmap_FillRect(bitmap.get(), 0, 0, settings.bounds.width(),
	settings.bounds.height(), 0xFFFFFFFF);
	// Shift top-left corner of bounds to (0, 0) if it's not there.
	dest.set_origin(dest.origin() - settings.bounds.OffsetFromOrigin());

	FPDF_RenderPageBitmap(bitmap.get(), page, dest.x(), dest.y(), dest.width(),
	dest.height(), rotate,
	GetRenderFlagsFromSettings(settings));
	return true;
	}

	#if BUILDFLAG(IS_WIN)
	bool RenderPageToDC(FPDF_PAGE page,
	const PDFiumEngineExports::RenderingSettings& settings,
	HDC dc) {
	if (!page \|\| !dc) {
	return false;
	}

	PDFiumEngineExports::RenderingSettings new_settings = settings;
	// calculate the page size
	if (new_settings.dpi.width() == -1) {
	new_settings.dpi.set_width(GetDeviceCaps(dc, LOGPIXELSX));
	}
	if (new_settings.dpi.height() == -1) {
	new_settings.dpi.set_height(GetDeviceCaps(dc, LOGPIXELSY));
	}

	gfx::Rect dest;
	int rotate = CalculatePosition(page, new_settings, &dest);

	int save_state = SaveDC(dc);
	// The caller wanted all drawing to happen within the bounds specified.
	// Based on scale calculations, our destination rect might be larger
	// than the bounds. Set the clip rect to the bounds.
	IntersectClipRect(dc, settings.bounds.x(), settings.bounds.y(),
	settings.bounds.x() + settings.bounds.width(),
	settings.bounds.y() + settings.bounds.height());

	int flags = GetRenderFlagsFromSettings(settings);

	// A "temporary" hack. Some PDFs seems to render very slowly if
	// FPDF_RenderPage() is directly used on a printer DC. I suspect it is
	// because of the code to talk Postscript directly to the printer if
	// the printer supports this. Need to discuss this with PDFium. For now,
	// render to a bitmap and then blit the bitmap to the DC if we have been
	// supplied a printer DC.
	int device_type = GetDeviceCaps(dc, TECHNOLOGY);
	if (device_type == DT_RASPRINTER \|\| device_type == DT_PLOTTER) {
	ScopedFPDFBitmap bitmap(
	FPDFBitmap_Create(dest.width(), dest.height(), FPDFBitmap_BGRx));
	// Clear the bitmap
	FPDFBitmap_FillRect(bitmap.get(), 0, 0, dest.width(), dest.height(),
	0xFFFFFFFF);
	FPDF_RenderPageBitmap(bitmap.get(), page, 0, 0, dest.width(), dest.height(),
	rotate, flags);
	int stride = FPDFBitmap_GetStride(bitmap.get());
	BITMAPINFO bmi;
	UNSAFE_TODO(memset(&bmi, 0, sizeof(bmi)));
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = dest.width();
	bmi.bmiHeader.biHeight = -dest.height(); // top-down image
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 32;
	bmi.bmiHeader.biCompression = BI_RGB;
	bmi.bmiHeader.biSizeImage = stride * dest.height();
	StretchDIBits(dc, dest.x(), dest.y(), dest.width(), dest.height(), 0, 0,
	dest.width(), dest.height(),
	FPDFBitmap_GetBuffer(bitmap.get()), &bmi, DIB_RGB_COLORS,
	SRCCOPY);
	} else {
	FPDF_RenderPage(dc, page, dest.x(), dest.y(), dest.width(), dest.height(),
	rotate, flags);
	}
	RestoreDC(dc, save_state);
	return true;
	}
	#endif // BUILDFLAG(IS_WIN)

	} // namespace chrome_pdf