Added autorotate flag in PDF rendering and wiring it through service-utility channel.

chrome/utility/chrome_content_utility_client.cc

 // Copyright (c) 2011 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/chrome_content_utility_client.h"
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/threading/thread.h"
@@ skipping 153 matching lines @@
   for (size_t i = 0; i < decoded_string.size(); ++i) {
     decoded_vector[i] = static_cast<unsigned char>(decoded_string[i]);
   }
 
   OnDecodeImage(decoded_vector);
 }
 
 void ChromeContentUtilityClient::OnRenderPDFPagesToMetafile(
     base::PlatformFile pdf_file,
     const FilePath& metafile_path,
-    const gfx::Rect& render_area,
-    int render_dpi,
+    const printing::PdfRenderSettings& pdf_render_settings,
     const std::vector<printing::PageRange>& page_ranges) {
   bool succeeded = false;
 #if defined(OS_WIN)
   int highest_rendered_page_number = 0;
   succeeded = RenderPDFToWinMetafile(pdf_file,
                                      metafile_path,
-                                     render_area,
-                                     render_dpi,
+                                     pdf_render_settings.area(),
+                                     pdf_render_settings.dpi(),
+                                     pdf_render_settings.autorotate(),
                                      page_ranges,
                                      &highest_rendered_page_number);
   if (succeeded) {
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(
         highest_rendered_page_number));
   }
 #endif  // defined(OS_WIN)
   if (!succeeded) {
     Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed());
   }
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 #if defined(OS_WIN)
 // Exported by pdf.dll
 typedef bool (*RenderPDFPageToDCProc)(
     const unsigned char* 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 stretch_to_bounds, bool keep_aspect_ratio, bool center_in_bounds,
+    bool autorotate);
 
 typedef bool (*GetPDFDocInfoProc)(const unsigned char* pdf_buffer,
                                   int buffer_size, int* page_count,
                                   double* max_page_width);
 
 // 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,
@@ skipping 28 matching lines @@
     }
   }
   return rv;
 }
 
 bool ChromeContentUtilityClient::RenderPDFToWinMetafile(
     base::PlatformFile pdf_file,
     const FilePath& metafile_path,
     const gfx::Rect& render_area,
     int render_dpi,
+    bool autorotate,
     const std::vector<printing::PageRange>& page_ranges,
     int* highest_rendered_page_number) {
   *highest_rendered_page_number = -1;
   base::win::ScopedHandle file(pdf_file);
   FilePath pdf_module_path;
   PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_module_path);
   HMODULE pdf_module = GetModuleHandle(pdf_module_path.value().c_str());
   if (!pdf_module)
     return false;
 
@@ skipping 54 matching lines @@
   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;
       // The underlying metafile is of type Emf and ignores the arguments passed
       // to StartPage.
       metafile.StartPage(gfx::Size(), gfx::Rect(), 1);
       if (render_proc(&buffer.front(), buffer.size(), page_number,
                       metafile.context(), render_dpi, render_dpi,
                       render_area.x(), render_area.y(), render_area.width(),
-                      render_area.height(), true, false, true, true))
+                      render_area.height(), true, false, true, true,
+                      autorotate))
         if (*highest_rendered_page_number < page_number)
           *highest_rendered_page_number = page_number;
         ret = true;
       metafile.FinishPage();
     }
   }
   metafile.FinishDocument();
   return ret;
 }
 #endif  // defined(OS_WIN)
@@ skipping 74 matching lines @@
 
 void ChromeContentUtilityClient::ImporterCleanup() {
   importer_->Cancel();
   importer_ = NULL;
   bridge_ = NULL;
   import_thread_.reset();
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 }  // namespace chrome