Substitute boolean GDI printing for a mode type

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 94 matching lines @@
 // All these steps work sequentially, so no data should be accessed
 // simultaneously by several threads.
 class PdfConverterUtilityProcessHostClient
     : public content::UtilityProcessHostClient {
  public:
   PdfConverterUtilityProcessHostClient(
       base::WeakPtr<PdfConverterImpl> converter,
       const PdfRenderSettings& settings);
 
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
-             bool print_text_with_gdi,
              const PdfConverter::StartCallback& start_callback);
 
   void GetPage(int page_number,
                const PdfConverter::GetPageCallback& get_page_callback);
 
   void Stop();
 
   // UtilityProcessHostClient implementation.
   void OnProcessCrashed(int exit_code) override;
   void OnProcessLaunchFailed(int exit_code) override;
@@ skipping 36 matching lines @@
   ~PdfConverterUtilityProcessHostClient() override;
 
   // Helper functions: must be overridden by subclasses
   // Set the process name
   virtual base::string16 GetName() const = 0;
   // 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;
   // Send the messages to Start, GetPage, and Stop.
-  virtual void SendStartMessage(IPC::PlatformFileForTransit transit,
-                                bool print_text_with_gdi) = 0;
+  virtual void SendStartMessage(IPC::PlatformFileForTransit transit) = 0;
   virtual void SendGetPageMessage(int page_number,
                                   IPC::PlatformFileForTransit transit) = 0;
   virtual void SendStopMessage() = 0;
 
   // Message handlers:
   void OnPageCount(int page_count);
   void OnPageDone(bool success, float scale_factor);
 
   void OnFailed();
-  void OnTempPdfReady(bool print_text_with_gdi, ScopedTempFile pdf);
+  void OnTempPdfReady(ScopedTempFile pdf);
   void OnTempFileReady(GetPageCallbackData* callback_data,
                        ScopedTempFile temp_file);
 
   scoped_refptr<RefCountedTempDir> temp_dir_;
 
   // Used to suppress callbacks after PdfConverter is deleted.
   base::WeakPtr<PdfConverterImpl> converter_;
   PdfRenderSettings settings_;
 
   // Document loaded callback.
@@ skipping 19 matching lines @@
 
   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,
-                        bool print_text_with_gdi) 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);
 };
 
 class PdfConverterImpl : public PdfConverter {
  public:
   PdfConverterImpl();
 
   ~PdfConverterImpl() override;
 
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
              const PdfRenderSettings& conversion_settings,
-             bool print_text_with_gdi,
              const StartCallback& start_callback) override;
 
   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:
   scoped_refptr<PdfConverterUtilityProcessHostClient> utility_client_;
 
  private:
   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,
-             bool print_text_with_gdi,
              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())
@@ skipping 75 matching lines @@
 
 PdfConverterUtilityProcessHostClient::PdfConverterUtilityProcessHostClient(
     base::WeakPtr<PdfConverterImpl> converter,
     const PdfRenderSettings& settings)
     : converter_(converter), settings_(settings) {}
 
 PdfConverterUtilityProcessHostClient::~PdfConverterUtilityProcessHostClient() {}
 
 void PdfConverterUtilityProcessHostClient::Start(
     const scoped_refptr<base::RefCountedMemory>& data,
-    bool print_text_with_gdi,
     const PdfConverter::StartCallback& start_callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&PdfConverterUtilityProcessHostClient::Start, this, data,
-                   print_text_with_gdi, start_callback));
+                   start_callback));
     return;
   }
 
   // Store callback before any OnFailed() call to make it called on failure.
   start_callback_ = start_callback;
 
   // NOTE: This process _must_ be sandboxed, otherwise the pdf dll will load
   // gdiplus.dll, change how rendering happens, and not be able to correctly
   // generate when sent to a metafile DC.
   utility_process_host_ = content::UtilityProcessHost::Create(
                               this, base::ThreadTaskRunnerHandle::Get())
                               ->AsWeakPtr();
   utility_process_host_->SetName(GetName());
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateTempPdfFile, data, &temp_dir_),
-      base::Bind(&PdfConverterUtilityProcessHostClient::OnTempPdfReady, this,
-                 print_text_with_gdi));
+      base::Bind(&PdfConverterUtilityProcessHostClient::OnTempPdfReady, this));
 }
 
-void PdfConverterUtilityProcessHostClient::OnTempPdfReady(
-    bool print_text_with_gdi,
-    ScopedTempFile pdf) {
+void PdfConverterUtilityProcessHostClient::OnTempPdfReady(ScopedTempFile pdf) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!utility_process_host_ || !pdf)
     return OnFailed();
   // Should reply with OnPageCount().
   SendStartMessage(
-      IPC::GetPlatformFileForTransit(pdf->GetPlatformFile(), false),
-      print_text_with_gdi);
+      IPC::GetPlatformFileForTransit(pdf->GetPlatformFile(), false));
 }
 
 void PdfConverterUtilityProcessHostClient::OnPageCount(int page_count) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (start_callback_.is_null())
     return OnFailed();
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&PdfConverterImpl::RunCallback, converter_,
                                      base::Bind(start_callback_, page_count)));
   start_callback_.Reset();
@@ skipping 155 matching lines @@
 }
 
 void PdfToEmfUtilityProcessHostClient::SendGetPageMessage(
     int page_number,
     IPC::PlatformFileForTransit transit) {
   Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(page_number,
                                                               transit));
 }
 
 void PdfToEmfUtilityProcessHostClient::SendStartMessage(
-    IPC::PlatformFileForTransit transit,
-    bool print_text_with_gdi) {
-  Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles(transit, settings_,
-                                                      print_text_with_gdi));
+    IPC::PlatformFileForTransit transit) {
+  Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles(transit, settings_));
 }
 
 void PdfToEmfUtilityProcessHostClient::SendStopMessage() {
   Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_Stop());
 }
 
 // Pdf Converter Impl and subclasses
 PdfConverterImpl::PdfConverterImpl() {}
 
 PdfConverterImpl::~PdfConverterImpl() {}
 
 void PdfConverterImpl::Start(const scoped_refptr<base::RefCountedMemory>& data,
                              const PdfRenderSettings& conversion_settings,
-                             bool print_text_with_gdi,
                              const StartCallback& start_callback) {
   DCHECK(!utility_client_.get());
 }
 
 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,
-    bool print_text_with_gdi,
     const StartCallback& start_callback) {
   DCHECK(!utility_client_.get());
   utility_client_ = new PdfToEmfUtilityProcessHostClient(
       weak_ptr_factory_.GetWeakPtr(), conversion_settings);
-  utility_client_->Start(data, print_text_with_gdi, start_callback);
+  utility_client_->Start(data, start_callback);
 }
 
 }  // namespace
 
 PdfConverter::~PdfConverter() {}
 
 // static
 std::unique_ptr<PdfConverter> PdfConverter::CreatePdfToEmfConverter() {
   return base::MakeUnique<PdfToEmfConverterImpl>();
 }
 
 }  // namespace printing