Cloud Print Proxy: Delete print jobs.

chrome/service/cloud_print/print_system_win.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/cloud_print/print_system.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 17 matching lines @@
 #include "printing/emf_win.h"
 #include "printing/page_range.h"
 #include "printing/pdf_render_settings.h"
 #include "printing/printing_utils.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace cloud_print {
 
 namespace {
 
+bool CurrentlyOnServiceIOThread() {
+  return g_service_process->io_task_runner()->BelongsToCurrentThread();
+}
+
+bool PostIOThreadTask(const tracked_objects::Location& from_here,
+                      const base::Closure& task) {
+  return g_service_process->io_task_runner()->PostTask(from_here, task);
+}
+
 class PrintSystemWatcherWin : public base::win::ObjectWatcher::Delegate {
  public:
   PrintSystemWatcherWin()
       : delegate_(NULL) {
   }
   ~PrintSystemWatcherWin() override { Stop(); }
 
   class Delegate {
    public:
     virtual ~Delegate() {}
@@ skipping 205 matching lines @@
                const base::FilePath& print_data_file_path,
                const std::string& print_data_mime_type,
                const std::string& printer_name,
                const std::string& job_title,
                JobSpooler::Delegate* delegate) {
       if (delegate_) {
         // We are already in the process of printing.
         NOTREACHED();
         return false;
       }
-      base::string16 printer_wide = base::UTF8ToWide(printer_name);
+
       // We only support PDF and XPS documents for now.
       if (print_data_mime_type == kContentTypePDF) {
+        base::string16 printer_wide = base::UTF8ToWide(printer_name);
         std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode;
         if (print_ticket_mime_type == kContentTypeJSON) {
           dev_mode = CjtToDevMode(printer_wide, print_ticket);
         } else {
-          DCHECK(print_ticket_mime_type == kContentTypeXML);
+          DCHECK_EQ(kContentTypeXML, print_ticket_mime_type);
           dev_mode = printing::XpsTicketToDevMode(printer_wide, print_ticket);
         }
 
         if (!dev_mode) {
           NOTREACHED();
           return false;
         }
 
         HDC dc = CreateDC(L"WINSPOOL", printer_wide.c_str(), NULL,
                           dev_mode.get());
         if (!dc) {
           NOTREACHED();
           return false;
         }
         DOCINFO di = {0};
         di.cbSize = sizeof(DOCINFO);
         base::string16 doc_name = base::UTF8ToUTF16(job_title);
         DCHECK(printing::SimplifyDocumentTitle(doc_name) == doc_name);
         di.lpszDocName = doc_name.c_str();
         job_id_ = StartDoc(dc, &di);
         if (job_id_ <= 0)
           return false;
 
         printer_dc_.Set(dc);
         saved_dc_ = SaveDC(printer_dc_.Get());
-        print_data_file_path_ = print_data_file_path;
         delegate_ = delegate;
-        RenderPDFPages();
-      } else if (print_data_mime_type == kContentTypeXPS) {
+        RenderPDFPages(print_data_file_path);
+        return true;
+      }
+
+      if (print_data_mime_type == kContentTypeXPS) {
         DCHECK(print_ticket_mime_type == kContentTypeXML);
         bool ret = PrintXPSDocument(printer_name,
                                     job_title,
                                     print_data_file_path,
                                     print_ticket);
         if (ret)
           delegate_ = delegate;
         return ret;
-      } else {
-        NOTREACHED();
-        return false;
       }
-      return true;
+
+      NOTREACHED();
+      return false;
     }
 
     void PreparePageDCForPrinting(HDC, float scale_factor) {
       SetGraphicsMode(printer_dc_.Get(), GM_ADVANCED);
       // Setup the matrix to translate and scale to the right place. Take in
       // account the scale factor.
       // Note that the printing output is relative to printable area of
       // the page. That is 0,0 is offset by PHYSICALOFFSETX/Y from the page.
       int offset_x = ::GetDeviceCaps(printer_dc_.Get(), PHYSICALOFFSETX);
       int offset_y = ::GetDeviceCaps(printer_dc_.Get(), PHYSICALOFFSETY);
@@ skipping 78 matching lines @@
       RestoreDC(printer_dc_.Get(), saved_dc_);
       EndDoc(printer_dc_.Get());
       if (success) {
         delegate_->OnJobSpoolSucceeded(job_id_);
       } else {
         delegate_->OnJobSpoolFailed();
       }
       delegate_ = NULL;
     }
 
-    void RenderPDFPages() {
+    void RenderPDFPages(const base::FilePath& pdf_path) {
       int printer_dpi = ::GetDeviceCaps(printer_dc_.Get(), LOGPIXELSX);
       int dc_width = GetDeviceCaps(printer_dc_.Get(), PHYSICALWIDTH);
       int dc_height = GetDeviceCaps(printer_dc_.Get(), PHYSICALHEIGHT);
       gfx::Rect render_area(0, 0, dc_width, dc_height);
-      g_service_process->io_task_runner()->PostTask(
-          FROM_HERE,
-          base::Bind(&JobSpoolerWin::Core::RenderPDFPagesInSandbox, this,
-                     print_data_file_path_, render_area, printer_dpi,
-                     base::ThreadTaskRunnerHandle::Get()));
+      PostIOThreadTask(FROM_HERE,
+                       base::Bind(&JobSpoolerWin::Core::RenderPDFPagesInSandbox,
+                                  this, pdf_path, render_area, printer_dpi,
+                                  base::ThreadTaskRunnerHandle::Get()));
     }
 
-    // Called on the service process IO thread.
     void RenderPDFPagesInSandbox(
         const base::FilePath& pdf_path,
         const gfx::Rect& render_area,
         int render_dpi,
         const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner) {
-      DCHECK(g_service_process->io_task_runner()->BelongsToCurrentThread());
+      DCHECK(CurrentlyOnServiceIOThread());
       std::unique_ptr<ServiceUtilityProcessHost> utility_host(
           new ServiceUtilityProcessHost(this, client_task_runner.get()));
       // TODO(gene): For now we disabling autorotation for CloudPrinting.
       // Landscape/Portrait setting is passed in the print ticket and
       // server is generating portrait PDF always.
       // We should enable autorotation once server will be able to generate
       // PDF that matches paper size and orientation.
       if (utility_host->StartRenderPDFPagesToMetafile(
               pdf_path,
               printing::PdfRenderSettings(render_area, render_dpi, false))) {
         // The object will self-destruct when the child process dies.
         ignore_result(utility_host.release());
       } else {
         client_task_runner->PostTask(
             FROM_HERE, base::Bind(&Core::PrintJobDone, this, false));
       }
     }
 
     bool PrintXPSDocument(const std::string& printer_name,
                           const std::string& job_title,
-                          const base::FilePath& print_data_file_path,
+                          const base::FilePath& xps_path,
                           const std::string& print_ticket) {
+      base::File xps_file(xps_path, base::File::FLAG_OPEN |
+                                        base::File::FLAG_READ |
+                                        base::File::FLAG_DELETE_ON_CLOSE);
       if (!printing::XPSPrintModule::Init())
         return false;
 
-      job_progress_event_.Set(CreateEvent(NULL, TRUE, FALSE, NULL));
+      job_progress_event_.Set(CreateEvent(nullptr, TRUE, FALSE, nullptr));
       if (!job_progress_event_.Get())
         return false;
 
       PrintJobCanceler job_canceler(&xps_print_job_);
       base::win::ScopedComPtr<IXpsPrintJobStream> doc_stream;
       base::win::ScopedComPtr<IXpsPrintJobStream> print_ticket_stream;
       if (FAILED(printing::XPSPrintModule::StartXpsPrintJob(
               base::UTF8ToWide(printer_name).c_str(),
-              base::UTF8ToWide(job_title).c_str(),
-              NULL, job_progress_event_.Get(), NULL, NULL, NULL,
+              base::UTF8ToWide(job_title).c_str(), nullptr,
+              job_progress_event_.Get(), nullptr, nullptr, 0,
               xps_print_job_.Receive(), doc_stream.Receive(),
-              print_ticket_stream.Receive())))
+              print_ticket_stream.Receive()))) {
         return false;
+      }
 
       ULONG print_bytes_written = 0;
       if (FAILED(print_ticket_stream->Write(print_ticket.c_str(),
                                             print_ticket.length(),
-                                            &print_bytes_written)))
+                                            &print_bytes_written))) {
         return false;
+      }
       DCHECK_EQ(print_ticket.length(), print_bytes_written);
       if (FAILED(print_ticket_stream->Close()))
         return false;
 
-      std::string document_data;
-      base::ReadFileToString(print_data_file_path, &document_data);
+      int64_t file_size = xps_file.GetLength();
+      if (file_size <= 0)
+        return false;
+
+      std::unique_ptr<char[]> document_data(new char[file_size]);
+      int bytes_read = xps_file.Read(0, document_data.get(), file_size);
+      if (bytes_read != file_size)
+        return false;
+
       ULONG doc_bytes_written = 0;
-      if (FAILED(doc_stream->Write(document_data.c_str(),
-                                    document_data.length(),
-                                    &doc_bytes_written)))
+      if (FAILED(doc_stream->Write(document_data.get(), file_size,
+                                   &doc_bytes_written))) {
         return false;
-      DCHECK_EQ(document_data.length(), doc_bytes_written);
+      }
+      DCHECK_EQ(file_size, doc_bytes_written);
       if (FAILED(doc_stream->Close()))
         return false;
 
-      job_progress_watcher_.StartWatchingOnce(
-          job_progress_event_.Get(), this);
+      job_progress_watcher_.StartWatchingOnce(job_progress_event_.Get(), this);
       job_canceler.reset();
       return true;
     }
 
     PlatformJobId job_id_;
     PrintSystem::JobSpooler::Delegate* delegate_;
     int saved_dc_;
     base::win::ScopedCreateDC printer_dc_;
-    base::FilePath print_data_file_path_;
     base::win::ScopedHandle job_progress_event_;
     base::win::ObjectWatcher job_progress_watcher_;
     base::win::ScopedComPtr<IXpsPrintJob> xps_print_job_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(JobSpoolerWin);
 };
@@ skipping 37 matching lines @@
             *description, base::JSONWriter::OPTIONS_PRETTY_PRINT,
             &printer_info.printer_capabilities);
       }
     }
     callback_.Run(succeeded, printer_name, printer_info);
     callback_.Reset();
     Release();
   }
 
   void StartGetPrinterCapsAndDefaults() {
-    g_service_process->io_task_runner()->PostTask(
+    PostIOThreadTask(
         FROM_HERE,
         base::Bind(&PrinterCapsHandler::GetPrinterCapsAndDefaultsImpl, this,
                    base::ThreadTaskRunnerHandle::Get()));
   }
 
   void StartGetPrinterSemanticCapsAndDefaults() {
-    g_service_process->io_task_runner()->PostTask(
+    PostIOThreadTask(
         FROM_HERE,
         base::Bind(&PrinterCapsHandler::GetPrinterSemanticCapsAndDefaultsImpl,
                    this, base::ThreadTaskRunnerHandle::Get()));
   }
 
  private:
   ~PrinterCapsHandler() override {}
 
   void GetPrinterCapsAndDefaultsImpl(
       const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner) {
-    DCHECK(g_service_process->io_task_runner()->BelongsToCurrentThread());
+    DCHECK(CurrentlyOnServiceIOThread());
     std::unique_ptr<ServiceUtilityProcessHost> utility_host(
         new ServiceUtilityProcessHost(this, client_task_runner.get()));
     if (utility_host->StartGetPrinterCapsAndDefaults(printer_name_)) {
       // The object will self-destruct when the child process dies.
       ignore_result(utility_host.release());
     } else {
       client_task_runner->PostTask(
           FROM_HERE, base::Bind(&PrinterCapsHandler::OnChildDied, this));
     }
   }
 
   void GetPrinterSemanticCapsAndDefaultsImpl(
       const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner) {
-    DCHECK(g_service_process->io_task_runner()->BelongsToCurrentThread());
+    DCHECK(CurrentlyOnServiceIOThread());
     std::unique_ptr<ServiceUtilityProcessHost> utility_host(
         new ServiceUtilityProcessHost(this, client_task_runner.get()));
     if (utility_host->StartGetPrinterSemanticCapsAndDefaults(printer_name_)) {
       // The object will self-destruct when the child process dies.
       ignore_result(utility_host.release());
     } else {
       client_task_runner->PostTask(
           FROM_HERE, base::Bind(&PrinterCapsHandler::OnChildDied, this));
     }
   }
@@ skipping 212 matching lines @@
 }
 
 }  // namespace
 
 scoped_refptr<PrintSystem> PrintSystem::CreateInstance(
     const base::DictionaryValue* print_system_settings) {
   return new PrintSystemWin;
 }
 
 }  // namespace cloud_print