printing/pdf_metafile_cg_mac_unittest.cc - chromium/src - Git at Google

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

 #include "printing/pdf_metafile_cg_mac.h"

 #include <CoreGraphics/CoreGraphics.h>
 #include <stdint.h>

 #include <memory>
 #include <string>
 #include <vector>

 #include "base/files/file_util.h"
 #include "base/hash/sha1.h"
 #include "base/path_service.h"
 #include "printing/mojom/print.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/rect.h"

 namespace printing {

 namespace {

 base::FilePath GetPdfTestData(const base::FilePath::StringType& filename) {
   base::FilePath root_path;
   if (!base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &root_path)) {
     return base::FilePath();
   }
   return root_path.Append("pdf").Append("test").Append("data").Append(filename);
 }

 base::FilePath GetPrintingTestData(const base::FilePath::StringType& filename) {
   base::FilePath root_path;
   if (!base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &root_path)) {
     return base::FilePath();
   }
   return root_path.Append("printing")
       .Append("test")
       .Append("data")
       .Append("pdf_cg")
       .Append(filename);
 }

 std::unique_ptr<PdfMetafileCg> GetPdfMetafile(
     const base::FilePath::StringType& pdf_filename) {
   // Get test data.
   base::FilePath pdf_file = GetPdfTestData(pdf_filename);
   if (pdf_file.empty())
     return nullptr;

   std::string pdf_data;
   if (!base::ReadFileToString(pdf_file, &pdf_data))
     return nullptr;

   // Initialize and check metafile.
   auto pdf_cg = std::make_unique<PdfMetafileCg>();
   if (!pdf_cg->InitFromData(base::as_bytes(base::make_span(pdf_data))))
     return nullptr;
   return pdf_cg;
 }

 void RenderedPdfSha1(const base::FilePath::StringType& pdf_filename,
                      size_t page_number,
                      const gfx::Rect& expected_page_bounds,
                      const gfx::Size& dest_size,
                      bool autorotate,
                      bool fit_to_page,
                      base::SHA1Digest* rendered_hash) {
   // Initialize and verify the metafile.
   std::unique_ptr<PdfMetafileCg> pdf_cg = GetPdfMetafile(pdf_filename);
   ASSERT_TRUE(pdf_cg);
   ASSERT_LE(page_number, pdf_cg->GetPageCount());
   const gfx::Rect bounds = pdf_cg->GetPageBounds(page_number);
   ASSERT_EQ(expected_page_bounds, bounds);

   // Set up rendering context.
   constexpr size_t kBitsPerComponent = 8;
   constexpr size_t kBytesPerPixel = 4;
   const size_t kStride = dest_size.width() * kBytesPerPixel;
   std::vector<uint8_t> rendered_bitmap(dest_size.height() * kStride);
   base::apple::ScopedCFTypeRef<CGColorSpaceRef> color_space(
       CGColorSpaceCreateDeviceRGB());
   base::apple::ScopedCFTypeRef<CGContextRef> context(CGBitmapContextCreate(
       rendered_bitmap.data(), dest_size.width(), dest_size.height(),
       kBitsPerComponent, kStride, color_space.get(),
       uint32_t{kCGImageAlphaPremultipliedFirst} | kCGBitmapByteOrder32Little));

   // Render using metafile and calculate the output hash.
   ASSERT_TRUE(pdf_cg->RenderPage(page_number, context.get(),
                                  gfx::Rect(dest_size).ToCGRect(), autorotate,
                                  fit_to_page));
   *rendered_hash = base::SHA1HashSpan(rendered_bitmap);
 }

 void ExpectedPngSha1(const base::FilePath::StringType& expected_png_filename,
                      const gfx::Size& expected_png_size,
                      base::SHA1Digest* expected_hash) {
   base::FilePath expected_png_file = GetPrintingTestData(expected_png_filename);
   ASSERT_FALSE(expected_png_file.empty());
   std::string expected_png_data;
   ASSERT_TRUE(base::ReadFileToString(expected_png_file, &expected_png_data));

   // Decode expected PNG and calculate the output hash.
   std::vector<uint8_t> expected_png_bitmap;
   int png_width;
   int png_height;
   ASSERT_TRUE(gfx::PNGCodec::Decode(
       reinterpret_cast<const uint8_t*>(expected_png_data.data()),
       expected_png_data.size(), gfx::PNGCodec::FORMAT_BGRA,
       &expected_png_bitmap, &png_width, &png_height));
   ASSERT_EQ(expected_png_size.width(), png_width);
   ASSERT_EQ(expected_png_size.height(), png_height);
   *expected_hash = base::SHA1HashSpan(expected_png_bitmap);
 }

 void TestRenderPageWithTransformParams(
     const base::FilePath::StringType& pdf_filename,
     size_t page_number,
     const gfx::Rect& expected_page_bounds,
     const base::FilePath::StringType& expected_png_filename,
     const gfx::Size& dest_size,
     bool autorotate,
     bool fit_to_page) {
   base::SHA1Digest rendered_hash;
   RenderedPdfSha1(pdf_filename, page_number, expected_page_bounds, dest_size,
                   autorotate, fit_to_page, &rendered_hash);
   base::SHA1Digest expected_hash;
   ExpectedPngSha1(expected_png_filename, dest_size, &expected_hash);

   // Make sure the hashes match.
   EXPECT_EQ(expected_hash, rendered_hash);
 }

 void TestRenderPage(const base::FilePath::StringType& pdf_filename,
                     size_t page_number,
                     const gfx::Rect& expected_page_bounds,
                     const base::FilePath::StringType& expected_png_filename,
                     const gfx::Size& dest_size) {
   TestRenderPageWithTransformParams(
       pdf_filename, page_number, expected_page_bounds, expected_png_filename,
       dest_size, /*autorotate=*/true, /*fit_to_page=*/false);
 }

 }  // namespace

 TEST(PdfMetafileCgTest, Pdf) {
   // Test in-renderer constructor.
   PdfMetafileCg pdf;
   EXPECT_TRUE(pdf.Init());
   EXPECT_TRUE(pdf.context());

   // Render page 1.
   constexpr gfx::Rect kRect1(10, 10, 520, 700);
   constexpr gfx::Size kSize1(540, 720);
   pdf.StartPage(kSize1, kRect1, 1.25, mojom::PageOrientation::kUpright);
   pdf.FinishPage();

   // Render page 2.
   constexpr gfx::Rect kRect2(10, 10, 520, 700);
   constexpr gfx::Size kSize2(720, 540);
   pdf.StartPage(kSize2, kRect2, 2.0, mojom::PageOrientation::kUpright);
   pdf.FinishPage();

   pdf.FinishDocument();

   // Check data size.
   const uint32_t size = pdf.GetDataSize();
   EXPECT_GT(size, 0U);

   // Get resulting data.
   std::vector<char> buffer(size, 0);
   pdf.GetData(&buffer.front(), size);

   // Test browser-side constructor.
   PdfMetafileCg pdf2;
   // TODO(thestig): Make `buffer` uint8_t and avoid the base::as_bytes() call.
   EXPECT_TRUE(pdf2.InitFromData(base::as_bytes(base::make_span(buffer))));

   // Get the first 4 characters from pdf2.
   std::vector<char> buffer2(4, 0);
   pdf2.GetData(&buffer2.front(), 4);

   // Test that the header begins with "%PDF".
   std::string header(&buffer2.front(), 4);
   EXPECT_EQ(0U, header.find("%PDF", 0));

   // Test that the PDF is correctly reconstructed.
   EXPECT_EQ(2U, pdf2.GetPageCount());
   gfx::Size page_size = pdf2.GetPageBounds(1).size();
   EXPECT_EQ(540, page_size.width());
   EXPECT_EQ(720, page_size.height());
   page_size = pdf2.GetPageBounds(2).size();
   EXPECT_EQ(720, page_size.width());
   EXPECT_EQ(540, page_size.height());
 }

 TEST(PdfMetafileCgTest, GetPageBounds) {
   // Get test data.
   base::FilePath pdf_file = GetPdfTestData("rectangles_multi_pages.pdf");
   ASSERT_FALSE(pdf_file.empty());
   std::string pdf_data;
   ASSERT_TRUE(base::ReadFileToString(pdf_file, &pdf_data));

   // Initialize and check metafile.
   PdfMetafileCg pdf_cg;
   ASSERT_TRUE(pdf_cg.InitFromData(base::as_bytes(base::make_span(pdf_data))));
   ASSERT_EQ(5u, pdf_cg.GetPageCount());

   // Since the input into GetPageBounds() is a 1-indexed page number, 0 and 6
   // are out of bounds.
   gfx::Rect bounds;
   for (size_t i : {0, 6}) {
     bounds = pdf_cg.GetPageBounds(i);
     EXPECT_EQ(0, bounds.x());
     EXPECT_EQ(0, bounds.y());
     EXPECT_EQ(0, bounds.width());
     EXPECT_EQ(0, bounds.height());
   }

   // Whereas 1-5 are in bounds.
   for (size_t i = 1; i < 6; ++i) {
     bounds = pdf_cg.GetPageBounds(i);
     EXPECT_EQ(0, bounds.x());
     EXPECT_EQ(0, bounds.y());
     EXPECT_EQ(200, bounds.width());
     EXPECT_EQ(250, bounds.height());
   }
 }

 TEST(PdfMetafileCgTest, RenderPortraitRectangles) {
   constexpr gfx::Rect kPageBounds(200, 300);
   constexpr gfx::Size kDestinationSize(200, 300);
   TestRenderPage("rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_portrait_rectangles_expected.0.png", kDestinationSize);
 }

 TEST(PdfMetafileCgTest, RenderAutorotatedPortraitRectangles) {
   constexpr gfx::Rect kPageBounds(200, 300);
   constexpr gfx::Size kDestinationSize(300, 200);
   TestRenderPage("rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_autorotated_portrait_rectangles_expected.0.png",
                  kDestinationSize);
 }

 TEST(PdfMetafileCgTest, RenderLargePortraitRectangles) {
   constexpr gfx::Rect kPageBounds(200, 300);
   constexpr gfx::Size kDestinationSize(100, 120);
   TestRenderPage("rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_large_portrait_rectangles_expected.0.png",
                  kDestinationSize);
 }

 TEST(PdfMetafileCgTest, RenderSmallPortraitRectangles) {
   constexpr gfx::Rect kPageBounds(200, 300);
   constexpr gfx::Size kDestinationSize(300, 450);
   TestRenderPage("rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_small_portrait_rectangles_expected.0.png",
                  kDestinationSize);
 }

 TEST(PdfMetafileCgTest, RenderLandscapeRectangles) {
   constexpr gfx::Rect kPageBounds(800, 500);
   constexpr gfx::Size kDestinationSize(400, 600);
   TestRenderPage("landscape_rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_landscape_rectangles_expected.0.png",
                  kDestinationSize);
 }

 TEST(PdfMetafileCgTest, RenderRotatedRectangles) {
   constexpr gfx::Rect kPageBounds(800, 500);
   constexpr gfx::Size kLandscapeDestinationSize(600, 400);
   constexpr gfx::Size kPortraitDestinationSize(400, 600);

   TestRenderPage("rotated_rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_rotated_rectangles_expected.0.png",
                  kLandscapeDestinationSize);
   TestRenderPage("rotated_rectangles.pdf", /*page_number=*/2, kPageBounds,
                  "render_rotated_rectangles_expected.1.png",
                  kPortraitDestinationSize);
   TestRenderPage("rotated_rectangles.pdf", /*page_number=*/3, kPageBounds,
                  "render_rotated_rectangles_expected.2.png",
                  kLandscapeDestinationSize);
   TestRenderPage("rotated_rectangles.pdf", /*page_number=*/4, kPageBounds,
                  "render_rotated_rectangles_expected.3.png",
                  kPortraitDestinationSize);

   TestRenderPage("rotated_rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_autorotated_rotated_rectangles_expected.0.png",
                  kPortraitDestinationSize);
   TestRenderPage("rotated_rectangles.pdf", /*page_number=*/2, kPageBounds,
                  "render_autorotated_rotated_rectangles_expected.1.png",
                  kLandscapeDestinationSize);
   TestRenderPage("rotated_rectangles.pdf", /*page_number=*/3, kPageBounds,
                  "render_autorotated_rotated_rectangles_expected.2.png",
                  kPortraitDestinationSize);
   TestRenderPage("rotated_rectangles.pdf", /*page_number=*/4, kPageBounds,
                  "render_autorotated_rotated_rectangles_expected.3.png",
                  kLandscapeDestinationSize);
 }

 TEST(PdfMetafileCgTest, RenderLargeLandscapeRectangles) {
   constexpr gfx::Rect kPageBounds(800, 500);
   constexpr gfx::Size kDestinationSize(200, 300);
   TestRenderPage("landscape_rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_large_landscape_rectangles_expected.0.png",
                  kDestinationSize);
 }

 TEST(PdfMetafileCgTest, RenderSmallLandscapeRectangles) {
   constexpr gfx::Rect kPageBounds(800, 500);
   constexpr gfx::Size kDestinationSize(600, 900);
   TestRenderPage("landscape_rectangles.pdf", /*page_number=*/1, kPageBounds,
                  "render_small_landscape_rectangles_expected.0.png",
                  kDestinationSize);
 }

 TEST(PdfMetafileCgTest, RenderScaledLargeLandscapeRectangles) {
   constexpr gfx::Rect kPageBounds(800, 500);
   constexpr gfx::Size kDestinationSize(300, 450);
   TestRenderPageWithTransformParams(
       "landscape_rectangles.pdf", /*page_number=*/1, kPageBounds,
       "render_scaled_large_landscape_rectangles_expected.0.png",
       kDestinationSize,
       /*autorotate=*/true, /*fit_to_page=*/true);
 }

 TEST(PdfMetafileCgTest, RenderScaledSmallLandscapeRectangles) {
   constexpr gfx::Rect kPageBounds(800, 500);
   constexpr gfx::Size kDestinationSize(600, 900);
   TestRenderPageWithTransformParams(
       "landscape_rectangles.pdf", /*page_number=*/1, kPageBounds,
       "render_scaled_small_landscape_rectangles_expected.0.png",
       kDestinationSize,
       /*autorotate=*/true, /*fit_to_page=*/true);
 }

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

	#include "printing/pdf_metafile_cg_mac.h"

	#include <CoreGraphics/CoreGraphics.h>
	#include <stdint.h>

	#include <memory>
	#include <string>
	#include <vector>

	#include "base/files/file_util.h"
	#include "base/hash/sha1.h"
	#include "base/path_service.h"
	#include "printing/mojom/print.mojom.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "ui/gfx/codec/png_codec.h"
	#include "ui/gfx/geometry/rect.h"

	namespace printing {

	namespace {

	base::FilePath GetPdfTestData(const base::FilePath::StringType& filename) {
	base::FilePath root_path;
	if (!base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &root_path)) {
	return base::FilePath();
	}
	return root_path.Append("pdf").Append("test").Append("data").Append(filename);
	}

	base::FilePath GetPrintingTestData(const base::FilePath::StringType& filename) {
	base::FilePath root_path;
	if (!base::PathService::Get(base::DIR_SRC_TEST_DATA_ROOT, &root_path)) {
	return base::FilePath();
	}
	return root_path.Append("printing")
	.Append("test")
	.Append("data")
	.Append("pdf_cg")
	.Append(filename);
	}

	std::unique_ptr<PdfMetafileCg> GetPdfMetafile(
	const base::FilePath::StringType& pdf_filename) {
	// Get test data.
	base::FilePath pdf_file = GetPdfTestData(pdf_filename);
	if (pdf_file.empty())
	return nullptr;

	std::string pdf_data;
	if (!base::ReadFileToString(pdf_file, &pdf_data))
	return nullptr;

	// Initialize and check metafile.
	auto pdf_cg = std::make_unique<PdfMetafileCg>();
	if (!pdf_cg->InitFromData(base::as_bytes(base::make_span(pdf_data))))
	return nullptr;
	return pdf_cg;
	}

	void RenderedPdfSha1(const base::FilePath::StringType& pdf_filename,
	size_t page_number,
	const gfx::Rect& expected_page_bounds,
	const gfx::Size& dest_size,
	bool autorotate,
	bool fit_to_page,
	base::SHA1Digest* rendered_hash) {
	// Initialize and verify the metafile.
	std::unique_ptr<PdfMetafileCg> pdf_cg = GetPdfMetafile(pdf_filename);
	ASSERT_TRUE(pdf_cg);
	ASSERT_LE(page_number, pdf_cg->GetPageCount());
	const gfx::Rect bounds = pdf_cg->GetPageBounds(page_number);
	ASSERT_EQ(expected_page_bounds, bounds);

	// Set up rendering context.
	constexpr size_t kBitsPerComponent = 8;
	constexpr size_t kBytesPerPixel = 4;
	const size_t kStride = dest_size.width() * kBytesPerPixel;
	std::vector<uint8_t> rendered_bitmap(dest_size.height() * kStride);
	base::apple::ScopedCFTypeRef<CGColorSpaceRef> color_space(
	CGColorSpaceCreateDeviceRGB());
	base::apple::ScopedCFTypeRef<CGContextRef> context(CGBitmapContextCreate(
	rendered_bitmap.data(), dest_size.width(), dest_size.height(),
	kBitsPerComponent, kStride, color_space.get(),
	uint32_t{kCGImageAlphaPremultipliedFirst} \| kCGBitmapByteOrder32Little));

	// Render using metafile and calculate the output hash.
	ASSERT_TRUE(pdf_cg->RenderPage(page_number, context.get(),
	gfx::Rect(dest_size).ToCGRect(), autorotate,
	fit_to_page));
	*rendered_hash = base::SHA1HashSpan(rendered_bitmap);
	}

	void ExpectedPngSha1(const base::FilePath::StringType& expected_png_filename,
	const gfx::Size& expected_png_size,
	base::SHA1Digest* expected_hash) {
	base::FilePath expected_png_file = GetPrintingTestData(expected_png_filename);
	ASSERT_FALSE(expected_png_file.empty());
	std::string expected_png_data;
	ASSERT_TRUE(base::ReadFileToString(expected_png_file, &expected_png_data));

	// Decode expected PNG and calculate the output hash.
	std::vector<uint8_t> expected_png_bitmap;
	int png_width;
	int png_height;
	ASSERT_TRUE(gfx::PNGCodec::Decode(
	reinterpret_cast<const uint8_t*>(expected_png_data.data()),
	expected_png_data.size(), gfx::PNGCodec::FORMAT_BGRA,
	&expected_png_bitmap, &png_width, &png_height));
	ASSERT_EQ(expected_png_size.width(), png_width);
	ASSERT_EQ(expected_png_size.height(), png_height);
	*expected_hash = base::SHA1HashSpan(expected_png_bitmap);
	}

	void TestRenderPageWithTransformParams(
	const base::FilePath::StringType& pdf_filename,
	size_t page_number,
	const gfx::Rect& expected_page_bounds,
	const base::FilePath::StringType& expected_png_filename,
	const gfx::Size& dest_size,
	bool autorotate,
	bool fit_to_page) {
	base::SHA1Digest rendered_hash;
	RenderedPdfSha1(pdf_filename, page_number, expected_page_bounds, dest_size,
	autorotate, fit_to_page, &rendered_hash);
	base::SHA1Digest expected_hash;
	ExpectedPngSha1(expected_png_filename, dest_size, &expected_hash);

	// Make sure the hashes match.
	EXPECT_EQ(expected_hash, rendered_hash);
	}

	void TestRenderPage(const base::FilePath::StringType& pdf_filename,
	size_t page_number,
	const gfx::Rect& expected_page_bounds,
	const base::FilePath::StringType& expected_png_filename,
	const gfx::Size& dest_size) {
	TestRenderPageWithTransformParams(
	pdf_filename, page_number, expected_page_bounds, expected_png_filename,
	dest_size, /autorotate=/true, /fit_to_page=/false);
	}

	} // namespace

	TEST(PdfMetafileCgTest, Pdf) {
	// Test in-renderer constructor.
	PdfMetafileCg pdf;
	EXPECT_TRUE(pdf.Init());
	EXPECT_TRUE(pdf.context());

	// Render page 1.
	constexpr gfx::Rect kRect1(10, 10, 520, 700);
	constexpr gfx::Size kSize1(540, 720);
	pdf.StartPage(kSize1, kRect1, 1.25, mojom::PageOrientation::kUpright);
	pdf.FinishPage();

	// Render page 2.
	constexpr gfx::Rect kRect2(10, 10, 520, 700);
	constexpr gfx::Size kSize2(720, 540);
	pdf.StartPage(kSize2, kRect2, 2.0, mojom::PageOrientation::kUpright);
	pdf.FinishPage();

	pdf.FinishDocument();

	// Check data size.
	const uint32_t size = pdf.GetDataSize();
	EXPECT_GT(size, 0U);

	// Get resulting data.
	std::vector<char> buffer(size, 0);
	pdf.GetData(&buffer.front(), size);

	// Test browser-side constructor.
	PdfMetafileCg pdf2;
	// TODO(thestig): Make `buffer` uint8_t and avoid the base::as_bytes() call.
	EXPECT_TRUE(pdf2.InitFromData(base::as_bytes(base::make_span(buffer))));

	// Get the first 4 characters from pdf2.
	std::vector<char> buffer2(4, 0);
	pdf2.GetData(&buffer2.front(), 4);

	// Test that the header begins with "%PDF".
	std::string header(&buffer2.front(), 4);
	EXPECT_EQ(0U, header.find("%PDF", 0));

	// Test that the PDF is correctly reconstructed.
	EXPECT_EQ(2U, pdf2.GetPageCount());
	gfx::Size page_size = pdf2.GetPageBounds(1).size();
	EXPECT_EQ(540, page_size.width());
	EXPECT_EQ(720, page_size.height());
	page_size = pdf2.GetPageBounds(2).size();
	EXPECT_EQ(720, page_size.width());
	EXPECT_EQ(540, page_size.height());
	}

	TEST(PdfMetafileCgTest, GetPageBounds) {
	// Get test data.
	base::FilePath pdf_file = GetPdfTestData("rectangles_multi_pages.pdf");
	ASSERT_FALSE(pdf_file.empty());
	std::string pdf_data;
	ASSERT_TRUE(base::ReadFileToString(pdf_file, &pdf_data));

	// Initialize and check metafile.
	PdfMetafileCg pdf_cg;
	ASSERT_TRUE(pdf_cg.InitFromData(base::as_bytes(base::make_span(pdf_data))));
	ASSERT_EQ(5u, pdf_cg.GetPageCount());

	// Since the input into GetPageBounds() is a 1-indexed page number, 0 and 6
	// are out of bounds.
	gfx::Rect bounds;
	for (size_t i : {0, 6}) {
	bounds = pdf_cg.GetPageBounds(i);
	EXPECT_EQ(0, bounds.x());
	EXPECT_EQ(0, bounds.y());
	EXPECT_EQ(0, bounds.width());
	EXPECT_EQ(0, bounds.height());
	}

	// Whereas 1-5 are in bounds.
	for (size_t i = 1; i < 6; ++i) {
	bounds = pdf_cg.GetPageBounds(i);
	EXPECT_EQ(0, bounds.x());
	EXPECT_EQ(0, bounds.y());
	EXPECT_EQ(200, bounds.width());
	EXPECT_EQ(250, bounds.height());
	}
	}

	TEST(PdfMetafileCgTest, RenderPortraitRectangles) {
	constexpr gfx::Rect kPageBounds(200, 300);
	constexpr gfx::Size kDestinationSize(200, 300);
	TestRenderPage("rectangles.pdf", /page_number=/1, kPageBounds,
	"render_portrait_rectangles_expected.0.png", kDestinationSize);
	}

	TEST(PdfMetafileCgTest, RenderAutorotatedPortraitRectangles) {
	constexpr gfx::Rect kPageBounds(200, 300);
	constexpr gfx::Size kDestinationSize(300, 200);
	TestRenderPage("rectangles.pdf", /page_number=/1, kPageBounds,
	"render_autorotated_portrait_rectangles_expected.0.png",
	kDestinationSize);
	}

	TEST(PdfMetafileCgTest, RenderLargePortraitRectangles) {
	constexpr gfx::Rect kPageBounds(200, 300);
	constexpr gfx::Size kDestinationSize(100, 120);
	TestRenderPage("rectangles.pdf", /page_number=/1, kPageBounds,
	"render_large_portrait_rectangles_expected.0.png",
	kDestinationSize);
	}

	TEST(PdfMetafileCgTest, RenderSmallPortraitRectangles) {
	constexpr gfx::Rect kPageBounds(200, 300);
	constexpr gfx::Size kDestinationSize(300, 450);
	TestRenderPage("rectangles.pdf", /page_number=/1, kPageBounds,
	"render_small_portrait_rectangles_expected.0.png",
	kDestinationSize);
	}

	TEST(PdfMetafileCgTest, RenderLandscapeRectangles) {
	constexpr gfx::Rect kPageBounds(800, 500);
	constexpr gfx::Size kDestinationSize(400, 600);
	TestRenderPage("landscape_rectangles.pdf", /page_number=/1, kPageBounds,
	"render_landscape_rectangles_expected.0.png",
	kDestinationSize);
	}

	TEST(PdfMetafileCgTest, RenderRotatedRectangles) {
	constexpr gfx::Rect kPageBounds(800, 500);
	constexpr gfx::Size kLandscapeDestinationSize(600, 400);
	constexpr gfx::Size kPortraitDestinationSize(400, 600);

	TestRenderPage("rotated_rectangles.pdf", /page_number=/1, kPageBounds,
	"render_rotated_rectangles_expected.0.png",
	kLandscapeDestinationSize);
	TestRenderPage("rotated_rectangles.pdf", /page_number=/2, kPageBounds,
	"render_rotated_rectangles_expected.1.png",
	kPortraitDestinationSize);
	TestRenderPage("rotated_rectangles.pdf", /page_number=/3, kPageBounds,
	"render_rotated_rectangles_expected.2.png",
	kLandscapeDestinationSize);
	TestRenderPage("rotated_rectangles.pdf", /page_number=/4, kPageBounds,
	"render_rotated_rectangles_expected.3.png",
	kPortraitDestinationSize);

	TestRenderPage("rotated_rectangles.pdf", /page_number=/1, kPageBounds,
	"render_autorotated_rotated_rectangles_expected.0.png",
	kPortraitDestinationSize);
	TestRenderPage("rotated_rectangles.pdf", /page_number=/2, kPageBounds,
	"render_autorotated_rotated_rectangles_expected.1.png",
	kLandscapeDestinationSize);
	TestRenderPage("rotated_rectangles.pdf", /page_number=/3, kPageBounds,
	"render_autorotated_rotated_rectangles_expected.2.png",
	kPortraitDestinationSize);
	TestRenderPage("rotated_rectangles.pdf", /page_number=/4, kPageBounds,
	"render_autorotated_rotated_rectangles_expected.3.png",
	kLandscapeDestinationSize);
	}

	TEST(PdfMetafileCgTest, RenderLargeLandscapeRectangles) {
	constexpr gfx::Rect kPageBounds(800, 500);
	constexpr gfx::Size kDestinationSize(200, 300);
	TestRenderPage("landscape_rectangles.pdf", /page_number=/1, kPageBounds,
	"render_large_landscape_rectangles_expected.0.png",
	kDestinationSize);
	}

	TEST(PdfMetafileCgTest, RenderSmallLandscapeRectangles) {
	constexpr gfx::Rect kPageBounds(800, 500);
	constexpr gfx::Size kDestinationSize(600, 900);
	TestRenderPage("landscape_rectangles.pdf", /page_number=/1, kPageBounds,
	"render_small_landscape_rectangles_expected.0.png",
	kDestinationSize);
	}

	TEST(PdfMetafileCgTest, RenderScaledLargeLandscapeRectangles) {
	constexpr gfx::Rect kPageBounds(800, 500);
	constexpr gfx::Size kDestinationSize(300, 450);
	TestRenderPageWithTransformParams(
	"landscape_rectangles.pdf", /page_number=/1, kPageBounds,
	"render_scaled_large_landscape_rectangles_expected.0.png",
	kDestinationSize,
	/autorotate=/true, /fit_to_page=/true);
	}

	TEST(PdfMetafileCgTest, RenderScaledSmallLandscapeRectangles) {
	constexpr gfx::Rect kPageBounds(800, 500);
	constexpr gfx::Size kDestinationSize(600, 900);
	TestRenderPageWithTransformParams(
	"landscape_rectangles.pdf", /page_number=/1, kPageBounds,
	"render_scaled_small_landscape_rectangles_expected.0.png",
	kDestinationSize,
	/autorotate=/true, /fit_to_page=/true);
	}

	} // namespace printing