Change PDF scaling factor from double to float.

chrome/utility/printing_handler.cc

 // 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/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/scoped_native_library.h"
@@ skipping 277 matching lines @@
   base::File pdf_file = IPC::PlatformFileForTransitToFile(pdf_transit);
   int page_count = LoadPDF(pdf_file.Pass());
   Send(
       new ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageCount(page_count));
 }
 
 void PrintingHandler::OnRenderPDFPagesToMetafileGetPage(
     int page_number,
     IPC::PlatformFileForTransit output_file) {
   base::File emf_file = IPC::PlatformFileForTransitToFile(output_file);
-  double scale_factor = 1.0;
+  float scale_factor = 1.0f;
   bool success =
       RenderPdfPageToMetafile(page_number, emf_file.Pass(), &scale_factor);
   Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageDone(
       success, scale_factor));
 }
 
 void PrintingHandler::OnRenderPDFPagesToMetafileStop() {
   ReleaseProcessIfNeeded();
 }
 
@@ skipping 15 matching lines @@
   }
   ReleaseProcessIfNeeded();
 }
 #endif  // ENABLE_FULL_PRINTING
 
 #if defined(OS_WIN)
 int PrintingHandler::LoadPDF(base::File pdf_file) {
   if (!g_pdf_lib.Get().IsValid())
     return 0;
 
-  int64 length = pdf_file.GetLength();
-  if (length < 0)
+  int64 length64 = pdf_file.GetLength();
+  if (length64 < 0 || length64 > std::numeric_limits<int>::max())

[Peter Kasting, 2014/10/08 22:57:07]

I'm not sure if GetLength() can return >= 2^32, but if it's worth checking for
<0, maybe it's worth checking for this also?  I'll happily remove the
conditional if we know for sure it's unnecessary.

     return 0;
+  int length = static_cast<int>(length64);
 
   pdf_data_.resize(length);
   if (length != pdf_file.Read(0, pdf_data_.data(), pdf_data_.size()))
     return 0;
 
   int total_page_count = 0;
   if (!g_pdf_lib.Get().GetPDFDocInfo(
           &pdf_data_.front(), pdf_data_.size(), &total_page_count, NULL)) {
     return 0;
   }
   return total_page_count;
 }
 
 bool PrintingHandler::RenderPdfPageToMetafile(int page_number,
                                               base::File output_file,
-                                              double* scale_factor) {
+                                              float* scale_factor) {
   printing::Emf metafile;
   metafile.Init();
 
   // 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).
@@ skipping 35 matching lines @@
 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)
+  if (!pdf_file.GetInfo(&info) || info.size <= 0 ||
+      info.size > std::numeric_limits<int>::max())

[Peter Kasting, 2014/10/08 22:57:07]

Similarly, I don't know whether this check is necessary, but it looks like it
might be.

[sky, 2014/10/08 23:41:36]

These checks seem good to me, but I'm not familiar with this code. Is one of the
other reviewers more knowledgeable?

     return false;
+  int data_size = static_cast<int>(info.size);
 
-  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()))
+  std::string data(data_size, 0);
+  if (pdf_file.Read(0, &data[0], data_size) != data_size)
     return false;
 
   int total_page_count = 0;
-  if (!g_pdf_lib.Get().GetPDFDocInfo(data.data(), data.size(),
+  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(),
+                                               data_size,
                                                page_number,
                                                image.pixel_data(),
                                                image.size().width(),
                                                image.size().height(),
                                                settings.dpi(),
                                                settings.dpi(),
                                                autoupdate)) {
       return false;
     }
 
@@ skipping 67 matching lines @@
                                                        &printer_info)) {
     Send(new ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Succeeded(
         printer_name, printer_info));
   } else {
     Send(new ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Failed(
         printer_name));
   }
   ReleaseProcessIfNeeded();
 }
 #endif  // ENABLE_FULL_PRINTING