Make PrinterProviderAPI a pure interface

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

 // Copyright 2015 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/ui/webui/print_preview/extension_printer_handler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/local_discovery/pwg_raster_converter.h"
 #include "components/cloud_devices/common/cloud_device_description.h"
 #include "components/cloud_devices/common/printer_description.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api.h"
+#include "extensions/browser/api/printer_provider/printer_provider_api_factory.h"
+#include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
 #include "printing/pdf_render_settings.h"
 #include "printing/pwg_raster_settings.h"
 
 using local_discovery::PWGRasterConverter;
 
 namespace {
 
 const char kContentTypePdf[] = "application/pdf";
 const char kContentTypePWGRaster[] = "image/pwg-raster";
 const char kContentTypeAll[] = "*/*";
@@ skipping 48 matching lines @@
 }
 
 void ExtensionPrinterHandler::Reset() {
   // TODO(tbarzic): Keep track of pending request ids issued by |this| and
   // cancel them from here.
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void ExtensionPrinterHandler::StartGetPrinters(
     const PrinterHandler::GetPrintersCallback& callback) {
-  extensions::PrinterProviderAPI::GetFactoryInstance()
-      ->Get(browser_context_)
+  extensions::PrinterProviderAPIFactory::GetInstance()
+      ->GetForBrowserContext(browser_context_)
       ->DispatchGetPrintersRequested(
           base::Bind(&ExtensionPrinterHandler::WrapGetPrintersCallback,
                      weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void ExtensionPrinterHandler::StartGetCapability(
     const std::string& destination_id,
     const PrinterHandler::GetCapabilityCallback& callback) {
-  extensions::PrinterProviderAPI::GetFactoryInstance()
-      ->Get(browser_context_)
+  extensions::PrinterProviderAPIFactory::GetInstance()
+      ->GetForBrowserContext(browser_context_)
       ->DispatchGetCapabilityRequested(
           destination_id,
           base::Bind(&ExtensionPrinterHandler::WrapGetCapabilityCallback,
                      weak_ptr_factory_.GetWeakPtr(), callback, destination_id));
 }
 
 void ExtensionPrinterHandler::StartPrint(
     const std::string& destination_id,
     const std::string& capability,
     const std::string& ticket_json,
     const gfx::Size& page_size,
     const scoped_refptr<base::RefCountedMemory>& print_data,
     const PrinterHandler::PrintCallback& callback) {
-  scoped_ptr<extensions::PrinterProviderAPI::PrintJob> print_job(
-      new extensions::PrinterProviderAPI::PrintJob());
+  scoped_ptr<extensions::PrinterProviderPrintJob> print_job(
+      new extensions::PrinterProviderPrintJob());
   print_job->printer_id = destination_id;
   print_job->ticket_json = ticket_json;
 
   cloud_devices::CloudDeviceDescription printer_description;
   printer_description.InitFromString(capability);
 
   cloud_devices::printer::ContentTypesCapability content_types;
   content_types.LoadFrom(printer_description);
 
   const bool kUsePdf = content_types.Contains(kContentTypePdf) ||
@@ skipping 29 matching lines @@
   }
   pwg_raster_converter_->Start(
       data.get(),
       PWGRasterConverter::GetConversionSettings(printer_description, page_size),
       PWGRasterConverter::GetBitmapSettings(printer_description, ticket),
       base::Bind(&ReadConvertedPWGRasterFile, callback));
 }
 
 void ExtensionPrinterHandler::DispatchPrintJob(
     const PrinterHandler::PrintCallback& callback,
-    scoped_ptr<extensions::PrinterProviderAPI::PrintJob> print_job,
+    scoped_ptr<extensions::PrinterProviderPrintJob> print_job,
     const scoped_refptr<base::RefCountedMemory>& print_data) {
   if (!print_data) {
     WrapPrintCallback(callback, false, kInvalidDataPrintError);
     return;
   }
 
   print_job->document_bytes = print_data;
 
-  extensions::PrinterProviderAPI::GetFactoryInstance()
-      ->Get(browser_context_)
+  extensions::PrinterProviderAPIFactory::GetInstance()
+      ->GetForBrowserContext(browser_context_)
       ->DispatchPrintRequested(
           *print_job, base::Bind(&ExtensionPrinterHandler::WrapPrintCallback,
                                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void ExtensionPrinterHandler::WrapGetPrintersCallback(
     const PrinterHandler::GetPrintersCallback& callback,
     const base::ListValue& printers,
     bool done) {
   callback.Run(printers, done);
 }
 
 void ExtensionPrinterHandler::WrapGetCapabilityCallback(
     const PrinterHandler::GetCapabilityCallback& callback,
     const std::string& destination_id,
     const base::DictionaryValue& capability) {
   callback.Run(destination_id, capability);
 }
 
 void ExtensionPrinterHandler::WrapPrintCallback(
     const PrinterHandler::PrintCallback& callback,
     bool success,
     const std::string& status) {
   callback.Run(success, status);
 }