Rename PWGRasterConverter for consistency with r522241.

Change-Id: Ic690e729722f602e3c527e0d43c64c731c863645
Reviewed-on: https://chromium-review.googlesource.com/813097
Commit-Queue: Lei Zhang <thestig@chromium.org>
Reviewed-by: Jay Civelli <jcivelli@chromium.org>
Cr-Commit-Position: refs/heads/master@{#524266}

chrome/browser/printing/cloud_print/privet_http.h

@@ -21,7 +21,7 @@ class Size;
 }
 
 namespace printing {
-class PWGRasterConverter;
+class PwgRasterConverter;
 }
 
 namespace cloud_print {
@@ -174,8 +174,8 @@ class PrivetLocalPrintOperation {
   virtual void SetPageSize(const gfx::Size& page_size) = 0;
 
   // For testing, inject an alternative PWG raster converter.
-  virtual void SetPWGRasterConverterForTesting(
-      std::unique_ptr<printing::PWGRasterConverter> pwg_raster_converter) = 0;
+  virtual void SetPwgRasterConverterForTesting(
+      std::unique_ptr<printing::PwgRasterConverter> pwg_raster_converter) = 0;
 
   virtual PrivetHTTPClient* GetHTTPClient() = 0;
 };

chrome/browser/printing/cloud_print/privet_http_impl.cc

@@ -502,14 +502,14 @@ void PrivetLocalPrintOperationImpl::StartPrinting() {
 }
 
 void PrivetLocalPrintOperationImpl::StartConvertToPWG() {
-  using printing::PWGRasterConverter;
+  using printing::PwgRasterConverter;
   if (!pwg_raster_converter_)
-    pwg_raster_converter_ = PWGRasterConverter::CreateDefault();
+    pwg_raster_converter_ = PwgRasterConverter::CreateDefault();
 
   pwg_raster_converter_->Start(
       data_.get(),
-      PWGRasterConverter::GetConversionSettings(capabilities_, page_size_),
-      PWGRasterConverter::GetBitmapSettings(capabilities_, ticket_),
+      PwgRasterConverter::GetConversionSettings(capabilities_, page_size_),
+      PwgRasterConverter::GetBitmapSettings(capabilities_, ticket_),
       base::Bind(&PrivetLocalPrintOperationImpl::OnPWGRasterConverted,
                  weak_factory_.GetWeakPtr()));
 }
@@ -636,8 +636,8 @@ void PrivetLocalPrintOperationImpl::SetPageSize(const gfx::Size& page_size) {
   page_size_ = page_size;
 }
 
-void PrivetLocalPrintOperationImpl::SetPWGRasterConverterForTesting(
-    std::unique_ptr<printing::PWGRasterConverter> pwg_raster_converter) {
+void PrivetLocalPrintOperationImpl::SetPwgRasterConverterForTesting(
+    std::unique_ptr<printing::PwgRasterConverter> pwg_raster_converter) {
   pwg_raster_converter_ = std::move(pwg_raster_converter);
 }
 #endif  // ENABLE_PRINT_PREVIEW

chrome/browser/printing/cloud_print/privet_http_impl.h

@@ -160,8 +160,8 @@ class PrivetLocalPrintOperationImpl
   void SetUsername(const std::string& user) override;
   void SetJobname(const std::string& jobname) override;
   void SetPageSize(const gfx::Size& page_size) override;
-  void SetPWGRasterConverterForTesting(
-      std::unique_ptr<printing::PWGRasterConverter> pwg_raster_converter)
+  void SetPwgRasterConverterForTesting(
+      std::unique_ptr<printing::PwgRasterConverter> pwg_raster_converter)
       override;
   PrivetHTTPClient* GetHTTPClient() override;
 
@@ -216,7 +216,7 @@ class PrivetLocalPrintOperationImpl
 
   std::unique_ptr<PrivetURLFetcher> url_fetcher_;
   std::unique_ptr<PrivetJSONOperation> info_operation_;
-  std::unique_ptr<printing::PWGRasterConverter> pwg_raster_converter_;
+  std::unique_ptr<printing::PwgRasterConverter> pwg_raster_converter_;
 
   base::WeakPtrFactory<PrivetLocalPrintOperationImpl> weak_factory_;
 };

chrome/browser/printing/cloud_print/privet_http_unittest.cc

@@ -755,7 +755,7 @@ TEST_P(PrivetCapabilitiesTest, BadToken) {
 // converts strings to file paths based on them by appending "test.pdf", since
 // it's easier to test that way. Instead of using a mock, we simply check if the
 // request is uploading a file that is based on this pattern.
-class FakePWGRasterConverter : public printing::PWGRasterConverter {
+class FakePwgRasterConverter : public printing::PwgRasterConverter {
  public:
   void Start(base::RefCountedMemory* data,
              const printing::PdfRenderSettings& conversion_settings,
@@ -783,9 +783,9 @@ class PrivetLocalPrintTest : public PrivetHTTPTest {
     local_print_operation_ = privet_client_->CreateLocalPrintOperation(
         &local_print_delegate_);
 
-    auto pwg_converter = std::make_unique<FakePWGRasterConverter>();
+    auto pwg_converter = std::make_unique<FakePwgRasterConverter>();
     pwg_converter_ = pwg_converter.get();
-    local_print_operation_->SetPWGRasterConverterForTesting(
+    local_print_operation_->SetPwgRasterConverterForTesting(
         std::move(pwg_converter));
   }
 
@@ -799,7 +799,7 @@ class PrivetLocalPrintTest : public PrivetHTTPTest {
  protected:
   std::unique_ptr<PrivetLocalPrintOperation> local_print_operation_;
   StrictMock<MockLocalPrintDelegate> local_print_delegate_;
-  FakePWGRasterConverter* pwg_converter_;
+  FakePwgRasterConverter* pwg_converter_;
 };
 
 INSTANTIATE_TEST_CASE_P(PrivetTests,

chrome/browser/printing/pwg_raster_converter.cc

@@ -112,19 +112,19 @@ bool FileHandlers::IsValid() {
 //    This step posts |FileHandlers| to be destroyed on |blocking_task_runner_|.
 // All these steps work sequentially, so no data should be accessed
 // simultaneously by several threads.
-class PWGRasterConverterHelper
-    : public base::RefCountedThreadSafe<PWGRasterConverterHelper> {
+class PwgRasterConverterHelper
+    : public base::RefCountedThreadSafe<PwgRasterConverterHelper> {
  public:
-  PWGRasterConverterHelper(const PdfRenderSettings& settings,
+  PwgRasterConverterHelper(const PdfRenderSettings& settings,
                            const PwgRasterSettings& bitmap_settings);
 
   void Convert(base::RefCountedMemory* data,
-               PWGRasterConverter::ResultCallback callback);
+               PwgRasterConverter::ResultCallback callback);
 
  private:
-  friend class base::RefCountedThreadSafe<PWGRasterConverterHelper>;
+  friend class base::RefCountedThreadSafe<PwgRasterConverterHelper>;
 
-  ~PWGRasterConverterHelper();
+  ~PwgRasterConverterHelper();
 
   void RunCallback(bool success);
 
@@ -134,14 +134,14 @@ class PWGRasterConverterHelper
   PwgRasterSettings bitmap_settings_;
   mojo::InterfacePtr<printing::mojom::PdfToPwgRasterConverter>
       pdf_to_pwg_raster_converter_ptr_;
-  PWGRasterConverter::ResultCallback callback_;
+  PwgRasterConverter::ResultCallback callback_;
   const scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
   std::unique_ptr<FileHandlers, base::OnTaskRunnerDeleter> files_;
 
-  DISALLOW_COPY_AND_ASSIGN(PWGRasterConverterHelper);
+  DISALLOW_COPY_AND_ASSIGN(PwgRasterConverterHelper);
 };
 
-PWGRasterConverterHelper::PWGRasterConverterHelper(
+PwgRasterConverterHelper::PwgRasterConverterHelper(
     const PdfRenderSettings& settings,
     const PwgRasterSettings& bitmap_settings)
     : settings_(settings),
@@ -151,11 +151,11 @@ PWGRasterConverterHelper::PWGRasterConverterHelper(
            base::TaskShutdownBehavior::BLOCK_SHUTDOWN})),
       files_(nullptr, base::OnTaskRunnerDeleter(blocking_task_runner_)) {}
 
-PWGRasterConverterHelper::~PWGRasterConverterHelper() {}
+PwgRasterConverterHelper::~PwgRasterConverterHelper() {}
 
-void PWGRasterConverterHelper::Convert(
+void PwgRasterConverterHelper::Convert(
     base::RefCountedMemory* data,
-    PWGRasterConverter::ResultCallback callback) {
+    PwgRasterConverter::ResultCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   callback_ = std::move(callback);
@@ -166,10 +166,10 @@ void PWGRasterConverterHelper::Convert(
       FROM_HERE,
       base::BindOnce(&FileHandlers::Init, base::Unretained(files_.get()),
                      base::RetainedRef(data)),
-      base::BindOnce(&PWGRasterConverterHelper::OnFilesReadyOnUIThread, this));
+      base::BindOnce(&PwgRasterConverterHelper::OnFilesReadyOnUIThread, this));
 }
 
-void PWGRasterConverterHelper::OnFilesReadyOnUIThread() {
+void PwgRasterConverterHelper::OnFilesReadyOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!files_->IsValid()) {
@@ -183,24 +183,24 @@ void PWGRasterConverterHelper::OnFilesReadyOnUIThread() {
                       &pdf_to_pwg_raster_converter_ptr_);
 
   pdf_to_pwg_raster_converter_ptr_.set_connection_error_handler(
-      base::Bind(&PWGRasterConverterHelper::RunCallback, this, false));
+      base::Bind(&PwgRasterConverterHelper::RunCallback, this, false));
 
   pdf_to_pwg_raster_converter_ptr_->Convert(
       mojo::WrapPlatformFile(files_->GetPdfForProcess()), settings_,
       bitmap_settings_, mojo::WrapPlatformFile(files_->GetPwgForProcess()),
-      base::Bind(&PWGRasterConverterHelper::RunCallback, this));
+      base::Bind(&PwgRasterConverterHelper::RunCallback, this));
 }
 
-void PWGRasterConverterHelper::RunCallback(bool success) {
+void PwgRasterConverterHelper::RunCallback(bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (callback_)
     std::move(callback_).Run(success, files_->GetPwgPath());
 }
 
-class PWGRasterConverterImpl : public PWGRasterConverter {
+class PwgRasterConverterImpl : public PwgRasterConverter {
  public:
-  PWGRasterConverterImpl();
-  ~PWGRasterConverterImpl() override;
+  PwgRasterConverterImpl();
+  ~PwgRasterConverterImpl() override;
 
   void Start(base::RefCountedMemory* data,
              const PdfRenderSettings& conversion_settings,
@@ -212,33 +212,32 @@ class PWGRasterConverterImpl : public PWGRasterConverter {
   // change callback_ to a CancelableOnceCallback.
   void RunCallback(bool success, const base::FilePath& temp_file);
 
-  scoped_refptr<PWGRasterConverterHelper> utility_client_;
+  scoped_refptr<PwgRasterConverterHelper> utility_client_;
   ResultCallback callback_;
-  base::WeakPtrFactory<PWGRasterConverterImpl> weak_ptr_factory_;
+  base::WeakPtrFactory<PwgRasterConverterImpl> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(PWGRasterConverterImpl);
+  DISALLOW_COPY_AND_ASSIGN(PwgRasterConverterImpl);
 };
 
-PWGRasterConverterImpl::PWGRasterConverterImpl() : weak_ptr_factory_(this) {}
+PwgRasterConverterImpl::PwgRasterConverterImpl() : weak_ptr_factory_(this) {}
 
-PWGRasterConverterImpl::~PWGRasterConverterImpl() {
-}
+PwgRasterConverterImpl::~PwgRasterConverterImpl() {}
 
-void PWGRasterConverterImpl::Start(base::RefCountedMemory* data,
+void PwgRasterConverterImpl::Start(base::RefCountedMemory* data,
                                    const PdfRenderSettings& conversion_settings,
                                    const PwgRasterSettings& bitmap_settings,
                                    ResultCallback callback) {
   // Bind callback here and pass a wrapper to the utility client to avoid
-  // calling callback if PWGRasterConverterImpl is destroyed.
+  // calling callback if PwgRasterConverterImpl is destroyed.
   callback_ = std::move(callback);
-  utility_client_ = base::MakeRefCounted<PWGRasterConverterHelper>(
+  utility_client_ = base::MakeRefCounted<PwgRasterConverterHelper>(
       conversion_settings, bitmap_settings);
   utility_client_->Convert(data,
-                           base::BindOnce(&PWGRasterConverterImpl::RunCallback,
+                           base::BindOnce(&PwgRasterConverterImpl::RunCallback,
                                           weak_ptr_factory_.GetWeakPtr()));
 }
 
-void PWGRasterConverterImpl::RunCallback(bool success,
+void PwgRasterConverterImpl::RunCallback(bool success,
                                          const base::FilePath& temp_file) {
   std::move(callback_).Run(success, temp_file);
 }
@@ -246,12 +245,12 @@ void PWGRasterConverterImpl::RunCallback(bool success,
 }  // namespace
 
 // static
-std::unique_ptr<PWGRasterConverter> PWGRasterConverter::CreateDefault() {
-  return base::MakeUnique<PWGRasterConverterImpl>();
+std::unique_ptr<PwgRasterConverter> PwgRasterConverter::CreateDefault() {
+  return base::MakeUnique<PwgRasterConverterImpl>();
 }
 
 // static
-PdfRenderSettings PWGRasterConverter::GetConversionSettings(
+PdfRenderSettings PwgRasterConverter::GetConversionSettings(
     const cloud_devices::CloudDeviceDescription& printer_capabilities,
     const gfx::Size& page_size) {
   int dpi = kDefaultPdfDpi;
@@ -270,7 +269,7 @@ PdfRenderSettings PWGRasterConverter::GetConversionSettings(
 }
 
 // static
-PwgRasterSettings PWGRasterConverter::GetBitmapSettings(
+PwgRasterSettings PwgRasterConverter::GetBitmapSettings(
     const cloud_devices::CloudDeviceDescription& printer_capabilities,
     const cloud_devices::CloudDeviceDescription& ticket) {
   cloud_devices::printer::DuplexTicketItem duplex_item;

chrome/browser/printing/pwg_raster_converter.h

@@ -27,7 +27,7 @@ namespace printing {
 
 struct PwgRasterSettings;
 
-class PWGRasterConverter {
+class PwgRasterConverter {
  public:
   // Callback for when the PDF is converted to a PWG raster.
   // |success| denotes whether the conversion succeeded.
@@ -37,9 +37,9 @@ class PWGRasterConverter {
       base::OnceCallback<void(bool /*success*/,
                               const base::FilePath& /*temp_file*/)>;
 
-  virtual ~PWGRasterConverter() {}
+  virtual ~PwgRasterConverter() {}
 
-  static std::unique_ptr<PWGRasterConverter> CreateDefault();
+  static std::unique_ptr<PwgRasterConverter> CreateDefault();
 
   // Generates conversion settings to be used with converter from printer
   // capabilities and page size.

chrome/browser/printing/pwg_raster_converter_browsertest.cc

@@ -36,7 +36,7 @@ void ResultCallbackImpl(bool* called,
 class PdfToPwgRasterBrowserTest : public InProcessBrowserTest {
  public:
   PdfToPwgRasterBrowserTest()
-      : converter_(PWGRasterConverter::CreateDefault()) {}
+      : converter_(PwgRasterConverter::CreateDefault()) {}
   ~PdfToPwgRasterBrowserTest() override {}
 
   void Convert(base::RefCountedMemory* pdf_data,
@@ -56,7 +56,7 @@ class PdfToPwgRasterBrowserTest : public InProcessBrowserTest {
   }
 
  private:
-  std::unique_ptr<PWGRasterConverter> converter_;
+  std::unique_ptr<PwgRasterConverter> converter_;
 };
 
 std::string HashFile(const std::string& file_data) {

chrome/browser/ui/webui/print_preview/extension_printer_handler.cc

@@ -45,7 +45,7 @@ using extensions::Extension;
 using extensions::ExtensionRegistry;
 using extensions::ListBuilder;
 using extensions::UsbPrinterManifestData;
-using printing::PWGRasterConverter;
+using printing::PwgRasterConverter;
 
 namespace {
 
@@ -253,8 +253,8 @@ void ExtensionPrinterHandler::StartGrantPrinterAccess(
                          weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
-void ExtensionPrinterHandler::SetPWGRasterConverterForTesting(
-    std::unique_ptr<PWGRasterConverter> pwg_raster_converter) {
+void ExtensionPrinterHandler::SetPwgRasterConverterForTesting(
+    std::unique_ptr<PwgRasterConverter> pwg_raster_converter) {
   pwg_raster_converter_ = std::move(pwg_raster_converter);
 }
 
@@ -266,12 +266,12 @@ void ExtensionPrinterHandler::ConvertToPWGRaster(
     std::unique_ptr<extensions::PrinterProviderPrintJob> job,
     PrintJobCallback callback) {
   if (!pwg_raster_converter_) {
-    pwg_raster_converter_ = PWGRasterConverter::CreateDefault();
+    pwg_raster_converter_ = PwgRasterConverter::CreateDefault();
   }
   pwg_raster_converter_->Start(
       data.get(),
-      PWGRasterConverter::GetConversionSettings(printer_description, page_size),
-      PWGRasterConverter::GetBitmapSettings(printer_description, ticket),
+      PwgRasterConverter::GetConversionSettings(printer_description, page_size),
+      PwgRasterConverter::GetBitmapSettings(printer_description, ticket),
       base::BindOnce(&UpdateJobFileInfo, std::move(job), std::move(callback)));
 }
 

chrome/browser/ui/webui/print_preview/extension_printer_handler.h

@@ -37,7 +37,7 @@ class Size;
 }
 
 namespace printing {
-class PWGRasterConverter;
+class PwgRasterConverter;
 }
 
 // Implementation of PrinterHandler interface backed by printerProvider
@@ -71,8 +71,8 @@ class ExtensionPrinterHandler : public PrinterHandler {
  private:
   friend class ExtensionPrinterHandlerTest;
 
-  void SetPWGRasterConverterForTesting(
-      std::unique_ptr<printing::PWGRasterConverter> pwg_raster_converter);
+  void SetPwgRasterConverterForTesting(
+      std::unique_ptr<printing::PwgRasterConverter> pwg_raster_converter);
 
   // Converts |data| to PWG raster format (from PDF) for a printer described
   // by |printer_description|.
@@ -109,7 +109,7 @@ class ExtensionPrinterHandler : public PrinterHandler {
   Profile* const profile_;
   GetPrintersDoneCallback done_callback_;
   PrintJobCallback print_job_callback_;
-  std::unique_ptr<printing::PWGRasterConverter> pwg_raster_converter_;
+  std::unique_ptr<printing::PwgRasterConverter> pwg_raster_converter_;
   int pending_enumeration_count_ = 0;
 
   base::WeakPtrFactory<ExtensionPrinterHandler> weak_ptr_factory_;

chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc

@@ -53,7 +53,7 @@ using extensions::Extension;
 using extensions::PrinterProviderAPI;
 using extensions::PrinterProviderPrintJob;
 using extensions::TestExtensionEnvironment;
-using printing::PWGRasterConverter;
+using printing::PwgRasterConverter;
 
 namespace {
 
@@ -276,13 +276,13 @@ std::string RefCountedMemoryToString(
   return std::string(memory->front_as<char>(), memory->size());
 }
 
-// Fake PWGRasterConverter used in the tests.
-class FakePWGRasterConverter : public PWGRasterConverter {
+// Fake PwgRasterConverter used in the tests.
+class FakePwgRasterConverter : public PwgRasterConverter {
  public:
-  FakePWGRasterConverter() : fail_conversion_(false), initialized_(false) {}
-  ~FakePWGRasterConverter() override = default;
+  FakePwgRasterConverter() : fail_conversion_(false), initialized_(false) {}
+  ~FakePwgRasterConverter() override = default;
 
-  // PWGRasterConverter implementation. It writes |data| to a temp file.
+  // PwgRasterConverter implementation. It writes |data| to a temp file.
   // Also, remembers conversion and bitmap settings passed into the method.
   void Start(base::RefCountedMemory* data,
              const printing::PdfRenderSettings& conversion_settings,
@@ -337,7 +337,7 @@ class FakePWGRasterConverter : public PWGRasterConverter {
   bool fail_conversion_;
   bool initialized_;
 
-  DISALLOW_COPY_AND_ASSIGN(FakePWGRasterConverter);
+  DISALLOW_COPY_AND_ASSIGN(FakePwgRasterConverter);
 };
 
 // Information about received print requests.
@@ -472,9 +472,9 @@ class ExtensionPrinterHandlerTest : public testing::Test {
     extension_printer_handler_ =
         base::MakeUnique<ExtensionPrinterHandler>(env_.profile());
 
-    auto pwg_raster_converter = base::MakeUnique<FakePWGRasterConverter>();
+    auto pwg_raster_converter = base::MakeUnique<FakePwgRasterConverter>();
     pwg_raster_converter_ = pwg_raster_converter.get();
-    extension_printer_handler_->SetPWGRasterConverterForTesting(
+    extension_printer_handler_->SetPwgRasterConverterForTesting(
         std::move(pwg_raster_converter));
   }
 
@@ -494,7 +494,7 @@ class ExtensionPrinterHandlerTest : public testing::Test {
   std::unique_ptr<ExtensionPrinterHandler> extension_printer_handler_;
 
   // Owned by |extension_printer_handler_|.
-  FakePWGRasterConverter* pwg_raster_converter_ = nullptr;
+  FakePwgRasterConverter* pwg_raster_converter_ = nullptr;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrinterHandlerTest);