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() {

[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) {
   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 103 matching lines @@
   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(

[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()));
 }
 
 void PrintPreviewHandler::HandleForceOpenNewTab(const base::ListValue* args) {
   std::string url;
   if (!args->GetString(0, &url))
     return;
   Browser* browser = chrome::FindBrowserWithWebContents(GetInitiator());
   if (!browser)
@@ skipping 534 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;
 }