Perform printer setup on Chrome OS before selecting printer.

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 552 matching lines @@
   web_ui()->RegisterMessageCallback("getPreview",
       base::Bind(&PrintPreviewHandler::HandleGetPreview,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("print",
       base::Bind(&PrintPreviewHandler::HandlePrint,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "getPrinterCapabilities",
       base::Bind(&PrintPreviewHandler::HandleGetPrinterCapabilities,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "setupPrinter", base::Bind(&PrintPreviewHandler::HandlePrinterSetup,
+                                 base::Unretained(this)));
 #if BUILDFLAG(ENABLE_BASIC_PRINT_DIALOG)
   web_ui()->RegisterMessageCallback("showSystemDialog",
       base::Bind(&PrintPreviewHandler::HandleShowSystemDialog,
                  base::Unretained(this)));
 #endif
   web_ui()->RegisterMessageCallback("signIn",
       base::Bind(&PrintPreviewHandler::HandleSignin,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getAccessToken",
       base::Bind(&PrintPreviewHandler::HandleGetAccessToken,
@@ skipping 489 matching lines @@
   }
 
   printing::PrinterSetupCallback cb =
       base::Bind(&PrintPreviewHandler::SendPrinterCapabilities,
                  weak_factory_.GetWeakPtr(), printer_name);
 
   printer_backend_proxy()->ConfigurePrinterAndFetchCapabilities(printer_name,
                                                                 cb);
 }
 
+// |args| is expected to contain a string with representing the callback id
+// followed by a list of arguments the first of which should be the printer id.
+void PrintPreviewHandler::HandlePrinterSetup(const base::ListValue* args) {
+  AllowJavascript();
+
+  std::string callback_id;
+  std::string printer_name;
+  const base::ListValue* real_args;
+  if (!args->GetString(0, &callback_id) || !args->GetList(1, &real_args) ||
+      !real_args->GetString(0, &printer_name) || callback_id.empty() ||
+      printer_name.empty()) {
+    RejectJavascriptCallback(base::StringValue(callback_id),
+                             base::StringValue(printer_name));
+    return;
+  }
+
+  printer_backend_proxy()->ConfigurePrinterAndFetchCapabilities(
+      printer_name,
+      base::Bind(&PrintPreviewHandler::SendPrinterSetup,
+                 weak_factory_.GetWeakPtr(), callback_id, printer_name));
+}
+
 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);
   DCHECK(success);
 
@@ skipping 180 matching lines @@
     VLOG(1) << "Get printer capabilities failed";
     web_ui()->CallJavascriptFunctionUnsafe("failedToGetPrinterCapabilities",
                                            base::StringValue(printer_name));
     return;
   }
   VLOG(1) << "Get printer capabilities finished";
   web_ui()->CallJavascriptFunctionUnsafe("updateWithPrinterCapabilities",
                                          *settings_info);
 }
 
+void PrintPreviewHandler::SendPrinterSetup(
+    const std::string& callback_id,
+    const std::string& printer_name,
+    std::unique_ptr<base::DictionaryValue> destination_info) {
+  auto response = base::MakeUnique<base::DictionaryValue>();
+  bool success = true;
+  auto caps_value = base::Value::CreateNullValue();
+  auto caps = base::MakeUnique<base::DictionaryValue>();
+  if (destination_info &&
+      destination_info->Remove(printing::kPrinterCapabilities, &caps_value) &&
+      caps_value->IsType(base::Value::Type::DICTIONARY)) {
+    caps = base::DictionaryValue::From(std::move(caps_value));
+  } else {
+    LOG(WARNING) << "Printer setup failed";
+    success = false;
+  }
+
+  response->SetString("printerId", printer_name);
+  response->SetBoolean("success", success);
+  response->Set("capabilities", std::move(caps));
+
+  ResolveJavascriptCallback(base::StringValue(callback_id), *response);
+}
+
 void PrintPreviewHandler::SetupPrinterList(
     const printing::PrinterList& printer_list) {
   base::ListValue printers;
   PrintersToValues(printer_list, &printers);
 
   VLOG(1) << "Enumerate printers finished, found " << printers.GetSize()
           << " printers";
 
   if (!has_logged_printers_count_) {
     UMA_HISTOGRAM_COUNTS("PrintPreview.NumberOfPrinters", printers.GetSize());
@@ skipping 453 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;
 }