Add Postscript Printing

chrome/browser/printing/pdf_to_emf_converter.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/browser/printing/pdf_to_emf_converter.h"
 
 #include <stdint.h>
 #include <windows.h>
 
 #include <memory>
@@ skipping 73 matching lines @@
  private:
   mutable scoped_refptr<RefCountedTempDir> temp_dir_;
   mutable ScopedTempFile file_;  // Mutable because of consts in base class.
 
   bool GetDataAsVector(std::vector<char>* buffer) const override;
   bool SaveTo(base::File* file) const override;
 
   DISALLOW_COPY_AND_ASSIGN(LazyEmf);
 };
 
+// Postscript metafile subclass to override SafePlayback.
+class PostScriptMetaFile : public LazyEmf {
+ public:
+  PostScriptMetaFile(const scoped_refptr<RefCountedTempDir>& temp_dir,
+                     ScopedTempFile file)
+      : LazyEmf(temp_dir, std::move(file)) {}
+  ~PostScriptMetaFile() override;
+
+ protected:
+  // MetafilePlayer:
+  bool SafePlayback(HDC hdc) const override;
+
+  DISALLOW_COPY_AND_ASSIGN(PostScriptMetaFile);
+};
+
 // Class for converting PDF to another format for printing (Emf, Postscript).
 // Class uses 3 threads: UI, IO and FILE.
 // Internal workflow is following:
 // 1. Create instance on the UI thread. (files_, settings_,)
 // 2. Create pdf file on the FILE thread.
 // 3. Start utility process and start conversion on the IO thread.
 // 4. Utility process returns page count.
 // 5. For each page:
 //   1. Clients requests page with file handle to a temp file.
 //   2. Utility converts the page, save it to the file and reply.
@@ skipping 49 matching lines @@
     int page_number_;
 
     PdfConverter::GetPageCallback callback_;
     ScopedTempFile file_;
 
     DISALLOW_COPY_AND_ASSIGN(GetPageCallbackData);
   };
 
   ~PdfConverterUtilityProcessHostClient() override;
 
+  bool OnMessageReceived(const IPC::Message& message) override;
+
   // Helper functions: must be overridden by subclasses
   // Set the process name
-  virtual base::string16 GetName() const = 0;
+  virtual base::string16 GetName() const;
   // Create a metafileplayer subclass file from a temporary file.
   virtual std::unique_ptr<MetafilePlayer> GetFileFromTemp(
       std::unique_ptr<base::File, content::BrowserThread::DeleteOnFileThread>
-          temp_file) = 0;
+          temp_file);
   // Send the messages to Start, GetPage, and Stop.
-  virtual void SendStartMessage(IPC::PlatformFileForTransit transit) = 0;
+  virtual void SendStartMessage(IPC::PlatformFileForTransit transit);
   virtual void SendGetPageMessage(int page_number,
-                                  IPC::PlatformFileForTransit transit) = 0;
-  virtual void SendStopMessage() = 0;
+                                  IPC::PlatformFileForTransit transit);
+  virtual void SendStopMessage();
 
   // Message handlers:
   void OnPageCount(int page_count);
   void OnPageDone(bool success, float scale_factor);
 
   void OnFailed();
   void OnTempPdfReady(ScopedTempFile pdf);
   void OnTempFileReady(GetPageCallbackData* callback_data,
                        ScopedTempFile temp_file);
 
+  // Additional message handler needed for Pdf to Emf
+  void OnPreCacheFontCharacters(const LOGFONT& log_font,
+                                const base::string16& characters);
+
   scoped_refptr<RefCountedTempDir> temp_dir_;
 
   // Used to suppress callbacks after PdfConverter is deleted.
   base::WeakPtr<PdfConverterImpl> converter_;
   PdfRenderSettings settings_;
 
   // Document loaded callback.
   PdfConverter::StartCallback start_callback_;
 
   // Process host for IPC.
   base::WeakPtr<content::UtilityProcessHost> utility_process_host_;
 
   // Queue of callbacks for GetPage() requests. Utility process should reply
   // with PageDone in the same order as requests were received.
   // Use containers that keeps element pointers valid after push() and pop().
   using GetPageCallbacks = std::queue<GetPageCallbackData>;
   GetPageCallbacks get_page_callbacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(PdfConverterUtilityProcessHostClient);
 };
 
-// Converts PDF into Emf.
-class PdfToEmfUtilityProcessHostClient
-    : public PdfConverterUtilityProcessHostClient {
- public:
-  PdfToEmfUtilityProcessHostClient(base::WeakPtr<PdfConverterImpl> converter,
-                                   const PdfRenderSettings& settings)
-      : PdfConverterUtilityProcessHostClient(converter, settings) {}
-
-  bool OnMessageReceived(const IPC::Message& message) override;
-
- private:
-  ~PdfToEmfUtilityProcessHostClient() override;
-  // Helpers to send messages and set process name
-  base::string16 GetName() const override;
-  std::unique_ptr<MetafilePlayer> GetFileFromTemp(
-      std::unique_ptr<base::File, content::BrowserThread::DeleteOnFileThread>
-          temp_file) override;
-  void SendStartMessage(IPC::PlatformFileForTransit transit) override;
-  void SendGetPageMessage(int page_number,
-                          IPC::PlatformFileForTransit transit) override;
-  void SendStopMessage() override;
-
-  // Additional message handler needed for Pdf to Emf
-  void OnPreCacheFontCharacters(const LOGFONT& log_font,
-                                const base::string16& characters);
-
-  DISALLOW_COPY_AND_ASSIGN(PdfToEmfUtilityProcessHostClient);
-};
+std::unique_ptr<MetafilePlayer>
+PdfConverterUtilityProcessHostClient::GetFileFromTemp(
+  std::unique_ptr<base::File, content::BrowserThread::DeleteOnFileThread>
+      temp_file) {
+  if (settings_.mode == PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2 ||
+      settings_.mode == PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3) {
+    return base::MakeUnique<PostScriptMetaFile>(temp_dir_,
+                                                std::move(temp_file));
+  }
+  return base::MakeUnique<LazyEmf>(temp_dir_, std::move(temp_file));
+}
 
 class PdfConverterImpl : public PdfConverter {
  public:
   PdfConverterImpl();
 
   ~PdfConverterImpl() override;
 
+  base::WeakPtr<PdfConverterImpl> GetWeakPtr() {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
              const PdfRenderSettings& conversion_settings,
-             const StartCallback& start_callback) override;
+             const StartCallback& start_callback);
 
   void GetPage(int page_number,
                const GetPageCallback& get_page_callback) override;
 
   // Helps to cancel callbacks if this object is destroyed.
   void RunCallback(const base::Closure& callback);
 
- protected:
+  void Start(
+      const scoped_refptr<PdfConverterUtilityProcessHostClient>& utility_client,
+      const scoped_refptr<base::RefCountedMemory>& data,
+      const StartCallback& start_callback);
+
+ private:
   scoped_refptr<PdfConverterUtilityProcessHostClient> utility_client_;
 
- private:
+  base::WeakPtrFactory<PdfConverterImpl> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(PdfConverterImpl);
 };
 
-class PdfToEmfConverterImpl : public PdfConverterImpl {
- public:
-  PdfToEmfConverterImpl();
-
-  ~PdfToEmfConverterImpl() override;
-
-  void Start(const scoped_refptr<base::RefCountedMemory>& data,
-             const PdfRenderSettings& conversion_settings,
-             const StartCallback& start_callback) override;
-
- private:
-  base::WeakPtrFactory<PdfToEmfConverterImpl> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(PdfToEmfConverterImpl);
-};
-
 ScopedTempFile CreateTempFile(scoped_refptr<RefCountedTempDir>* temp_dir) {
   if (!temp_dir->get())
     *temp_dir = new RefCountedTempDir();
   ScopedTempFile file;
   if (!(*temp_dir)->IsValid())
     return file;
   base::FilePath path;
   if (!base::CreateTemporaryFileInDir((*temp_dir)->GetPath(), &path)) {
     PLOG(ERROR) << "Failed to create file in "
                 << (*temp_dir)->GetPath().value();
@@ skipping 58 matching lines @@
   file_->Seek(base::File::FROM_BEGIN, 0);
   int64_t size = file_->GetLength();
   if (size <= 0)
     return false;
   std::vector<char> data(size);
   if (file_->ReadAtCurrentPos(data.data(), data.size()) != size)
     return false;
   return emf->InitFromData(data.data(), data.size());
 }
 
+PostScriptMetaFile::~PostScriptMetaFile() {
+}
+
+bool PostScriptMetaFile::SafePlayback(HDC hdc) const {
+  // TODO(thestig): Fix destruction of metafiles. For some reasons
+  // instances of Emf are not deleted. https://crbug.com/260806
+  // It's known that the Emf going to be played just once to a printer. So just
+  // release |file_| before returning.
+  Emf emf;
+  if (!LoadEmf(&emf)) {
+    Close();
+    return false;
+  }
+
+  {
+    // Ensure enumerator destruction before calling Close() below.
+    Emf::Enumerator emf_enum(emf, nullptr, nullptr);
+    for (const Emf::Record& record : emf_enum) {
+      auto* emf_record = record.record();
+      if (emf_record->iType != EMR_GDICOMMENT)
+        continue;
+
+      const EMRGDICOMMENT* comment =
+          reinterpret_cast<const EMRGDICOMMENT*>(emf_record);
+      const char* data = reinterpret_cast<const char*>(comment->Data);
+      const uint16_t* ptr = reinterpret_cast<const uint16_t*>(data);
+      int ret = ExtEscape(hdc, PASSTHROUGH, 2 + *ptr, data, 0, nullptr);
+      DCHECK_EQ(*ptr, ret);
+    }
+  }
+  Close();
+  return true;
+}
+
 PdfConverterUtilityProcessHostClient::PdfConverterUtilityProcessHostClient(
     base::WeakPtr<PdfConverterImpl> converter,
     const PdfRenderSettings& settings)
     : converter_(converter), settings_(settings) {}
 
 PdfConverterUtilityProcessHostClient::~PdfConverterUtilityProcessHostClient() {}
 
 void PdfConverterUtilityProcessHostClient::Start(
     const scoped_refptr<base::RefCountedMemory>& data,
     const PdfConverter::StartCallback& start_callback) {
@@ skipping 97 matching lines @@
       base::Bind(&PdfConverterImpl::RunCallback, converter_,
                  base::Bind(data.callback(), data.page_number(), scale_factor,
                             base::Passed(&file))));
   get_page_callbacks_.pop();
 }
 
 void PdfConverterUtilityProcessHostClient::Stop() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&PdfToEmfUtilityProcessHostClient::Stop, this));
+        base::Bind(&PdfConverterUtilityProcessHostClient::Stop, this));
     return;
   }
   SendStopMessage();
 }
 
 void PdfConverterUtilityProcessHostClient::OnProcessCrashed(int exit_code) {
   OnFailed();
 }
 
 void PdfConverterUtilityProcessHostClient::OnProcessLaunchFailed(
@@ skipping 10 matching lines @@
 
 void PdfConverterUtilityProcessHostClient::OnFailed() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!start_callback_.is_null())
     OnPageCount(0);
   while (!get_page_callbacks_.empty())
     OnPageDone(false, 0.0f);
   utility_process_host_.reset();
 }
 
-// PDF to Emf
-PdfToEmfUtilityProcessHostClient::~PdfToEmfUtilityProcessHostClient() {}
 
-void PdfToEmfUtilityProcessHostClient::OnPreCacheFontCharacters(
+void PdfConverterUtilityProcessHostClient::OnPreCacheFontCharacters(
     const LOGFONT& font,
     const base::string16& str) {
   // TODO(scottmg): pdf/ppapi still require the renderer to be able to precache
   // GDI fonts (http://crbug.com/383227), even when using DirectWrite.
   // Eventually this shouldn't be added and should be moved to
   // FontCacheDispatcher too. http://crbug.com/356346.
 
   // First, comments from FontCacheDispatcher::OnPreCacheFont do apply here too.
   // Except that for True Type fonts,
   // GetTextMetrics will not load the font in memory.
@@ skipping 11 matching lines @@
 
   SelectObject(hdc, old_font);
   DeleteObject(font_handle);
 
   HENHMETAFILE metafile = CloseEnhMetaFile(hdc);
 
   if (metafile)
     DeleteEnhMetaFile(metafile);
 }
 
-bool PdfToEmfUtilityProcessHostClient::OnMessageReceived(
+bool PdfConverterUtilityProcessHostClient::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PdfToEmfUtilityProcessHostClient, message)
+  IPC_BEGIN_MESSAGE_MAP(PdfConverterUtilityProcessHostClient, message)
     IPC_MESSAGE_HANDLER(
         ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageCount, OnPageCount)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageDone,
                         OnPageDone)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_PreCacheFontCharacters,
                         OnPreCacheFontCharacters)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-base::string16 PdfToEmfUtilityProcessHostClient::GetName() const {
-  return l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_EMF_CONVERTOR_NAME);
+base::string16 PdfConverterUtilityProcessHostClient::GetName() const {
+  return l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_PDF_CONVERTOR_NAME);
 }
 
-std::unique_ptr<MetafilePlayer>
-PdfToEmfUtilityProcessHostClient::GetFileFromTemp(
-    std::unique_ptr<base::File, content::BrowserThread::DeleteOnFileThread>
-        temp_file) {
-  return base::MakeUnique<LazyEmf>(temp_dir_, std::move(temp_file));
-}
-
-void PdfToEmfUtilityProcessHostClient::SendGetPageMessage(
+void PdfConverterUtilityProcessHostClient::SendGetPageMessage(
     int page_number,
     IPC::PlatformFileForTransit transit) {
   Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(page_number,
                                                               transit));
 }
 
-void PdfToEmfUtilityProcessHostClient::SendStartMessage(
+void PdfConverterUtilityProcessHostClient::SendStartMessage(
     IPC::PlatformFileForTransit transit) {
   Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles(transit, settings_));
 }
 
-void PdfToEmfUtilityProcessHostClient::SendStopMessage() {
+void PdfConverterUtilityProcessHostClient::SendStopMessage() {
   Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_Stop());
 }
+/*void PdfToPostScriptUtilityProcessHostClient::OnPageDone(bool success) {
+  PdfConverterUtilityProcessHostClient::OnPageDone(success, 0.0f);
+}
+*/
+// Pdf Converter Impl and subclasses
+PdfConverterImpl::PdfConverterImpl() : weak_ptr_factory_(this) {}
 
-// Pdf Converter Impl and subclasses
-PdfConverterImpl::PdfConverterImpl() {}
+PdfConverterImpl::~PdfConverterImpl() {
+  if (utility_client_.get())
+    utility_client_->Stop();
+}
 
-PdfConverterImpl::~PdfConverterImpl() {}
-
-void PdfConverterImpl::Start(const scoped_refptr<base::RefCountedMemory>& data,
-                             const PdfRenderSettings& conversion_settings,
-                             const StartCallback& start_callback) {
-  DCHECK(!utility_client_.get());
+void PdfConverterImpl::Start(
+      const scoped_refptr<PdfConverterUtilityProcessHostClient>& utility_client,
+      const scoped_refptr<base::RefCountedMemory>& data,
+      const StartCallback& start_callback) {
+    DCHECK(!utility_client_);
+    utility_client_ = utility_client;
+    utility_client_->Start(data, start_callback);
 }
 
 void PdfConverterImpl::GetPage(int page_number,
                                const GetPageCallback& get_page_callback) {
   utility_client_->GetPage(page_number, get_page_callback);
 }
 
 void PdfConverterImpl::RunCallback(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   callback.Run();
 }
 
-PdfToEmfConverterImpl::PdfToEmfConverterImpl() : weak_ptr_factory_(this) {}
-
-PdfToEmfConverterImpl::~PdfToEmfConverterImpl() {
-  if (utility_client_.get())
-    utility_client_->Stop();
-}
-
-void PdfToEmfConverterImpl::Start(
-    const scoped_refptr<base::RefCountedMemory>& data,
-    const PdfRenderSettings& conversion_settings,
-    const StartCallback& start_callback) {
-  DCHECK(!utility_client_.get());
-  utility_client_ = new PdfToEmfUtilityProcessHostClient(
-      weak_ptr_factory_.GetWeakPtr(), conversion_settings);
-  utility_client_->Start(data, start_callback);
-}
-
 }  // namespace
 
 PdfConverter::~PdfConverter() {}
 
 // static
-std::unique_ptr<PdfConverter> PdfConverter::CreatePdfToEmfConverter() {
-  return base::MakeUnique<PdfToEmfConverterImpl>();
+std::unique_ptr<PdfConverter> PdfConverter::StartPdfConverter(
+    const scoped_refptr<base::RefCountedMemory>& data,
+    const PdfRenderSettings& conversion_settings,
+    const StartCallback& start_callback) {
+  std::unique_ptr<PdfConverterImpl> converter =
+      base::MakeUnique<PdfConverterImpl>();
+  converter->Start(
+      new PdfConverterUtilityProcessHostClient(converter->GetWeakPtr(),
+                                               conversion_settings),
+          data, start_callback);
+  return std::move(converter);
 }
 
 }  // namespace printing