Use file handles to interact with utility process.

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 "base/bind_helpers.h"
-#include "base/cancelable_callback.h"
+#include <queue>
+
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/chrome_utility_printing_messages.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 "printing/emf_win.h"
-#include "printing/page_range.h"
 #include "printing/pdf_render_settings.h"
 
 namespace printing {
 
 namespace {
 
 using content::BrowserThread;
 
-class FileHandlers
-    : public base::RefCountedThreadSafe<FileHandlers,
-                                        BrowserThread::DeleteOnFileThread> {
+class PdfToEmfConverterImpl;
+
+typedef scoped_ptr<base::File, BrowserThread::DeleteOnFileThread>
+    ScopedTempFile;
+
+// Wrapper for Emf to keep only file handle in memory, and load actual data only
+// on playback. Emf::InitFromFile() can play metafile directly from disk, but it
+// can't open file handles. We need file handles to reliably delete temporary
+// files, and to efficiently interact with utility process.
+class LazyEmf : public MetafilePlayer {
  public:
-  FileHandlers() {}
-
-  void Init(base::RefCountedMemory* data);
-  bool IsValid();
-
-  base::FilePath GetEmfPath() const {
-    return temp_dir_.path().AppendASCII("output.emf");
-  }
-
-  base::FilePath GetEmfPagePath(int page_number) const {
-    return GetEmfPath().InsertBeforeExtensionASCII(
-        base::StringPrintf(".%d", page_number));
-  }
-
-  base::FilePath GetPdfPath() const {
-    return temp_dir_.path().AppendASCII("input.pdf");
-  }
-
-  IPC::PlatformFileForTransit GetPdfForProcess(base::ProcessHandle process) {
-    DCHECK(pdf_file_.IsValid());
-    IPC::PlatformFileForTransit transit =
-        IPC::TakeFileHandleForProcess(pdf_file_.Pass(), process);
-    return transit;
-  }
-
-  const base::FilePath& GetBasePath() const {
-    return temp_dir_.path();
-  }
+  explicit LazyEmf(ScopedTempFile file) : file_(file.Pass()) {}
+  virtual ~LazyEmf() { Close(); }
+
+  virtual bool SafePlayback(HDC hdc) const OVERRIDE;
+  virtual bool SaveTo(base::File* file) const OVERRIDE;
 
  private:
-  friend struct BrowserThread::DeleteOnThread<BrowserThread::FILE>;
-  friend class base::DeleteHelper<FileHandlers>;
-
-  ~FileHandlers() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); }
-
-  base::ScopedTempDir temp_dir_;
-  base::File pdf_file_;
-};
-
-void FileHandlers::Init(base::RefCountedMemory* data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  if (!temp_dir_.CreateUniqueTempDir()) {
-    return;
-  }
-
-  pdf_file_.Initialize(GetPdfPath(),
-                       base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE |
-                           base::File::FLAG_READ |
-                           base::File::FLAG_DELETE_ON_CLOSE);
-  if (static_cast<int>(data->size()) !=
-      pdf_file_.WriteAtCurrentPos(data->front_as<char>(), data->size())) {
-    pdf_file_.Close();
-    return;
-  }
-  pdf_file_.Seek(base::File::FROM_BEGIN, 0);
-  pdf_file_.Flush();
-}
-
-bool FileHandlers::IsValid() {
-  return pdf_file_.IsValid();
-}
-
-// Modification of Emf to keep references to |FileHandlers|.
-// |FileHandlers| must be deleted after the last metafile is closed because
-// Emf holds files locked.
-// Ideally we want to use FLAG_DELETE_ON_CLOSE, but it requires large changes.
-// It's going to be done for crbug.com/408184
-class TempEmf : public Emf {
- public:
-  explicit TempEmf(const scoped_refptr<FileHandlers>& files) : files_(files) {}
-  virtual ~TempEmf() {}
-
-  virtual bool SafePlayback(HDC hdc) const OVERRIDE {
-    bool result = Emf::SafePlayback(hdc);
-    TempEmf* this_mutable = const_cast<TempEmf*>(this);
-    // TODO(vitalybuka): Fix destruction of metafiles. For some reasons
-    // instances of Emf are not deleted. crbug.com/411683
-    // |files_| must be released as soon as possible to guarantee deletion.
-    // It's know that this Emf file is going to be played just once to
-    // a printer. So just release files here.
-    this_mutable->Close();
-    this_mutable->files_ = NULL;
-    return result;
-  }
-
- private:
-  scoped_refptr<FileHandlers> files_;
-  DISALLOW_COPY_AND_ASSIGN(TempEmf);
+  void Close() const;
+  bool LoadEmf(Emf* emf) const;
+
+  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.
 // Internal workflow is following:
 // 1. Create instance on the UI thread. (files_, settings_,)
-// 2. Create file on the FILE thread.
+// 2. Create pdf file on the FILE thread.
 // 3. Start utility process and start conversion on the IO thread.
-// 4. Run result callback on the UI thread.
-// 5. Instance is destroyed from any thread that has the last reference.
-// 6. FileHandlers destroyed on the FILE thread.
-//    This step posts |FileHandlers| to be destroyed on the FILE 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:
-  explicit PdfToEmfUtilityProcessHostClient(
-      const printing::PdfRenderSettings& settings);
-
-  void Convert(base::RefCountedMemory* data,
-               const PdfToEmfConverter::ResultCallback& callback);
+  PdfToEmfUtilityProcessHostClient(
+      base::WeakPtr<PdfToEmfConverterImpl> converter,
+      const PdfRenderSettings& settings);
+
+  void Start(const scoped_refptr<base::RefCountedMemory>& data,
+             const PdfToEmfConverter::StartCallback& start_callback);
+
+  void GetPage(int page_number,
+               const PdfToEmfConverter::GetPageCallback& get_page_callback);
+
+  void Stop();
 
   // UtilityProcessHostClient implementation.
   virtual void OnProcessCrashed(int exit_code) OVERRIDE;
+  virtual void OnProcessLaunchFailed() OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
  private:
+  class GetPageCallbackData {
+    MOVE_ONLY_TYPE_FOR_CPP_03(GetPageCallbackData, RValue);
+
+   public:
+    GetPageCallbackData(int page_number,
+                        PdfToEmfConverter::GetPageCallback callback)
+        : page_number_(page_number), callback_(callback) {}
+
+    // Move constructor for STL.
+    GetPageCallbackData(RValue other) { this->operator=(other); }
+
+    // Move assignment for STL.
+    GetPageCallbackData& operator=(RValue rhs) {
+      page_number_ = rhs.object->page_number_;
+      callback_ = rhs.object->callback_;
+      emf_ = rhs.object->emf_.Pass();
+      return *this;
+    }
+
+    int page_number() const { return page_number_; }
+    const PdfToEmfConverter::GetPageCallback& callback() const {
+      return callback_;
+    }
+    ScopedTempFile emf() { return emf_.Pass(); }
+    void set_emf(ScopedTempFile emf) { emf_ = emf.Pass(); }
+
+   private:
+    int page_number_;
+    PdfToEmfConverter::GetPageCallback callback_;
+    ScopedTempFile emf_;
+  };
+
   virtual ~PdfToEmfUtilityProcessHostClient();
 
+  bool Send(IPC::Message* msg);
+
   // Message handlers.
   void OnProcessStarted();
-  void OnSucceeded(const std::vector<printing::PageRange>& page_ranges,
-                   double scale_factor);
+  void OnPageCount(int page_count);
+  void OnPageDone(bool success, double scale_factor);
+
   void OnFailed();
-
-  void RunCallback(const std::vector<printing::PageRange>& page_ranges,
-                   double scale_factor);
-
-  void StartProcessOnIOThread();
-
-  void RunCallbackOnUIThread(
-      const std::vector<printing::PageRange>& page_ranges,
-      double scale_factor);
-  void OnFilesReadyOnUIThread();
-
-  scoped_refptr<FileHandlers> files_;
-  printing::PdfRenderSettings settings_;
-  PdfToEmfConverter::ResultCallback callback_;
+  void OnTempPdfReady(ScopedTempFile pdf);
+  void OnTempEmfReady(GetPageCallbackData* callback_data, ScopedTempFile emf);
+
+  // Used to suppress callbacks after PdfToEmfConverterImpl is deleted.
+  base::WeakPtr<PdfToEmfConverterImpl> converter_;
+  PdfRenderSettings settings_;
+  scoped_refptr<base::RefCountedMemory> data_;
+
+  // Document loaded callback.
+  PdfToEmfConverter::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().
+  typedef std::queue<GetPageCallbackData> GetPageCallbacks;
+  GetPageCallbacks get_page_callbacks_;
+
   DISALLOW_COPY_AND_ASSIGN(PdfToEmfUtilityProcessHostClient);
 };
 
+class PdfToEmfConverterImpl : public PdfToEmfConverter {
+ public:
+  PdfToEmfConverterImpl();
+
+  virtual ~PdfToEmfConverterImpl();
+
+  virtual void Start(const scoped_refptr<base::RefCountedMemory>& data,
+                     const PdfRenderSettings& conversion_settings,
+                     const StartCallback& start_callback) OVERRIDE;
+
+  virtual 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);
+
+ private:
+  scoped_refptr<PdfToEmfUtilityProcessHostClient> utility_client_;
+  base::WeakPtrFactory<PdfToEmfConverterImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(PdfToEmfConverterImpl);
+};
+
+// Use global object to avoid tracking all opened files.

[Lei Zhang, 2014/09/16 19:57:36]

I'm slightly confused by this comment. Aren't you still using ScopedTempFile to
keep track of the returned file from CreateTempFile()? Are you trying to just
keep everything in its own directory?

[Vitaly Buka (NO REVIEWS), 2014/09/16 22:10:37]

I don't want global TEMP dir, to avoid polluted dir 2^16 temp files, and
collisions. Same as in service host.

ScopedTempFile is just to delete base::File on FILE thread, and nothing for temp
dir.

We need to delete ScopedTempDir after all ScopedTempFile are gone.

I can update ScopedTempDir and make it track both: base::File and 
ScopedTempFile.

I don't like this approach because I would need to share ScopedTempDir between
different calls to CreateTempFile(). It would complicate the code a little.
Single temp dir for process should be good enough.

I can create a patch to show how it looks.

[Lei Zhang, 2014/09/16 22:39:59]

Oh, is the problem that ScopedTempDir doesn't work properly on Windows because
it won't actually delete the temp dir if there are files in it that are open?
Thus one would need to track the files in that folder that are open, and that's
a lot of work?

+base::LazyInstance<base::ScopedTempDir> g_temp_dir = LAZY_INSTANCE_INITIALIZER;
+
+ScopedTempFile CreateTempFile() {
+  base::ScopedTempDir& temp_dir = g_temp_dir.Get();
+  ScopedTempFile file;
+  if (!temp_dir.IsValid() && !temp_dir.CreateUniqueTempDir())
+    return file.Pass();
+  base::FilePath path;
+  if (!base::CreateTemporaryFileInDir(temp_dir.path(), &path))
+    return file.Pass();
+  file.reset(new base::File(path,
+                            base::File::FLAG_CREATE_ALWAYS |
+                                base::File::FLAG_WRITE | base::File::FLAG_READ |
+                                base::File::FLAG_DELETE_ON_CLOSE |
+                                base::File::FLAG_TEMPORARY));
+  if (!file->IsValid())
+    file.reset();
+  return file.Pass();
+}
+
+ScopedTempFile CreateTempPdfFile(
+    const scoped_refptr<base::RefCountedMemory>& data) {
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+
+  ScopedTempFile pdf_file = CreateTempFile();
+  if (!pdf_file ||
+      static_cast<int>(data->size()) !=
+          pdf_file->WriteAtCurrentPos(data->front_as<char>(), data->size())) {
+    pdf_file.reset();
+  }
+  pdf_file->Seek(base::File::FROM_BEGIN, 0);
+  return pdf_file.Pass();
+}
+
+bool LazyEmf::SafePlayback(HDC hdc) const {
+  Emf emf;
+  bool result = LoadEmf(&emf) && emf.SafePlayback(hdc);
+  // TODO(vitalybuka): Fix destruction of metafiles. For some reasons
+  // instances of Emf are not deleted. crbug.com/411683
+  // It's known that the Emf going to be played just once to a printer. So just
+  // release file here.
+  Close();
+  return result;
+}
+
+bool LazyEmf::SaveTo(base::File* file) const {
+  Emf emf;
+  return LoadEmf(&emf) && emf.SaveTo(file);
+}
+
+void LazyEmf::Close() const {
+  file_.reset();
+}
+
+bool LazyEmf::LoadEmf(Emf* emf) const {
+  file_->Seek(base::File::FROM_BEGIN, 0);
+  int64 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());
+}
+
 PdfToEmfUtilityProcessHostClient::PdfToEmfUtilityProcessHostClient(
-    const printing::PdfRenderSettings& settings)
-    : settings_(settings) {}
+    base::WeakPtr<PdfToEmfConverterImpl> converter,
+    const PdfRenderSettings& settings)
+    : converter_(converter), settings_(settings) {
+}
 
 PdfToEmfUtilityProcessHostClient::~PdfToEmfUtilityProcessHostClient() {
 }
 
-void PdfToEmfUtilityProcessHostClient::Convert(
-    base::RefCountedMemory* data,
-    const PdfToEmfConverter::ResultCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  callback_ = callback;
-  CHECK(!files_.get());
-  files_ = new FileHandlers();
-  BrowserThread::PostTaskAndReply(
+void PdfToEmfUtilityProcessHostClient::Start(
+    const scoped_refptr<base::RefCountedMemory>& data,
+    const PdfToEmfConverter::StartCallback& start_callback) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(BrowserThread::IO,
+                            FROM_HERE,
+                            base::Bind(&PdfToEmfUtilityProcessHostClient::Start,
+                                       this,
+                                       data,
+                                       start_callback));
+    return;
+  }
+  data_ = data;
+
+  // Store callback before any OnFailed() calles to make it called on failure.

[Lei Zhang, 2014/09/16 19:57:36]

typo: calls, same on line 333

[Vitaly Buka (NO REVIEWS), 2014/09/16 22:10:37]

Done.

+  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::MessageLoop::current()->message_loop_proxy())
+          ->AsWeakPtr();
+  if (!utility_process_host_)
+    return OnFailed();
+  // Should reply with OnProcessStarted().
+  Send(new ChromeUtilityMsg_StartupPing);
+}
+
+void PdfToEmfUtilityProcessHostClient::OnProcessStarted() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!utility_process_host_)
+    return OnFailed();
+
+  base::ProcessHandle process = utility_process_host_->GetData().handle;
+  scoped_refptr<base::RefCountedMemory> data = data_;
+  data_ = NULL;
+  BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE,
       FROM_HERE,
-      base::Bind(&FileHandlers::Init, files_, make_scoped_refptr(data)),
-      base::Bind(&PdfToEmfUtilityProcessHostClient::OnFilesReadyOnUIThread,
-                 this));
+      base::Bind(&CreateTempPdfFile, data),
+      base::Bind(&PdfToEmfUtilityProcessHostClient::OnTempPdfReady, this));
+}
+
+void PdfToEmfUtilityProcessHostClient::OnTempPdfReady(ScopedTempFile pdf) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!utility_process_host_)
+    return OnFailed();
+  base::ProcessHandle process = utility_process_host_->GetData().handle;
+  // Should reply with OnPageCount().
+  Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles(
+      IPC::GetFileHandleForProcess(pdf->GetPlatformFile(), process, false),
+      settings_));
+}
+
+void PdfToEmfUtilityProcessHostClient::OnPageCount(int page_count) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  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();
+}
+
+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;
+  }
+
+  // Store callback before any OnFailed() calles to make it called on failure.
+  get_page_callbacks_.push(GetPageCallbackData(page_number, get_page_callback));
+
+  if (!utility_process_host_)
+    return OnFailed();
+
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&CreateTempFile),
+      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_)
+    return OnFailed();
+  base::ProcessHandle process = utility_process_host_->GetData().handle;
+  IPC::PlatformFileForTransit transit =
+      IPC::GetFileHandleForProcess(emf->GetPlatformFile(), process, false);
+  callback_data->set_emf(emf.Pass());
+  // Should reply with OnPageDone().
+  Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(
+      callback_data->page_number(), transit));
+}
+
+void PdfToEmfUtilityProcessHostClient::OnPageDone(bool success,
+                                                  double scale_factor) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (get_page_callbacks_.empty())
+    return OnFailed();
+  scoped_ptr<LazyEmf> emf;
+  GetPageCallbackData& data = get_page_callbacks_.front();
+  if (success)
+    emf.reset(new LazyEmf(data.emf().Pass()));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&PdfToEmfConverterImpl::RunCallback,
+                                     converter_,
+                                     base::Bind(data.callback(),
+                                                data.page_number(),
+                                                scale_factor,
+                                                base::Passed(&emf))));
+  get_page_callbacks_.pop();
+}
+
+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() {
+  OnFailed();
+}
+
 bool PdfToEmfUtilityProcessHostClient::OnMessageReceived(
-  const IPC::Message& message) {
+    const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PdfToEmfUtilityProcessHostClient, message)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ProcessStarted, OnProcessStarted)
     IPC_MESSAGE_HANDLER(
-        ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_Succeeded, OnSucceeded)
-    IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed,
-                        OnFailed)
+        ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageCount, OnPageCount)
+    IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageDone,
+                        OnPageDone)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void PdfToEmfUtilityProcessHostClient::OnProcessStarted() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (!utility_process_host_) {
-    RunCallbackOnUIThread(std::vector<printing::PageRange>(), 0.0);
-    return;
-  }
-
-  base::ProcessHandle process = utility_process_host_->GetData().handle;
-  utility_process_host_->Send(
-      new ChromeUtilityMsg_RenderPDFPagesToMetafiles(
-          files_->GetPdfForProcess(process),
-          files_->GetEmfPath(),
-          settings_,
-          std::vector<printing::PageRange>()));
+bool PdfToEmfUtilityProcessHostClient::Send(IPC::Message* msg) {
+  if (utility_process_host_)
+    return utility_process_host_->Send(msg);
+  delete msg;
+  return false;
+}
+
+void PdfToEmfUtilityProcessHostClient::OnFailed() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!start_callback_.is_null())
+    OnPageCount(0);
+  while (!get_page_callbacks_.empty())
+    OnPageDone(false, 0.0);
   utility_process_host_.reset();
 }
 
-void PdfToEmfUtilityProcessHostClient::OnSucceeded(
-    const std::vector<printing::PageRange>& page_ranges,
-    double scale_factor) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunCallback(page_ranges, scale_factor);
-}
-
-void PdfToEmfUtilityProcessHostClient::OnFailed() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunCallback(std::vector<printing::PageRange>(), 0.0);
-}
-
-void PdfToEmfUtilityProcessHostClient::OnFilesReadyOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!files_->IsValid()) {
-    RunCallbackOnUIThread(std::vector<printing::PageRange>(), 0.0);
-    return;
-  }
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&PdfToEmfUtilityProcessHostClient::StartProcessOnIOThread,
-                 this));
-}
-
-void PdfToEmfUtilityProcessHostClient::StartProcessOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  utility_process_host_ =
-      content::UtilityProcessHost::Create(
-          this,
-          base::MessageLoop::current()->message_loop_proxy())->AsWeakPtr();
-  // 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_->SetExposedDir(files_->GetBasePath());
-  utility_process_host_->Send(new ChromeUtilityMsg_StartupPing);
-}
-
-void PdfToEmfUtilityProcessHostClient::RunCallback(
-    const std::vector<printing::PageRange>& page_ranges,
-    double scale_factor) {
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&PdfToEmfUtilityProcessHostClient::RunCallbackOnUIThread,
-                 this,
-                 page_ranges,
-                 scale_factor));
-}
-
-void PdfToEmfUtilityProcessHostClient::RunCallbackOnUIThread(
-    const std::vector<printing::PageRange>& page_ranges,
-    double scale_factor) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ScopedVector<MetafilePlayer> pages;
-  std::vector<printing::PageRange>::const_iterator iter;
-  for (iter = page_ranges.begin(); iter != page_ranges.end(); ++iter) {
-    for (int page_number = iter->from; page_number <= iter->to; ++page_number) {
-      scoped_ptr<TempEmf> metafile(new TempEmf(files_));
-      if (!metafile->InitFromFile(files_->GetEmfPagePath(page_number))) {
-        NOTREACHED() << "Invalid metafile";
-        metafile.reset();
-      }
-      pages.push_back(metafile.release());
-    }
-  }
-  files_ = NULL;
-  if (!callback_.is_null()) {
-    callback_.Run(scale_factor, &pages);
-    callback_.Reset();
-  }
-}
-
-class PdfToEmfConverterImpl : public PdfToEmfConverter {
- public:
-  PdfToEmfConverterImpl();
-
-  virtual ~PdfToEmfConverterImpl();
-
-  virtual void Start(base::RefCountedMemory* data,
-                     const printing::PdfRenderSettings& conversion_settings,
-                     const ResultCallback& callback) OVERRIDE;
-
- private:
-  scoped_refptr<PdfToEmfUtilityProcessHostClient> utility_client_;
-  base::CancelableCallback<ResultCallback::RunType> callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(PdfToEmfConverterImpl);
-};
-
-PdfToEmfConverterImpl::PdfToEmfConverterImpl() {
+PdfToEmfConverterImpl::PdfToEmfConverterImpl() : weak_ptr_factory_(this) {
 }
 
 PdfToEmfConverterImpl::~PdfToEmfConverterImpl() {
+  if (utility_client_)
+    utility_client_->Stop();
 }
 
 void PdfToEmfConverterImpl::Start(
-    base::RefCountedMemory* data,
-    const printing::PdfRenderSettings& conversion_settings,
-    const ResultCallback& callback) {
-  // Rebind cancelable callback to avoid calling callback if
-  // PdfToEmfConverterImpl is destroyed.
-  callback_.Reset(callback);
-  utility_client_ = new PdfToEmfUtilityProcessHostClient(conversion_settings);
-  utility_client_->Convert(data, callback_.callback());
+    const scoped_refptr<base::RefCountedMemory>& data,
+    const PdfRenderSettings& conversion_settings,
+    const StartCallback& start_callback) {
+  DCHECK(!utility_client_);
+  utility_client_ = new PdfToEmfUtilityProcessHostClient(
+      weak_ptr_factory_.GetWeakPtr(), conversion_settings);
+  utility_client_->Start(data, start_callback);
+}
+
+void PdfToEmfConverterImpl::GetPage(int page_number,
+                                    const GetPageCallback& get_page_callback) {
+  utility_client_->GetPage(page_number, get_page_callback);
+}
+
+void PdfToEmfConverterImpl::RunCallback(const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  callback.Run();
 }
 
 }  // namespace
 
+PdfToEmfConverter::~PdfToEmfConverter() {
+}
+
 // static
 scoped_ptr<PdfToEmfConverter> PdfToEmfConverter::CreateDefault() {
   return scoped_ptr<PdfToEmfConverter>(new PdfToEmfConverterImpl());
 }
 
 }  // namespace printing