Printing on Windows via PDF

chrome/service/service_utility_process_host.cc

 // Copyright (c) 2012 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/service/service_utility_process_host.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 89 matching lines @@
   start_time_ = base::Time::Now();
 #if !defined(OS_WIN)
   // This is only implemented on Windows (because currently it is only needed
   // on Windows). Will add implementations on other platforms when needed.
   NOTIMPLEMENTED();
   return false;
 #else  // !defined(OS_WIN)
   scratch_metafile_dir_.reset(new base::ScopedTempDir);
   if (!scratch_metafile_dir_->CreateUniqueTempDir())
     return false;
-  if (!base::CreateTemporaryFileInDir(scratch_metafile_dir_->path(),
-                                      &metafile_path_)) {
-    return false;
-  }
-
+  metafile_path_ = scratch_metafile_dir_->path().AppendASCII("output.emf");
   if (!StartProcess(false, scratch_metafile_dir_->path()))
     return false;
 
-  base::win::ScopedHandle pdf_file(
-      ::CreateFile(pdf_path.value().c_str(),
-                   GENERIC_READ,
-                   FILE_SHARE_READ | FILE_SHARE_WRITE,
-                   NULL,
-                   OPEN_EXISTING,
-                   FILE_ATTRIBUTE_NORMAL,
-                   NULL));
-  if (pdf_file == INVALID_HANDLE_VALUE)
-    return false;
-  HANDLE pdf_file_in_utility_process = NULL;
-  ::DuplicateHandle(::GetCurrentProcess(), pdf_file, handle(),
-                    &pdf_file_in_utility_process, 0, false,
-                    DUPLICATE_SAME_ACCESS);
-  if (!pdf_file_in_utility_process)
-    return false;
+  base::File pdf_file(
+      pdf_path,
+      base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE);
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
   return child_process_host_->Send(
-      new ChromeUtilityMsg_RenderPDFPagesToMetafile(
-          pdf_file_in_utility_process,
+      new ChromeUtilityMsg_RenderPDFPagesToMetafiles(
+          IPC::TakeFileHandleForProcess(pdf_file.Pass(), handle()),
           metafile_path_,
           render_settings,
           page_ranges));
 #endif  // !defined(OS_WIN)
 }
 
 bool ServiceUtilityProcessHost::StartGetPrinterCapsAndDefaults(
     const std::string& printer_name) {
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
                             SERVICE_UTILITY_CAPS_REQUEST,
@@ skipping 92 matching lines @@
     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityDisconnectTime",
                         base::Time::Now() - start_time_);
   }
   delete this;
 }
 
 bool ServiceUtilityProcessHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceUtilityProcessHost, message)
     IPC_MESSAGE_HANDLER(
-        ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded,
-        OnRenderPDFPagesToMetafileSucceeded)
+        ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_Succeeded,
+        OnRenderPDFPagesToMetafilesSucceeded)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed,
                         OnRenderPDFPagesToMetafileFailed)
     IPC_MESSAGE_HANDLER(
         ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Succeeded,
         OnGetPrinterCapsAndDefaultsSucceeded)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Failed,
                         OnGetPrinterCapsAndDefaultsFailed)
     IPC_MESSAGE_HANDLER(
         ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Succeeded,
         OnGetPrinterSemanticCapsAndDefaultsSucceeded)
     IPC_MESSAGE_HANDLER(
         ChromeUtilityHostMsg_GetPrinterSemanticCapsAndDefaults_Failed,
         OnGetPrinterSemanticCapsAndDefaultsFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 base::ProcessHandle ServiceUtilityProcessHost::GetHandle() const {
   return handle_;
 }
 
-void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafileSucceeded(
-    int highest_rendered_page_number,
+void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesSucceeded(
+    const std::vector<printing::PageRange>& page_ranges,
     double scale_factor) {
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
                             SERVICE_UTILITY_METAFILE_SUCCEEDED,
                             SERVICE_UTILITY_EVENT_MAX);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileTime",
                       base::Time::Now() - start_time_);
   DCHECK(waiting_for_reply_);
   waiting_for_reply_ = false;
   // If the metafile was successfully created, we need to take our hands off the
   // scratch metafile directory. The client will delete it when it is done with
   // metafile.
   scratch_metafile_dir_->Take();
+
+  // TODO(vitalybuka|scottmg): http://crbug.com/170859: Currently, only one
+  // page is printed at a time. This would need to be refactored to change
+  // this.
+  CHECK_EQ(1u, page_ranges.size());
+  CHECK_EQ(page_ranges[0].from, page_ranges[0].to);
+  int page_number = page_ranges[0].from;
   client_message_loop_proxy_->PostTask(
       FROM_HERE,
-      base::Bind(&Client::MetafileAvailable, client_.get(), metafile_path_,
-                 highest_rendered_page_number, scale_factor));
+      base::Bind(&Client::MetafileAvailable,
+                 client_.get(),
+                 metafile_path_.InsertBeforeExtensionASCII(
+                     base::StringPrintf(".%d", page_number)),
+                 page_number,
+                 scale_factor));
 }
 
 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafileFailed() {
   DCHECK(waiting_for_reply_);
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
                             SERVICE_UTILITY_METAFILE_FAILED,
                             SERVICE_UTILITY_EVENT_MAX);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileFailTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
@@ skipping 82 matching lines @@
   if (!metafile.InitFromFile(metafile_path)) {
     OnRenderPDFPagesToMetafileFailed();
   } else {
     OnRenderPDFPagesToMetafileSucceeded(metafile,
                                         highest_rendered_page_number,
                                         scale_factor);
   }
 #endif  // defined(OS_WIN)
 }