// Copyright 2014 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "chrome/utility/printing_handler.h" #include "base/file_util.h" #include "base/lazy_instance.h" #include "base/path_service.h" #include "base/scoped_native_library.h" #include "chrome/common/chrome_paths.h" #include "chrome/common/chrome_utility_printing_messages.h" #include "chrome/utility/cloud_print/bitmap_image.h" #include "chrome/utility/cloud_print/pwg_encoder.h" #include "content/public/utility/utility_thread.h" #include "printing/page_range.h" #include "printing/pdf_render_settings.h" #if defined(OS_WIN) #include "base/win/iat_patch_function.h" #include "printing/emf_win.h" #include "ui/gfx/gdi_util.h" #endif #if defined(ENABLE_FULL_PRINTING) #include "chrome/common/crash_keys.h" #include "printing/backend/print_backend.h" #endif namespace { bool Send(IPC::Message* message) { return content::UtilityThread::Get()->Send(message); } void ReleaseProcessIfNeeded() { content::UtilityThread::Get()->ReleaseProcessIfNeeded(); } class PdfFunctionsBase { public: PdfFunctionsBase() : render_pdf_to_bitmap_func_(NULL), get_pdf_doc_info_func_(NULL) {} bool Init() { base::FilePath pdf_module_path; if (!PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_module_path) || !base::PathExists(pdf_module_path)) { return false; } pdf_lib_.Reset(base::LoadNativeLibrary(pdf_module_path, NULL)); if (!pdf_lib_.is_valid()) { LOG(WARNING) << "Couldn't load PDF plugin"; return false; } render_pdf_to_bitmap_func_ = reinterpret_cast<RenderPDFPageToBitmapProc>( pdf_lib_.GetFunctionPointer("RenderPDFPageToBitmap")); LOG_IF(WARNING, !render_pdf_to_bitmap_func_) << "Missing RenderPDFPageToBitmap"; get_pdf_doc_info_func_ = reinterpret_cast<GetPDFDocInfoProc>( pdf_lib_.GetFunctionPointer("GetPDFDocInfo")); LOG_IF(WARNING, !get_pdf_doc_info_func_) << "Missing GetPDFDocInfo"; if (!render_pdf_to_bitmap_func_ || !get_pdf_doc_info_func_ || !PlatformInit(pdf_module_path, pdf_lib_)) { Reset(); } return IsValid(); } bool IsValid() const { return pdf_lib_.is_valid(); } void Reset() { pdf_lib_.Reset(NULL); } bool RenderPDFPageToBitmap(const void* pdf_buffer, int pdf_buffer_size, int page_number, void* bitmap_buffer, int bitmap_width, int bitmap_height, int dpi_x, int dpi_y, bool autorotate) { if (!render_pdf_to_bitmap_func_) return false; return render_pdf_to_bitmap_func_(pdf_buffer, pdf_buffer_size, page_number, bitmap_buffer, bitmap_width, bitmap_height, dpi_x, dpi_y, autorotate); } bool GetPDFDocInfo(const void* pdf_buffer, int buffer_size, int* page_count, double* max_page_width) { if (!get_pdf_doc_info_func_) return false; return get_pdf_doc_info_func_(pdf_buffer, buffer_size, page_count, max_page_width); } protected: virtual bool PlatformInit( const base::FilePath& pdf_module_path, const base::ScopedNativeLibrary& pdf_lib) { return true; } private: // Exported by PDF plugin. typedef bool (*RenderPDFPageToBitmapProc)(const void* pdf_buffer, int pdf_buffer_size, int page_number, void* bitmap_buffer, int bitmap_width, int bitmap_height, int dpi_x, int dpi_y, bool autorotate); typedef bool (*GetPDFDocInfoProc)(const void* pdf_buffer, int buffer_size, int* page_count, double* max_page_width); RenderPDFPageToBitmapProc render_pdf_to_bitmap_func_; GetPDFDocInfoProc get_pdf_doc_info_func_; base::ScopedNativeLibrary pdf_lib_; DISALLOW_COPY_AND_ASSIGN(PdfFunctionsBase); }; #if defined(OS_WIN) // The 2 below IAT patch functions are almost identical to the code in // render_process_impl.cc. This is needed to work around specific Windows APIs // used by the Chrome PDF plugin that will fail in the sandbox. static base::win::IATPatchFunction g_iat_patch_createdca; HDC WINAPI UtilityProcess_CreateDCAPatch(LPCSTR driver_name, LPCSTR device_name, LPCSTR output, const DEVMODEA* init_data) { if (driver_name && (std::string("DISPLAY") == driver_name)) { // CreateDC fails behind the sandbox, but not CreateCompatibleDC. return CreateCompatibleDC(NULL); } NOTREACHED(); return CreateDCA(driver_name, device_name, output, init_data); } static base::win::IATPatchFunction g_iat_patch_get_font_data; DWORD WINAPI UtilityProcess_GetFontDataPatch( HDC hdc, DWORD table, DWORD offset, LPVOID buffer, DWORD length) { int rv = GetFontData(hdc, table, offset, buffer, length); if (rv == GDI_ERROR && hdc) { HFONT font = static_cast<HFONT>(GetCurrentObject(hdc, OBJ_FONT)); LOGFONT logfont; if (GetObject(font, sizeof(LOGFONT), &logfont)) { content::UtilityThread::Get()->PreCacheFont(logfont); rv = GetFontData(hdc, table, offset, buffer, length); content::UtilityThread::Get()->ReleaseCachedFonts(); } } return rv; } class PdfFunctionsWin : public PdfFunctionsBase { public: PdfFunctionsWin() : render_pdf_to_dc_func_(NULL) { } bool PlatformInit( const base::FilePath& pdf_module_path, const base::ScopedNativeLibrary& pdf_lib) OVERRIDE { // Patch the IAT for handling specific APIs known to fail in the sandbox. if (!g_iat_patch_createdca.is_patched()) { g_iat_patch_createdca.Patch(pdf_module_path.value().c_str(), "gdi32.dll", "CreateDCA", UtilityProcess_CreateDCAPatch); } if (!g_iat_patch_get_font_data.is_patched()) { g_iat_patch_get_font_data.Patch(pdf_module_path.value().c_str(), "gdi32.dll", "GetFontData", UtilityProcess_GetFontDataPatch); } render_pdf_to_dc_func_ = reinterpret_cast<RenderPDFPageToDCProc>( pdf_lib.GetFunctionPointer("RenderPDFPageToDC")); LOG_IF(WARNING, !render_pdf_to_dc_func_) << "Missing RenderPDFPageToDC"; return render_pdf_to_dc_func_ != NULL; } bool RenderPDFPageToDC(const void* pdf_buffer, int buffer_size, int page_number, HDC dc, int dpi_x, int dpi_y, int bounds_origin_x, int bounds_origin_y, int bounds_width, int bounds_height, bool fit_to_bounds, bool stretch_to_bounds, bool keep_aspect_ratio, bool center_in_bounds, bool autorotate) { if (!render_pdf_to_dc_func_) return false; return render_pdf_to_dc_func_(pdf_buffer, buffer_size, page_number, dc, dpi_x, dpi_y, bounds_origin_x, bounds_origin_y, bounds_width, bounds_height, fit_to_bounds, stretch_to_bounds, keep_aspect_ratio, center_in_bounds, autorotate); } private: // Exported by PDF plugin. typedef bool (*RenderPDFPageToDCProc)( const void* pdf_buffer, int buffer_size, int page_number, HDC dc, int dpi_x, int dpi_y, int bounds_origin_x, int bounds_origin_y, int bounds_width, int bounds_height, bool fit_to_bounds, bool stretch_to_bounds, bool keep_aspect_ratio, bool center_in_bounds, bool autorotate); RenderPDFPageToDCProc render_pdf_to_dc_func_; DISALLOW_COPY_AND_ASSIGN(PdfFunctionsWin); }; typedef PdfFunctionsWin PdfFunctions; #else // OS_WIN typedef PdfFunctionsBase PdfFunctions; #endif // OS_WIN base::LazyInstance<PdfFunctions> g_pdf_lib = LAZY_INSTANCE_INITIALIZER; } // namespace PrintingHandler::PrintingHandler() {} PrintingHandler::~PrintingHandler() {} // static void PrintingHandler::PreSandboxStartup() { g_pdf_lib.Get().Init(); } bool PrintingHandler::OnMessageReceived(const IPC::Message& message) { bool handled = true; IPC_BEGIN_MESSAGE_MAP(PrintingHandler, message) #if defined(WIN_PDF_METAFILE_FOR_PRINTING) IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafiles, OnRenderPDFPagesToMetafile) #endif IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToPWGRaster, OnRenderPDFPagesToPWGRaster) IPC_MESSAGE_HANDLER(ChromeUtilityMsg_GetPrinterCapsAndDefaults, OnGetPrinterCapsAndDefaults) IPC_MESSAGE_HANDLER(ChromeUtilityMsg_GetPrinterSemanticCapsAndDefaults, OnGetPrinterSemanticCapsAndDefaults) IPC_MESSAGE_UNHANDLED(handled = false) IPC_END_MESSAGE_MAP() return handled; } #if defined(WIN_PDF_METAFILE_FOR_PRINTING) void PrintingHandler::OnRenderPDFPagesToMetafile( IPC::PlatformFileForTransit pdf_transit, const base::FilePath& metafile_path, const printing::PdfRenderSettings& settings, const std::vector<printing::PageRange>& page_ranges_const) { bool succeeded = false; base::File pdf_file = IPC::PlatformFileForTransitToFile(pdf_transit); int highest_rendered_page_number = 0; double scale_factor = 1.0; std::vector<printing::PageRange> page_ranges = page_ranges_const; succeeded = RenderPDFToWinMetafile(pdf_file.Pass(), metafile_path, settings, &page_ranges, &highest_rendered_page_number, &scale_factor); if (succeeded) { // TODO(vitalybuka|scottmg): http://crbug.com/170859. These could // potentially be sent as each page is converted so that the spool could // start sooner. Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_Succeeded( page_ranges, scale_factor)); } else { Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed()); } ReleaseProcessIfNeeded(); } #endif void PrintingHandler::OnRenderPDFPagesToPWGRaster( IPC::PlatformFileForTransit pdf_transit, const printing::PdfRenderSettings& settings, const printing::PwgRasterSettings& bitmap_settings, IPC::PlatformFileForTransit bitmap_transit) { base::File pdf = IPC::PlatformFileForTransitToFile(pdf_transit); base::File bitmap = IPC::PlatformFileForTransitToFile(bitmap_transit); if (RenderPDFPagesToPWGRaster(pdf.Pass(), settings, bitmap_settings, bitmap.Pass())) { Send(new ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Succeeded()); } else { Send(new ChromeUtilityHostMsg_RenderPDFPagesToPWGRaster_Failed()); } ReleaseProcessIfNeeded(); } #if defined(WIN_PDF_METAFILE_FOR_PRINTING) bool PrintingHandler::RenderPDFToWinMetafile( base::File pdf_file, const base::FilePath& metafile_path, const printing::PdfRenderSettings& settings, std::vector<printing::PageRange>* page_ranges, int* highest_rendered_page_number, double* scale_factor) { DCHECK(page_ranges); *highest_rendered_page_number = -1; *scale_factor = 1.0; if (!g_pdf_lib.Get().IsValid()) return false; // TODO(sanjeevr): Add a method to the PDF DLL that takes in a file handle // and a page range array. That way we don't need to read the entire PDF into // memory. int64 length = pdf_file.GetLength(); if (length < 0) return false; std::vector<char> buffer; buffer.resize(length); if (length != pdf_file.Read(0, &buffer.front(), length)) return false; int total_page_count = 0; if (!g_pdf_lib.Get().GetPDFDocInfo(&buffer.front(), buffer.size(), &total_page_count, NULL)) { return false; } // If no range supplied, do all pages. if (page_ranges->empty()) { printing::PageRange page_range_all; page_range_all.from = 0; page_range_all.to = total_page_count - 1; page_ranges->push_back(page_range_all); } bool ret = false; std::vector<printing::PageRange>::const_iterator iter; for (iter = page_ranges->begin(); iter != page_ranges->end(); ++iter) { for (int page_number = iter->from; page_number <= iter->to; ++page_number) { if (page_number >= total_page_count) break; printing::Emf metafile; metafile.InitToFile(metafile_path.InsertBeforeExtensionASCII( base::StringPrintf(".%d", page_number))); // We need to scale down DC to fit an entire page into DC available area. // Current metafile is based on screen DC and have current screen size. // Writing outside of those boundaries will result in the cut-off output. // On metafiles (this is the case here), scaling down will still record // original coordinates and we'll be able to print in full resolution. // Before playback we'll need to counter the scaling up that will happen // in the service (print_system_win.cc). *scale_factor = gfx::CalculatePageScale(metafile.context(), settings.area().right(), settings.area().bottom()); gfx::ScaleDC(metafile.context(), *scale_factor); // The underlying metafile is of type Emf and ignores the arguments passed // to StartPage. metafile.StartPage(gfx::Size(), gfx::Rect(), 1); if (g_pdf_lib.Get().RenderPDFPageToDC( &buffer.front(), buffer.size(), page_number, metafile.context(), settings.dpi(), settings.dpi(), settings.area().x(), settings.area().y(), settings.area().width(), settings.area().height(), true, false, true, true, settings.autorotate())) { if (*highest_rendered_page_number < page_number) *highest_rendered_page_number = page_number; ret = true; } metafile.FinishPage(); metafile.FinishDocument(); } } return ret; } #endif // defined(WIN_PDF_METAFILE_FOR_PRINTING) bool PrintingHandler::RenderPDFPagesToPWGRaster( base::File pdf_file, const printing::PdfRenderSettings& settings, const printing::PwgRasterSettings& bitmap_settings, base::File bitmap_file) { bool autoupdate = true; if (!g_pdf_lib.Get().IsValid()) return false; base::File::Info info; if (!pdf_file.GetInfo(&info) || info.size <= 0) return false; std::string data(info.size, 0); int data_size = pdf_file.Read(0, &data[0], data.size()); if (data_size != static_cast<int>(data.size())) return false; int total_page_count = 0; if (!g_pdf_lib.Get().GetPDFDocInfo(data.data(), data.size(), &total_page_count, NULL)) { return false; } cloud_print::PwgEncoder encoder; std::string pwg_header; encoder.EncodeDocumentHeader(&pwg_header); int bytes_written = bitmap_file.WriteAtCurrentPos(pwg_header.data(), pwg_header.size()); if (bytes_written != static_cast<int>(pwg_header.size())) return false; cloud_print::BitmapImage image(settings.area().size(), cloud_print::BitmapImage::BGRA); for (int i = 0; i < total_page_count; ++i) { int page_number = i; if (bitmap_settings.reverse_page_order) { page_number = total_page_count - 1 - page_number; } if (!g_pdf_lib.Get().RenderPDFPageToBitmap(data.data(), data.size(), page_number, image.pixel_data(), image.size().width(), image.size().height(), settings.dpi(), settings.dpi(), autoupdate)) { return false; } cloud_print::PwgHeaderInfo header_info; header_info.dpi = settings.dpi(); header_info.total_pages = total_page_count; // Transform odd pages. if (page_number % 2) { switch (bitmap_settings.odd_page_transform) { case printing::TRANSFORM_NORMAL: break; case printing::TRANSFORM_ROTATE_180: header_info.flipx = true; header_info.flipy = true; break; case printing::TRANSFORM_FLIP_HORIZONTAL: header_info.flipx = true; break; case printing::TRANSFORM_FLIP_VERTICAL: header_info.flipy = true; break; } } if (bitmap_settings.rotate_all_pages) { header_info.flipx = !header_info.flipx; header_info.flipy = !header_info.flipy; } std::string pwg_page; if (!encoder.EncodePage(image, header_info, &pwg_page)) return false; bytes_written = bitmap_file.WriteAtCurrentPos(pwg_page.data(), pwg_page.size()); if (bytes_written != static_cast<int>(pwg_page.size())) return false; } return true; } void PrintingHandler::OnGetPrinterCapsAndDefaults( const std::string& printer_name) { scoped_refptr<printing::PrintBackend> print_backend = printing::PrintBackend::CreateInstance(NULL); printing::PrinterCapsAndDefaults printer_info; crash_keys::ScopedPrinterInfo crash_key( print_backend->GetPrinterDriverInfo(printer_name)); if (print_backend->GetPrinterCapsAndDefaults(printer_name, &printer_info)) { Send(new ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Succeeded( printer_name, printer_info)); } else { Send(new ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Failed( printer_name)); } ReleaseProcessIfNeeded(); } void PrintingHandler::OnGetPrinterSemanticCapsAndDefaults( const std::string& printer_name) { scoped_refptr<printing::PrintBackend> print_backend = printing::PrintBackend::CreateInstance(NULL); printing::PrinterSemanticCapsAndDefaults printer_info; crash_keys::ScopedPrinterInfo crash_key( print_backend->GetPrinterDriverInfo(printer_name)); if (print_backend->GetPrinterSemanticCapsAndDefaults(printer_name, &printer_info)) { Send(new ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Succeeded( printer_name, printer_info)); } else { Send(new ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Failed( printer_name)); } ReleaseProcessIfNeeded(); }