Convert printing IPCs to Mojo

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>
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/common/chrome_utility_messages.h"
-#include "chrome/common/chrome_utility_printing_messages.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/printing/common/printing.mojom.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
-#include "content/public/browser/utility_process_host.h"
-#include "content/public/browser/utility_process_host_client.h"
+#include "content/public/browser/utility_process_mojo_client.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "printing/emf_win.h"
 #include "printing/pdf_render_settings.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace printing {
 
 namespace {
 
 using content::BrowserThread;
 
 class PdfToEmfConverterImpl;
 
@@ skipping 41 matching lines @@
   void Close() const;
   bool LoadEmf(Emf* emf) const;
 
   mutable scoped_refptr<RefCountedTempDir> temp_dir_;
   mutable ScopedTempFile file_;  // Mutable because of consts in base class.
 
   DISALLOW_COPY_AND_ASSIGN(LazyEmf);
 };
 
 // Converts PDF into EMF.
-// Class uses 3 threads: UI, IO and FILE.
+// Class uses 2 threads: UI 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.
+// 3. Start utility process and start conversion on the UI 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.
 //
 // All these steps work sequentially, so no data should be accessed
 // simultaneously by several threads.
 class PdfToEmfUtilityProcessHostClient
-    : public content::UtilityProcessHostClient {
+    : public base::RefCountedThreadSafe<PdfToEmfUtilityProcessHostClient> {
  public:
   PdfToEmfUtilityProcessHostClient(
       base::WeakPtr<PdfToEmfConverterImpl> converter,
       const PdfRenderSettings& settings);
 
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
              bool print_text_with_gdi,
              const PdfToEmfConverter::StartCallback& start_callback);
 
   void GetPage(int page_number,
                const PdfToEmfConverter::GetPageCallback& get_page_callback);
 
   void Stop();
 
-  // Needs to be public to handle ChromeUtilityHostMsg_PreCacheFontCharacters
-  // sync message replies.
-  bool Send(IPC::Message* msg);
-
-  // UtilityProcessHostClient implementation.
-  void OnProcessCrashed(int exit_code) override;
-  void OnProcessLaunchFailed(int exit_code) override;
-  bool OnMessageReceived(const IPC::Message& message) override;
-
  private:
   class GetPageCallbackData {
    public:
     GetPageCallbackData(int page_number,
                         PdfToEmfConverter::GetPageCallback callback)
         : page_number_(page_number), callback_(callback) {}
 
     GetPageCallbackData(GetPageCallbackData&& other) {
       *this = std::move(other);
     }
@@ skipping 13 matching lines @@
     void set_emf(ScopedTempFile emf) { emf_ = std::move(emf); }
 
    private:
     int page_number_;
     PdfToEmfConverter::GetPageCallback callback_;
     ScopedTempFile emf_;
 
     DISALLOW_COPY_AND_ASSIGN(GetPageCallbackData);
   };
 
+  friend class base::RefCountedThreadSafe<PdfToEmfUtilityProcessHostClient>;
   ~PdfToEmfUtilityProcessHostClient() override;
 
   // Message handlers.
   void OnPageCount(int page_count);
   void OnPageDone(bool success, float scale_factor);
-  void OnPreCacheFontCharacters(const LOGFONT& log_font,
-                                const base::string16& characters);
 
   void OnFailed();
   void OnTempPdfReady(bool print_text_with_gdi, ScopedTempFile pdf);
   void OnTempEmfReady(GetPageCallbackData* callback_data, ScopedTempFile emf);
 
   scoped_refptr<RefCountedTempDir> temp_dir_;
 
   // Used to suppress callbacks after PdfToEmfConverterImpl is deleted.
   base::WeakPtr<PdfToEmfConverterImpl> converter_;
   PdfRenderSettings settings_;
 
   // Document loaded callback.
   PdfToEmfConverter::StartCallback start_callback_;
 
-  // Process host for IPC.
-  base::WeakPtr<content::UtilityProcessHost> utility_process_host_;
+  std::unique_ptr<content::UtilityProcessMojoClient<mojom::PrintingFactory>>
+      utility_client_;
 
   // 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().
   typedef std::queue<GetPageCallbackData> GetPageCallbacks;
   GetPageCallbacks get_page_callbacks_;
 
+  // Bound and used on the UI thread.
+  mojom::PrintingPtr printing_;
+
   DISALLOW_COPY_AND_ASSIGN(PdfToEmfUtilityProcessHostClient);
 };
 
 class PdfToEmfConverterImpl : public PdfToEmfConverter {
  public:
   PdfToEmfConverterImpl();
 
   ~PdfToEmfConverterImpl() override;
 
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
@@ skipping 88 matching lines @@
     return false;
   std::vector<char> data(size);
   if (file_->ReadAtCurrentPos(data.data(), data.size()) != size)
     return false;
   return emf->InitFromData(data.data(), data.size());
 }
 
 PdfToEmfUtilityProcessHostClient::PdfToEmfUtilityProcessHostClient(
     base::WeakPtr<PdfToEmfConverterImpl> converter,
     const PdfRenderSettings& settings)
-    : converter_(converter), settings_(settings) {
+    : converter_(converter), settings_(settings) {}
+
+PdfToEmfUtilityProcessHostClient::~PdfToEmfUtilityProcessHostClient() {
 }
 
-PdfToEmfUtilityProcessHostClient::~PdfToEmfUtilityProcessHostClient() {
+class FontPreCachingImpl : public mojom::FontPreCaching {

[Sam McNally, 2017/01/12 04:49:53]

This class seems bit scattered.

[tibell, 2017/01/13 02:51:10]

Done.

+ public:
+  static void Create(mojom::FontPreCachingRequest request);
+
+  // mojom::FontPreCaching:
+  void PreCacheFontCharacters(
+      const LOGFONT& log_font,
+      const base::string16& characters,
+      const PreCacheFontCharactersCallback& callback) override;
+
+ private:
+  // Interface that receives font precaching requests.
+  mojo::StrongBinding<mojom::FontPreCaching> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(FontPreCachingImpl);
+};
+
+FontPreCachingImpl::Create(mojom::FontPreCachingRequest request) {
+  mojo::MakeStrongBinding(base::MakeUnique<FontPreCachingImpl>(),
+                          std::move(request));
 }
 
 void PdfToEmfUtilityProcessHostClient::Start(
     const scoped_refptr<base::RefCountedMemory>& data,
     bool print_text_with_gdi,
     const PdfToEmfConverter::StartCallback& start_callback) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&PdfToEmfUtilityProcessHostClient::Start, this, data,
-                   print_text_with_gdi, start_callback));
-    return;
-  }
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // 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(l10n_util::GetStringUTF16(
-      IDS_UTILITY_PROCESS_EMF_CONVERTOR_NAME));
+  utility_client_ = base::MakeUnique<
+      content::UtilityProcessMojoClient<mojom::PrintingFactory>>(
+      l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_EMF_CONVERTOR_NAME));
+  utility_client_->set_error_callback(
+      base::Bind(&PdfToEmfUtilityProcessHostClient::OnFailed, this));
+  utility_client_->Start();
+  mojom::FontPreCachingPtr font_precaching;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&FontPreCachingImpl::Create,
+                 base::Passed(mojo::MakeRequest(&font_precaching))));
+  utility_client_->service()->MakePrinting(mojo::MakeRequest(&printing_),
+                                           std::move(font_precaching));
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateTempPdfFile, data, &temp_dir_),
       base::Bind(&PdfToEmfUtilityProcessHostClient::OnTempPdfReady, this,
                  print_text_with_gdi));
 }
 
 void PdfToEmfUtilityProcessHostClient::OnTempPdfReady(bool print_text_with_gdi,
                                                       ScopedTempFile pdf) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!utility_process_host_ || !pdf)
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!utility_client_ || !pdf)
     return OnFailed();
-  // Should reply with OnPageCount().
-  Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles(
-      IPC::GetPlatformFileForTransit(pdf->GetPlatformFile(), false), settings_,
-      print_text_with_gdi));
+  printing_->RenderPDFPagesToMetafiles(
+      pdf->Duplicate(), settings_, print_text_with_gdi,
+      base::Bind(&PdfToEmfUtilityProcessHostClient::OnPageCount, this));
 }
 
 void PdfToEmfUtilityProcessHostClient::OnPageCount(int page_count) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (start_callback_.is_null())
     return OnFailed();
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&PdfToEmfConverterImpl::RunCallback,
-                                     converter_,
-                                     base::Bind(start_callback_, page_count)));
-  start_callback_.Reset();
+  base::ResetAndReturn(&start_callback_).Run(page_count);
 }
 
 void PdfToEmfUtilityProcessHostClient::GetPage(
     int page_number,
     const PdfToEmfConverter::GetPageCallback& get_page_callback) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&PdfToEmfUtilityProcessHostClient::GetPage,
-                   this,
-                   page_number,
-                   get_page_callback));
-    return;
-  }
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Store callback before any OnFailed() call to make it called on failure.
   get_page_callbacks_.push(GetPageCallbackData(page_number, get_page_callback));
 
-  if (!utility_process_host_)
+  if (!utility_client_)
     return OnFailed();
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&CreateTempFile, &temp_dir_),
       base::Bind(&PdfToEmfUtilityProcessHostClient::OnTempEmfReady,
                  this,
                  &get_page_callbacks_.back()));
 }
 
 void PdfToEmfUtilityProcessHostClient::OnTempEmfReady(
     GetPageCallbackData* callback_data,
     ScopedTempFile emf) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!utility_process_host_ || !emf)
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!utility_client_ || !emf)
     return OnFailed();
-  IPC::PlatformFileForTransit transit =
-      IPC::GetPlatformFileForTransit(emf->GetPlatformFile(), false);
   callback_data->set_emf(std::move(emf));
-  // Should reply with OnPageDone().
-  Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(
-      callback_data->page_number(), transit));
+  printing_->RenderPDFPagesToMetafilesGetPage(
+      callback_data->page_number(), emf->Duplicate(),
+      base::Bind(&PdfToEmfUtilityProcessHostClient::OnPageDone, this));
 }
 
 void PdfToEmfUtilityProcessHostClient::OnPageDone(bool success,
                                                   float scale_factor) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (get_page_callbacks_.empty())
     return OnFailed();
   GetPageCallbackData& data = get_page_callbacks_.front();
   std::unique_ptr<MetafilePlayer> emf;
 
   if (success) {
     ScopedTempFile temp_emf = data.TakeEmf();
     if (!temp_emf)  // Unexpected message from utility process.
       return OnFailed();
     emf = base::MakeUnique<LazyEmf>(temp_dir_, std::move(temp_emf));
   }
 
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&PdfToEmfConverterImpl::RunCallback,
-                                     converter_,
-                                     base::Bind(data.callback(),
-                                                data.page_number(),
-                                                scale_factor,
-                                                base::Passed(&emf))));
+  data.callback().Run(data.page_number(), scale_factor, std::move(emf));
   get_page_callbacks_.pop();
 }
 
-void PdfToEmfUtilityProcessHostClient::OnPreCacheFontCharacters(
+void FontPreCachingImpl::PreCacheFontCharacters(
     const LOGFONT& font,
-    const base::string16& str) {
+    const base::string16& str,
+    const PreCacheFontCharactersCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // 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.
   // The only way windows seem to load properly, it is to create a similar
   // device (like the one in which we print), then do an ExtTextOut,
   // as we do in the printing thread, which is sandboxed.
   HDC hdc = CreateEnhMetaFile(nullptr, nullptr, nullptr, nullptr);
   HFONT font_handle = CreateFontIndirect(&font);
   DCHECK(font_handle != nullptr);
 
   HGDIOBJ old_font = SelectObject(hdc, font_handle);
   DCHECK(old_font != nullptr);
 
   ExtTextOut(hdc, 0, 0, ETO_GLYPH_INDEX, 0, str.c_str(), str.length(), nullptr);
 
   SelectObject(hdc, old_font);
   DeleteObject(font_handle);
 
   HENHMETAFILE metafile = CloseEnhMetaFile(hdc);
 
   if (metafile)
     DeleteEnhMetaFile(metafile);
+  callback.Run();
 }
 
 void PdfToEmfUtilityProcessHostClient::Stop() {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&PdfToEmfUtilityProcessHostClient::Stop, this));
-    return;
-  }
-  Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_Stop());
-}
-
-void PdfToEmfUtilityProcessHostClient::OnProcessCrashed(int exit_code) {
-  OnFailed();
-}
-
-void PdfToEmfUtilityProcessHostClient::OnProcessLaunchFailed(int exit_code) {
-  OnFailed();
-}
-
-bool PdfToEmfUtilityProcessHostClient::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PdfToEmfUtilityProcessHostClient, 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;
-}
-
-bool PdfToEmfUtilityProcessHostClient::Send(IPC::Message* msg) {
-  if (utility_process_host_)
-    return utility_process_host_->Send(msg);
-  delete msg;
-  return false;
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  printing_.reset();
 }
 
 void PdfToEmfUtilityProcessHostClient::OnFailed() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!start_callback_.is_null())
     OnPageCount(0);
   while (!get_page_callbacks_.empty())
     OnPageDone(false, 0.0f);
-  utility_process_host_.reset();
+  utility_client_.reset();
 }
 
 PdfToEmfConverterImpl::PdfToEmfConverterImpl() : weak_ptr_factory_(this) {
 }
 
 PdfToEmfConverterImpl::~PdfToEmfConverterImpl() {
   if (utility_client_.get())
     utility_client_->Stop();
 }
 
@@ skipping 22 matching lines @@
 
 PdfToEmfConverter::~PdfToEmfConverter() {
 }
 
 // static
 std::unique_ptr<PdfToEmfConverter> PdfToEmfConverter::CreateDefault() {
   return std::unique_ptr<PdfToEmfConverter>(new PdfToEmfConverterImpl());
 }
 
 }  // namespace printing