Interrogate PpdProvider from PrintPreview.

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

Index: chrome/browser/ui/webui/print_preview/print_preview_handler.cc
diff --git a/chrome/browser/ui/webui/print_preview/print_preview_handler.cc b/chrome/browser/ui/webui/print_preview/print_preview_handler.cc
index de2fc1255d17e2a97ba53f2257c88a3671bd04f6..73145508da9d4512580271a9f0a3e9ccaf7a500a 100644
--- a/chrome/browser/ui/webui/print_preview/print_preview_handler.cc
+++ b/chrome/browser/ui/webui/print_preview/print_preview_handler.cc
@@ -518,7 +518,8 @@ PrintPreviewHandler::PrintPreviewHandler()
       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);
 }
@@ -611,11 +612,23 @@ PrintPreviewUI* PrintPreviewHandler::print_preview_ui() const {
   return static_cast<PrintPreviewUI*>(web_ui()->GetController());
 }
 
+printing::PrinterBackendProxy* PrintPreviewHandler::printer_backend_proxy() {

[Carlson, 2016/12/02 19:10:22]

This should run on the UI thread, right?  Add a DCHECK?

[skau, 2016/12/05 23:13:34]

No.  The proxy is actually designed to run on the UI thread and handle making
calls into the blocking pool.

[Carlson, 2016/12/05 23:45:58]

I don't understand your response here.  Is this function run on the UI thread or
not?

I sure hope it *is* on the UI thread because we are definitely making a
sequenced assumption with the handling of printer_backend_proxy_ initialization.

[skau, 2016/12/06 23:20:08]

I misread your comment.  I've added the DCHECK.  It *is* on the UI thread.  I've
also fixed the proxy so the public methods are always called on the UI thread.

+  if (!printer_backend_proxy_) {
+#if defined(OS_CHROMEOS)
+    printer_backend_proxy_ =
+        printing::PrinterBackendProxy::Create(Profile::FromWebUI(web_ui()));

[Carlson, 2016/12/02 19:10:22]

The reason for the multiplexing of proxies here deserves a comment or a doc
link.

[skau, 2016/12/05 23:13:34]

Done.

+#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) {
@@ -1029,8 +1042,8 @@ void PrintPreviewHandler::HandleGetPrinterCapabilities(
       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() {
@@ -1154,7 +1167,9 @@ void PrintPreviewHandler::HandleGetInitialSettings(
   SendCloudPrintEnabled();
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(), FROM_HERE,
-      base::Bind(&printing::GetDefaultPrinterOnBlockingPoolThread),
+      base::Bind(

[Carlson, 2016/12/02 19:10:22]

Is this safe?  The second bind is weak ptr based, so should do something sane in
the cancellation case, but the first Bind() takes a pointer to an internal class
member and is *not* weak ptr based.  I don't really know the guts of the
weak-ptr-cancellation mechanism very well, but this seems fishy.

[skau, 2016/12/05 23:13:34]

I need to think about this a little.  WeakPtrs aren't thread safe. I have to
double check what happens if PrintPreviewHandler is collected while
GetDefaultPrinter... is running.  Thanks for the catch.

[skau, 2016/12/06 23:20:08]

This has been fixed so that we dispatch the call from the UI thread and I've
checked that all callbacks are bound with WeakPtrs so they'll cancel safely if
PrintPreviewHandler gets collected.

+          &printing::PrinterBackendProxy::GetDefaultPrinterOnBlockingPoolThread,
+          base::Unretained(printer_backend_proxy())),
       base::Bind(&PrintPreviewHandler::SendInitialSettings,
                  weak_factory_.GetWeakPtr()));
 }