Interrogate PpdProvider from PrintPreview.

chrome/browser/ui/webui/print_preview/print_preview_handler.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/ui/webui/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 #include <stddef.h>
 
 #include <map>
@@ skipping 500 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(AccessTokenService);
 };
 
 PrintPreviewHandler::PrintPreviewHandler()
     : regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
       manage_cloud_printers_dialog_request_count_(0),
       reported_failed_preview_(false),
       has_logged_printers_count_(false),
-      gaia_cookie_manager_service_(NULL),
+      gaia_cookie_manager_service_(nullptr),
+      printer_backend_proxy_(nullptr),
       weak_factory_(this) {
   ReportUserActionHistogram(PREVIEW_STARTED);
 }
 
 PrintPreviewHandler::~PrintPreviewHandler() {
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 
   UnregisterForGaiaCookieChanges();
 }
@@ skipping 72 matching lines @@
 }
 
 WebContents* PrintPreviewHandler::preview_web_contents() const {
   return web_ui()->GetWebContents();
 }
 
 PrintPreviewUI* PrintPreviewHandler::print_preview_ui() const {
   return static_cast<PrintPreviewUI*>(web_ui()->GetController());
 }
 
+printing::PrinterBackendProxy* PrintPreviewHandler::printer_backend_proxy() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (!printer_backend_proxy_) {
+#if defined(OS_CHROMEOS)
+    // ChromeOS stores printer information in printer prefs which requires a
+    // profile.  Other plaforms retrieve printer information from OS resources.
+    printer_backend_proxy_ =
+        printing::PrinterBackendProxy::Create(Profile::FromWebUI(web_ui()));
+#else
+    printer_backend_proxy_ = printing::PrinterBackendProxy::Create();
+#endif
+  }
+
+  return printer_backend_proxy_.get();
+}
+
 void PrintPreviewHandler::HandleGetPrinters(const base::ListValue* /*args*/) {
   VLOG(1) << "Enumerate printers start";
-  printing::EnumeratePrinters(Profile::FromWebUI(web_ui()),
-                              base::Bind(&PrintPreviewHandler::SetupPrinterList,
-                                         weak_factory_.GetWeakPtr()));
+  printer_backend_proxy()->EnumeratePrinters(base::Bind(
+      &PrintPreviewHandler::SetupPrinterList, weak_factory_.GetWeakPtr()));
 }
 
 void PrintPreviewHandler::HandleGetPrivetPrinters(const base::ListValue* args) {
   if (!PrivetPrintingEnabled())
     return web_ui()->CallJavascriptFunctionUnsafe("onPrivetPrinterSearchDone");
 #if BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
   using local_discovery::ServiceDiscoverySharedClient;
   scoped_refptr<ServiceDiscoverySharedClient> service_discovery =
       ServiceDiscoverySharedClient::GetInstance();
   StartPrivetLister(service_discovery);
@@ skipping 393 matching lines @@
         printing::kPrinterCapabilities,
         GetPdfCapabilities(g_browser_process->GetApplicationLocale()));
     SendPrinterCapabilities(printer_name, std::move(printer_info));
     return;
   }
 
   printing::PrinterSetupCallback cb =
       base::Bind(&PrintPreviewHandler::SendPrinterCapabilities,
                  weak_factory_.GetWeakPtr(), printer_name);
 
-  printing::ConfigurePrinterAndFetchCapabilities(Profile::FromWebUI(web_ui()),
-                                                 printer_name, cb);
+  printer_backend_proxy()->ConfigurePrinterAndFetchCapabilities(printer_name,
+                                                                cb);
 }
 
 void PrintPreviewHandler::OnSigninComplete() {
   if (print_preview_ui())
     print_preview_ui()->OnReloadPrintersList();
 }
 
 void PrintPreviewHandler::HandleSignin(const base::ListValue* args) {
   bool add_account = false;
   bool success = args->GetBoolean(0, &add_account);
@@ skipping 101 matching lines @@
   // Getting the number formatting based on the locale and writing to
   // dictionary.
   settings->SetString(kNumberFormat, base::FormatDouble(123456.78, 2));
   settings->SetInteger(kMeasurementSystem, system);
 }
 
 void PrintPreviewHandler::HandleGetInitialSettings(
     const base::ListValue* /*args*/) {
   // Send before SendInitialSettings() to allow cloud printer auto select.
   SendCloudPrintEnabled();
-  base::PostTaskAndReplyWithResult(
-      BrowserThread::GetBlockingPool(), FROM_HERE,
-      base::Bind(&printing::GetDefaultPrinterOnBlockingPoolThread),
-      base::Bind(&PrintPreviewHandler::SendInitialSettings,
-                 weak_factory_.GetWeakPtr()));
+  printer_backend_proxy()->GetDefaultPrinter(base::Bind(
+      &PrintPreviewHandler::SendInitialSettings, weak_factory_.GetWeakPtr()));
 }
 
 void PrintPreviewHandler::HandleForceOpenNewTab(const base::ListValue* args) {
   std::string url;
   if (!args->GetString(0, &url))
     return;
   Browser* browser = chrome::FindBrowserWithWebContents(GetInitiator());
   if (!browser)
     return;
   chrome::AddSelectedTabWithURL(browser,
@@ skipping 532 matching lines @@
 
 void PrintPreviewHandler::UnregisterForGaiaCookieChanges() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
 }
 
 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
     const base::Closure& closure) {
   pdf_file_saved_closure_ = closure;
 }