pdf/pdf.cc

   1 // Copyright 2010 The Chromium Authors
   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.h"
   6
   7 #include <stdint.h>
   8
   9 #include <utility>
  10
  11 #include "build/build_config.h"
  12 #include "pdf/pdf_engine.h"
  13 #include "pdf/pdf_init.h"
  14 #include "ui/gfx/geometry/rect.h"
  15 #include "ui/gfx/geometry/size_f.h"
  16
  17 namespace chrome_pdf {
  18
  19 namespace {
  20
  21 class ScopedSdkInitializer {
  22  public:
  23   explicit ScopedSdkInitializer(bool enable_v8) {
  24     if (!IsSDKInitializedViaPlugin())
  25       InitializeSDK(enable_v8, FontMappingMode::kNoMapping);
  26   }
  27
  28   ScopedSdkInitializer(const ScopedSdkInitializer&) = delete;
  29   ScopedSdkInitializer& operator=(const ScopedSdkInitializer&) = delete;
  30
  31   ~ScopedSdkInitializer() {
  32     if (!IsSDKInitializedViaPlugin())
  33       ShutdownSDK();
  34   }
  35 };
  36
  37 }  // namespace
  38
  39 #if BUILDFLAG(IS_CHROMEOS)
  40 std::vector<uint8_t> CreateFlattenedPdf(
  41     base::span<const uint8_t> input_buffer) {
  42   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/false);
  43   return PDFEngineExports::Get()->CreateFlattenedPdf(input_buffer);
  44 }
  45 #endif  // BUILDFLAG(IS_CHROMEOS)
  46
  47 #if BUILDFLAG(IS_WIN)
  48 bool RenderPDFPageToDC(base::span<const uint8_t> pdf_buffer,
  49                        int page_index,
  50                        HDC dc,
  51                        int dpi_x,
  52                        int dpi_y,
  53                        int bounds_origin_x,
  54                        int bounds_origin_y,
  55                        int bounds_width,
  56                        int bounds_height,
  57                        bool fit_to_bounds,
  58                        bool stretch_to_bounds,
  59                        bool keep_aspect_ratio,
  60                        bool center_in_bounds,
  61                        bool autorotate,
  62                        bool use_color) {
  63   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/true);
  64   PDFEngineExports* engine_exports = PDFEngineExports::Get();
  65   PDFEngineExports::RenderingSettings settings(
  66       gfx::Size(dpi_x, dpi_y),
  67       gfx::Rect(bounds_origin_x, bounds_origin_y, bounds_width, bounds_height),
  68       fit_to_bounds, stretch_to_bounds, keep_aspect_ratio, center_in_bounds,
  69       autorotate, use_color, /*render_for_printing=*/true);
  70   return engine_exports->RenderPDFPageToDC(pdf_buffer, page_index, settings,
  71                                            dc);
  72 }
  73
  74 void SetPDFUsePrintMode(int mode) {
  75   PDFEngineExports::Get()->SetPDFUsePrintMode(mode);
  76 }
  77 #endif  // BUILDFLAG(IS_WIN)
  78
  79 bool GetPDFDocInfo(base::span<const uint8_t> pdf_buffer,
  80                    int* page_count,
  81                    float* max_page_width) {
  82   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/true);
  83   PDFEngineExports* engine_exports = PDFEngineExports::Get();
  84   return engine_exports->GetPDFDocInfo(pdf_buffer, page_count, max_page_width);
  85 }
  86
  87 absl::optional<bool> IsPDFDocTagged(base::span<const uint8_t> pdf_buffer) {
  88   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/true);
  89   PDFEngineExports* engine_exports = PDFEngineExports::Get();
  90   return engine_exports->IsPDFDocTagged(pdf_buffer);
  91 }
  92
  93 base::Value GetPDFStructTreeForPage(base::span<const uint8_t> pdf_buffer,
  94                                     int page_index) {
  95   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/true);
  96   PDFEngineExports* engine_exports = PDFEngineExports::Get();
  97   return engine_exports->GetPDFStructTreeForPage(pdf_buffer, page_index);
  98 }
  99
 100 absl::optional<gfx::SizeF> GetPDFPageSizeByIndex(
 101     base::span<const uint8_t> pdf_buffer,
 102     int page_index) {
 103   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/true);
 104   chrome_pdf::PDFEngineExports* engine_exports =
 105       chrome_pdf::PDFEngineExports::Get();
 106   return engine_exports->GetPDFPageSizeByIndex(pdf_buffer, page_index);
 107 }
 108
 109 bool RenderPDFPageToBitmap(base::span<const uint8_t> pdf_buffer,
 110                            int page_index,
 111                            void* bitmap_buffer,
 112                            const gfx::Size& bitmap_size,
 113                            const gfx::Size& dpi,
 114                            const RenderOptions& options) {
 115   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/true);
 116   PDFEngineExports* engine_exports = PDFEngineExports::Get();
 117   PDFEngineExports::RenderingSettings settings(
 118       dpi, gfx::Rect(bitmap_size),
 119       /*fit_to_bounds=*/true, options.stretch_to_bounds,
 120       options.keep_aspect_ratio,
 121       /*center_in_bounds=*/true, options.autorotate, options.use_color,
 122       options.render_device_type == RenderDeviceType::kPrinter);
 123   return engine_exports->RenderPDFPageToBitmap(pdf_buffer, page_index, settings,
 124                                                bitmap_buffer);
 125 }
 126
 127 std::vector<uint8_t> ConvertPdfPagesToNupPdf(
 128     std::vector<base::span<const uint8_t>> input_buffers,
 129     size_t pages_per_sheet,
 130     const gfx::Size& page_size,
 131     const gfx::Rect& printable_area) {
 132   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/false);
 133   PDFEngineExports* engine_exports = PDFEngineExports::Get();
 134   return engine_exports->ConvertPdfPagesToNupPdf(
 135       std::move(input_buffers), pages_per_sheet, page_size, printable_area);
 136 }
 137
 138 std::vector<uint8_t> ConvertPdfDocumentToNupPdf(
 139     base::span<const uint8_t> input_buffer,
 140     size_t pages_per_sheet,
 141     const gfx::Size& page_size,
 142     const gfx::Rect& printable_area) {
 143   ScopedSdkInitializer scoped_sdk_initializer(/*enable_v8=*/false);
 144   PDFEngineExports* engine_exports = PDFEngineExports::Get();
 145   return engine_exports->ConvertPdfDocumentToNupPdf(
 146       input_buffer, pages_per_sheet, page_size, printable_area);
 147 }
 148
 149 }  // namespace chrome_pdf