Refactor pdf_to_emf_converter

chrome/browser/printing/print_job.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/browser/printing/print_job.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 213 matching lines @@
 #if defined(OS_WIN)
 
 class PrintJob::PdfToEmfState {
  public:
   PdfToEmfState(const gfx::Size& page_size, const gfx::Rect& content_area)
       : page_count_(0),
         current_page_(0),
         pages_in_progress_(0),
         page_size_(page_size),
         content_area_(content_area),
-        converter_(PdfToEmfConverter::CreateDefault()) {}
+        converter_(PdfConverter::CreatePdfToEmfConverter()) {}
 
   void Start(const scoped_refptr<base::RefCountedMemory>& data,
              const PdfRenderSettings& conversion_settings,
              bool print_text_with_gdi,
-             const PdfToEmfConverter::StartCallback& start_callback) {
+             const PdfConverter::StartCallback& start_callback) {
     converter_->Start(data, conversion_settings, print_text_with_gdi,
                       start_callback);
   }
 
-  void GetMorePages(
-      const PdfToEmfConverter::GetPageCallback& get_page_callback) {
+  void GetMorePages(const PdfConverter::GetPageCallback& get_page_callback) {
     const int kMaxNumberOfTempFilesPerDocument = 3;
     while (pages_in_progress_ < kMaxNumberOfTempFilesPerDocument &&
            current_page_ < page_count_) {
       ++pages_in_progress_;
       converter_->GetPage(current_page_++, get_page_callback);
     }
   }
 
-  void OnPageProcessed(
-      const PdfToEmfConverter::GetPageCallback& get_page_callback) {
+  void OnPageProcessed(const PdfConverter::GetPageCallback& get_page_callback) {
     --pages_in_progress_;
     GetMorePages(get_page_callback);
     // Release converter if we don't need this any more.
     if (!pages_in_progress_ && current_page_ >= page_count_)
       converter_.reset();
   }
 
   void set_page_count(int page_count) { page_count_ = page_count; }
   gfx::Size page_size() const { return page_size_; }
   gfx::Rect content_area() const { return content_area_; }
 
  private:
   int page_count_;
   int current_page_;
   int pages_in_progress_;
   gfx::Size page_size_;
   gfx::Rect content_area_;
-  std::unique_ptr<PdfToEmfConverter> converter_;
+  std::unique_ptr<PdfConverter> converter_;
 };
 
 void PrintJob::AppendPrintedPage(int page_number) {
   pdf_page_mapping_.push_back(page_number);
 }
 
 void PrintJob::StartPdfToEmfConversion(
     const scoped_refptr<base::RefCountedMemory>& bytes,
     const gfx::Size& page_size,
     const gfx::Rect& content_area,
@@ skipping 173 matching lines @@
 }
 
 JobEventDetails::~JobEventDetails() {
 }
 
 PrintedDocument* JobEventDetails::document() const { return document_.get(); }
 
 PrintedPage* JobEventDetails::page() const { return page_.get(); }
 
 }  // namespace printing