pdf/pdf_transform_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "pdf/pdf_transform.h"
   6
   7 #include "printing/units.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "ui/gfx/geometry/rect.h"
  10
  11 namespace chrome_pdf {
  12
  13 namespace {
  14
  15 constexpr float kDefaultWidth = 8.5 * printing::kPointsPerInch;
  16 constexpr float kDefaultHeight = 11.0 * printing::kPointsPerInch;
  17 constexpr float kDefaultRatio = kDefaultWidth / kDefaultHeight;
  18 constexpr double kTolerance = 0.0001;
  19
  20 void ExpectDefaultPortraitBox(const PdfRectangle& box) {
  21   EXPECT_FLOAT_EQ(0, box.left);
  22   EXPECT_FLOAT_EQ(0, box.bottom);
  23   EXPECT_FLOAT_EQ(kDefaultWidth, box.right);
  24   EXPECT_FLOAT_EQ(kDefaultHeight, box.top);
  25 }
  26
  27 void ExpectDefaultLandscapeBox(const PdfRectangle& box) {
  28   EXPECT_FLOAT_EQ(0, box.left);
  29   EXPECT_FLOAT_EQ(0, box.bottom);
  30   EXPECT_FLOAT_EQ(kDefaultHeight, box.right);
  31   EXPECT_FLOAT_EQ(kDefaultWidth, box.top);
  32 }
  33
  34 void ExpectBoxesAreEqual(const PdfRectangle& expected,
  35                          const PdfRectangle& actual) {
  36   EXPECT_FLOAT_EQ(expected.left, actual.left);
  37   EXPECT_FLOAT_EQ(expected.bottom, actual.bottom);
  38   EXPECT_FLOAT_EQ(expected.right, actual.right);
  39   EXPECT_FLOAT_EQ(expected.top, actual.top);
  40 }
  41
  42 void InitializeBoxToInvalidValues(PdfRectangle* box) {
  43   box->left = box->bottom = box->right = box->top = -1;
  44 }
  45
  46 void InitializeBoxToDefaultPortraitValues(PdfRectangle* box) {
  47   box->left = 0;
  48   box->bottom = 0;
  49   box->right = kDefaultWidth;
  50   box->top = kDefaultHeight;
  51 }
  52
  53 void InitializeBoxToDefaultLandscapeValue(PdfRectangle* box) {
  54   box->left = 0;
  55   box->bottom = 0;
  56   box->right = kDefaultHeight;
  57   box->top = kDefaultWidth;
  58 }
  59
  60 }  // namespace
  61
  62 TEST(PdfTransformTest, CalculateScaleFactor) {
  63   gfx::Rect rect(kDefaultWidth, kDefaultHeight);
  64   double scale;
  65
  66   // 1:1
  67   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, false);
  68   EXPECT_NEAR(1, scale, kTolerance);
  69   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, true);
  70   EXPECT_NEAR(kDefaultRatio, scale, kTolerance);
  71
  72   // 1:2
  73   rect = gfx::Rect(kDefaultWidth / 2, kDefaultHeight / 2);
  74   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, false);
  75   EXPECT_NEAR(0.5, scale, kTolerance);
  76   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, true);
  77   EXPECT_NEAR(kDefaultRatio / 2, scale, kTolerance);
  78
  79   // 3:1
  80   rect = gfx::Rect(kDefaultWidth * 3, kDefaultHeight * 3);
  81   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, false);
  82   EXPECT_NEAR(3, scale, kTolerance);
  83   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, true);
  84   EXPECT_NEAR(kDefaultRatio * 3, scale, kTolerance);
  85
  86   // 3:1, rotated.
  87   rect = gfx::Rect(kDefaultHeight * 3, kDefaultWidth * 3);
  88   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, false);
  89   EXPECT_NEAR(kDefaultRatio * 3, scale, kTolerance);
  90   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, true);
  91   EXPECT_NEAR(3, scale, kTolerance);
  92
  93   // Odd size
  94   rect = gfx::Rect(10, 1000);
  95   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, false);
  96   EXPECT_NEAR(0.01634, scale, kTolerance);
  97   scale = CalculateScaleFactor(rect, kDefaultWidth, kDefaultHeight, true);
  98   EXPECT_NEAR(0.01263, scale, kTolerance);
  99 }
 100
 101 TEST(PdfTransformTest, SetDefaultClipBox) {
 102   PdfRectangle box;
 103
 104   SetDefaultClipBox(false, &box);
 105   ExpectDefaultPortraitBox(box);
 106
 107   SetDefaultClipBox(true, &box);
 108   ExpectDefaultLandscapeBox(box);
 109 }
 110
 111 TEST(PdfTransformTest, CalculateMediaBoxAndCropBox) {
 112   PdfRectangle media_box;
 113   PdfRectangle crop_box;
 114
 115   // Assume both boxes are there.
 116   InitializeBoxToDefaultPortraitValues(&media_box);
 117   InitializeBoxToDefaultLandscapeValue(&crop_box);
 118   CalculateMediaBoxAndCropBox(true, true, true, &media_box, &crop_box);
 119   ExpectDefaultPortraitBox(media_box);
 120   ExpectDefaultLandscapeBox(crop_box);
 121
 122   // Assume both boxes are missing.
 123   InitializeBoxToInvalidValues(&media_box);
 124   InitializeBoxToInvalidValues(&crop_box);
 125   CalculateMediaBoxAndCropBox(false, false, false, &media_box, &crop_box);
 126   ExpectDefaultPortraitBox(media_box);
 127   ExpectDefaultPortraitBox(crop_box);
 128   CalculateMediaBoxAndCropBox(true, false, false, &media_box, &crop_box);
 129   ExpectDefaultLandscapeBox(media_box);
 130   ExpectDefaultLandscapeBox(crop_box);
 131
 132   // Assume crop box is missing.
 133   constexpr PdfRectangle expected_box = {0, 0, 42, 420};
 134   media_box = expected_box;
 135   InitializeBoxToInvalidValues(&crop_box);
 136   CalculateMediaBoxAndCropBox(false, true, false, &media_box, &crop_box);
 137   ExpectBoxesAreEqual(expected_box, media_box);
 138   ExpectBoxesAreEqual(expected_box, crop_box);
 139
 140   // Assume media box is missing.
 141   InitializeBoxToInvalidValues(&media_box);
 142   CalculateMediaBoxAndCropBox(false, false, true, &media_box, &crop_box);
 143   ExpectBoxesAreEqual(expected_box, media_box);
 144   ExpectBoxesAreEqual(expected_box, crop_box);
 145 }
 146
 147 TEST(PdfTransformTest, CalculateClipBoxBoundary) {
 148   PdfRectangle media_box;
 149   PdfRectangle crop_box;
 150   PdfRectangle result;
 151
 152   // media box and crop box are the same.
 153   InitializeBoxToDefaultPortraitValues(&media_box);
 154   InitializeBoxToDefaultPortraitValues(&crop_box);
 155   result = CalculateClipBoxBoundary(media_box, crop_box);
 156   ExpectDefaultPortraitBox(result);
 157
 158   // media box is portrait and crop box is landscape.
 159   InitializeBoxToDefaultLandscapeValue(&crop_box);
 160   result = CalculateClipBoxBoundary(media_box, crop_box);
 161   EXPECT_FLOAT_EQ(0, result.left);
 162   EXPECT_FLOAT_EQ(0, result.bottom);
 163   EXPECT_FLOAT_EQ(kDefaultWidth, result.right);
 164   EXPECT_FLOAT_EQ(kDefaultWidth, result.top);
 165
 166   // crop box is smaller than media box.
 167   crop_box.left = 0;
 168   crop_box.bottom = 0;
 169   crop_box.right = 100;
 170   crop_box.top = 200;
 171   result = CalculateClipBoxBoundary(media_box, crop_box);
 172   EXPECT_FLOAT_EQ(0, result.left);
 173   EXPECT_FLOAT_EQ(0, result.bottom);
 174   EXPECT_FLOAT_EQ(100, result.right);
 175   EXPECT_FLOAT_EQ(200, result.top);
 176
 177   // crop box is smaller than the media box in one dimension and longer in the
 178   // other.
 179   crop_box.left = 0;
 180   crop_box.bottom = 0;
 181   crop_box.right = 100;
 182   crop_box.top = 2000;
 183   result = CalculateClipBoxBoundary(media_box, crop_box);
 184   EXPECT_FLOAT_EQ(0, result.left);
 185   EXPECT_FLOAT_EQ(0, result.bottom);
 186   EXPECT_FLOAT_EQ(100, result.right);
 187   EXPECT_FLOAT_EQ(kDefaultHeight, result.top);
 188 }
 189
 190 TEST(PdfTransformTest, CalculateScaledClipBoxOffset) {
 191   constexpr gfx::Rect rect(kDefaultWidth, kDefaultHeight);
 192   PdfRectangle clip_box;
 193   double offset_x;
 194   double offset_y;
 195
 196   // |rect| and |clip_box| are the same size.
 197   InitializeBoxToDefaultPortraitValues(&clip_box);
 198   CalculateScaledClipBoxOffset(rect, clip_box, &offset_x, &offset_y);
 199   EXPECT_DOUBLE_EQ(0, offset_x);
 200   EXPECT_DOUBLE_EQ(0, offset_y);
 201
 202   // |rect| is larger than |clip_box|.
 203   clip_box.top /= 2;
 204   clip_box.right /= 4;
 205   CalculateScaledClipBoxOffset(rect, clip_box, &offset_x, &offset_y);
 206   EXPECT_DOUBLE_EQ(229.5, offset_x);
 207   EXPECT_DOUBLE_EQ(198, offset_y);
 208 }
 209
 210 TEST(PdfTransformTest, CalculateNonScaledClipBoxOffset) {
 211   int page_width = kDefaultWidth;
 212   int page_height = kDefaultHeight;
 213   constexpr gfx::Rect rect(kDefaultWidth, kDefaultHeight);
 214   PdfRectangle clip_box;
 215   double offset_x;
 216   double offset_y;
 217
 218   // |rect|, page size and |clip_box| are the same.
 219   InitializeBoxToDefaultPortraitValues(&clip_box);
 220   CalculateNonScaledClipBoxOffset(rect, 0, page_width, page_height, clip_box,
 221                                   &offset_x, &offset_y);
 222   EXPECT_DOUBLE_EQ(0, offset_x);
 223   EXPECT_DOUBLE_EQ(0, offset_y);
 224   CalculateNonScaledClipBoxOffset(rect, 1, page_width, page_height, clip_box,
 225                                   &offset_x, &offset_y);
 226   EXPECT_DOUBLE_EQ(0, offset_x);
 227   EXPECT_DOUBLE_EQ(0, offset_y);
 228   CalculateNonScaledClipBoxOffset(rect, 2, page_width, page_height, clip_box,
 229                                   &offset_x, &offset_y);
 230   EXPECT_DOUBLE_EQ(0, offset_x);
 231   EXPECT_DOUBLE_EQ(0, offset_y);
 232   CalculateNonScaledClipBoxOffset(rect, 3, page_width, page_height, clip_box,
 233                                   &offset_x, &offset_y);
 234   EXPECT_DOUBLE_EQ(180, offset_x);
 235   EXPECT_DOUBLE_EQ(-180, offset_y);
 236
 237   // Smaller |clip_box|.
 238   clip_box.top /= 4;
 239   clip_box.right /= 2;
 240   CalculateNonScaledClipBoxOffset(rect, 0, page_width, page_height, clip_box,
 241                                   &offset_x, &offset_y);
 242   EXPECT_DOUBLE_EQ(0, offset_x);
 243   EXPECT_DOUBLE_EQ(594, offset_y);
 244   CalculateNonScaledClipBoxOffset(rect, 1, page_width, page_height, clip_box,
 245                                   &offset_x, &offset_y);
 246   EXPECT_DOUBLE_EQ(0, offset_x);
 247   EXPECT_DOUBLE_EQ(0, offset_y);
 248   CalculateNonScaledClipBoxOffset(rect, 2, page_width, page_height, clip_box,
 249                                   &offset_x, &offset_y);
 250   EXPECT_DOUBLE_EQ(306, offset_x);
 251   EXPECT_DOUBLE_EQ(0, offset_y);
 252   CalculateNonScaledClipBoxOffset(rect, 3, page_width, page_height, clip_box,
 253                                   &offset_x, &offset_y);
 254   EXPECT_DOUBLE_EQ(486, offset_x);
 255   EXPECT_DOUBLE_EQ(414, offset_y);
 256
 257   // Larger page size.
 258   InitializeBoxToDefaultPortraitValues(&clip_box);
 259   page_width += 10;
 260   page_height += 20;
 261   CalculateNonScaledClipBoxOffset(rect, 0, page_width, page_height, clip_box,
 262                                   &offset_x, &offset_y);
 263   EXPECT_DOUBLE_EQ(0, offset_x);
 264   EXPECT_DOUBLE_EQ(20, offset_y);
 265   CalculateNonScaledClipBoxOffset(rect, 1, page_width, page_height, clip_box,
 266                                   &offset_x, &offset_y);
 267   EXPECT_DOUBLE_EQ(0, offset_x);
 268   EXPECT_DOUBLE_EQ(0, offset_y);
 269   CalculateNonScaledClipBoxOffset(rect, 2, page_width, page_height, clip_box,
 270                                   &offset_x, &offset_y);
 271   EXPECT_DOUBLE_EQ(10, offset_x);
 272   EXPECT_DOUBLE_EQ(0, offset_y);
 273   CalculateNonScaledClipBoxOffset(rect, 3, page_width, page_height, clip_box,
 274                                   &offset_x, &offset_y);
 275   EXPECT_DOUBLE_EQ(200, offset_x);
 276   EXPECT_DOUBLE_EQ(-170, offset_y);
 277 }
 278
 279 // https://crbug.com/491160 and https://crbug.com/588757
 280 TEST(PdfTransformTest, ReversedMediaBox) {
 281   int page_width = kDefaultWidth;
 282   int page_height = kDefaultHeight;
 283   constexpr gfx::Rect rect(kDefaultWidth, kDefaultHeight);
 284   PdfRectangle clip_box;
 285   double offset_x;
 286   double offset_y;
 287
 288   constexpr PdfRectangle expected_media_box_b491160 = {0, -792, 612, 0};
 289   PdfRectangle media_box_b491160 = {0, 0, 612, -792};
 290   CalculateMediaBoxAndCropBox(false, true, false, &media_box_b491160,
 291                               &clip_box);
 292   ExpectBoxesAreEqual(expected_media_box_b491160, media_box_b491160);
 293   ExpectBoxesAreEqual(expected_media_box_b491160, clip_box);
 294
 295   CalculateScaledClipBoxOffset(rect, media_box_b491160, &offset_x, &offset_y);
 296   EXPECT_DOUBLE_EQ(0, offset_x);
 297   EXPECT_DOUBLE_EQ(792, offset_y);
 298
 299   CalculateNonScaledClipBoxOffset(rect, 0, page_width, page_height,
 300                                   media_box_b491160, &offset_x, &offset_y);
 301   EXPECT_DOUBLE_EQ(0, offset_x);
 302   EXPECT_DOUBLE_EQ(792, offset_y);
 303
 304   PdfRectangle media_box_b588757 = {0, 792, 612, 0};
 305   CalculateMediaBoxAndCropBox(false, true, false, &media_box_b588757,
 306                               &clip_box);
 307   ExpectDefaultPortraitBox(media_box_b588757);
 308   ExpectDefaultPortraitBox(clip_box);
 309
 310   CalculateScaledClipBoxOffset(rect, clip_box, &offset_x, &offset_y);
 311   EXPECT_DOUBLE_EQ(0, offset_x);
 312   EXPECT_DOUBLE_EQ(0, offset_y);
 313
 314   CalculateNonScaledClipBoxOffset(rect, 0, page_width, page_height, clip_box,
 315                                   &offset_x, &offset_y);
 316   EXPECT_DOUBLE_EQ(0, offset_x);
 317   EXPECT_DOUBLE_EQ(0, offset_y);
 318
 319   PdfRectangle media_box_left_right_flipped = {612, 792, 0, 0};
 320   CalculateMediaBoxAndCropBox(false, true, false, &media_box_left_right_flipped,
 321                               &clip_box);
 322   ExpectDefaultPortraitBox(media_box_left_right_flipped);
 323   ExpectDefaultPortraitBox(clip_box);
 324
 325   CalculateScaledClipBoxOffset(rect, clip_box, &offset_x, &offset_y);
 326   EXPECT_DOUBLE_EQ(0, offset_x);
 327   EXPECT_DOUBLE_EQ(0, offset_y);
 328
 329   CalculateNonScaledClipBoxOffset(rect, 0, page_width, page_height, clip_box,
 330                                   &offset_x, &offset_y);
 331   EXPECT_DOUBLE_EQ(0, offset_x);
 332   EXPECT_DOUBLE_EQ(0, offset_y);
 333 }
 334
 335 }  // namespace chrome_pdf